1米平方之python

def test_array():
    names=["yzl","hh","hr","nb","em"]
    print(f'names = {names}')
    print(f'names[0] = {names[0]}')
    print(f'names[1] = {names[1]}')
    names[1]="New Times"
    print(f'After names[1]="New Times" , names = {names}')
    names.append("ending")
    print(f'After names.append("ending") , names = {names}')
    names.insert(2,"second")
    print(f'After names.insert(2, "second") , names = {names}')
    print(f' Before pop(2) names= {names}')
    print(f' names.pop(2) = {names.pop(2)}')
    print(f' After pop(2) names= {names}')
    print(f' names.pop(1) = {names.pop(1)}')
    print(f' After pop(1) names= {names}')
    print(f' namees.index("hr") = {names.index("hr")}')
    print(f' namees.index("nb") = {names.index("nb")}')
    print(f' names[namees.index("nb")] = {names[names.index("nb")]}')
    print(f'names[2]={names[2]}')
    print(f'names[0]={names[0]}')
    print(f'names[1]={names[1]}')
    print(f'names[0:3]={names[0:3]}')
    print(f'names[1:-1]={names[1:-1]}')

def test_ArrayCopy():
    names=["zym","ys","lkp",["abc","def"],"qx","zb"]
    ## copy()是浅拷贝，只copy第一层，其它层走引用
    ## ***************第一种类型： 完全指针拷贝, 修改后完全相关***************
    namesCopy=names
    ## ***************第二种类型： 浅拷贝  第一层值拷贝  第二层指针拷贝，修改后部分相关(第一层不相关)***************
    # namesCopy=names.copy() ## 1. 数组copy等效于copy.copy(names)
    # namesCopy=names[:] ## 2. 数组切片等效于copy.copy(names)
    # namesCopy=list(names) ## 3. 工厂函数list(names)等效于copy.copy(names)
    # namesCopy=copy.copy(names)
    ## ***************第三种类型： 深拷贝(完全不相关，各自一份内存)***************
    # namesCopy=copy.deepcopy(names)

    ## 第一层是 值拷贝
    names[2]="lukunpeng"
    print(f'names={names}')
    print(f'namesCopy={namesCopy}')
    ## 第二层是 指针拷贝
    names[3][1]="123"
    print(f'names={names}')
    print(f'namesCopy={namesCopy}')

    ## 浅copy适用场景   夫妻共用一个财务账号  即夫妻姓名是不同，账号是共享 设计一个数据结构 [names,[saving,money]]
    ## 场景中考虑到内存部分共享，则考虑浅拷贝， 如果内存完全不共享，则为深拷贝
    # 数据是否共享?
    man=['Apple',['Saving',1000]]
    woman=man[:]
    woman[0]='Banana'
    print(f'man= {man}  \t women ={woman} ')
    woman[1][1]=woman[1][1]-100  ### 花了100块钱，总存款就少了
    print(f'Women spent 100 dollar \n\t man= {man}  \t women ={woman} ')

def test_tuple():
    ## 元组内容不可变
    product_list=[
        ('Ipod Watch',2000),
        ('Ipad', 7000),
        ('Iphone', 10000),
        ('Huawei P40', 8000),
        ('RongYao Magic3 ZhiZhen', 7400)
    ]
    shoppign_cart=[]
    print(f'product_list = {product_list}')
    print(f'product_list[0,1] = {product_list[0][1]}')
    salary=input('Input your salay: ')
    if salary.isdigit():
        salary=int(salary)
        while True:
            # for item in product_list:
            #     print(f'{product_list.index(item)}  {item}')  ## 回忆之前的知识点
            ## 更简捷方式 使用enumerate
            ## 新知识点1
            for index,item in enumerate(product_list):
                print(f'{index} {item}')
            user_choice=input('Input series no what you wanna buy: ')
            if user_choice.isdigit():
                user_choice=int(user_choice) ## 新知识点2
                if user_choice < len(product_list) and user_choice>=0:    # product_list.count("ffff"): count是用来获取某个元素出现的次数
                    ## 增加限制条件user_choice >0
                    if salary<product_list[user_choice][1]:
                        print(f'\033[1;34m  money is not enough, please try again! \033[0m')
                    else:
                        print(f'got it, give you your gift {product_list[user_choice][0]}')
                        salary=salary-product_list[user_choice][1] ###更新你的工资
                        #salary -= product_list[user_choice][1] ###也可以简写
                        shoppign_cart.append(product_list[user_choice])
                        print(f'{product_list[user_choice][0]} has been added into the shoppign_cart; \n \033[1;32m how much you have now? {salary}, you can go on shopping \033[0m')
                else:
                    print(f'\033[1;31m Warning!  Please input the number less than {len(product_list)} \033[0m')
                    continue
            elif user_choice=='q':
                print(f'buy buy, your shoppign_cart has {shoppign_cart}')
                print("shopping cart".center(50,'-'))
                for index,item in shoppign_cart:
                    print(f'{index} -> {item}')
                print(f'Your current balance is {salary}')
                print(f'welcome back')
                # exit() # exit直接退出这个程序， 会避免影响另外一个程序运行 先用break即可,退出无限循环
                break
            else:
                print(f'\033[1;31m Invalid Option \033[0m')

for i in range(20):
    sys.stdout.write('#')
    sys.stdout.flush()
    time.sleep(0.1)

## 生成器测试
## 生成器串行
def fib_max(max):
    n,a,b=0,0,1
    while n<=max:
        yield b  ## 生成器生成  用于返回需要从算法里面中间计算得到的值  当前状态值！
        a,b=b,a+b
        n=n+1
    return '*--done--*'

def test_generator():
  print(f'a=[1,2,3,4,5,7,8] = {[1,2,3,4,5,7,8]}')
  print(f'[i*2 for  i in range(1,10,1)]  = {[i*2 for  i in range(1,10,1)]}')
  print(f'(i*2 for i in range(1,10,1)) = {(i*2 for i in range(1,10,1))}')
  ## 生成器小括号，一般是存储算法到内存，而不是像列表把所有数据导入内存中
  g=fib_max(6)
  while True:
      try:
          x= next(g)
          print(f'g= {x}')
      except StopIteration as e:
          print(f'Generator exception return value {e.value}')
          break

## 生成器并行: 生产者-消费者模式
def consume(name):
    print(f'\033[31;1m Inside consume:\033[0m 准备吃包子了{name}')
    while True:
        baozi=yield
        print(f'\033[31;1m Inside Consume:\033[0m 包子{baozi}来了，被{name}吃了')

## 生成器并行: 生产者-消费者模式
## 不要小瞧这段代码，它是异步IO的雏形，nginx的前身，nginx为什么效率那么高，因为它是异步
## 虽然当前代码依然是串行，但由于切换不同角色，且执行速度快，所有有点看起来是并行程序。

def producer(name):
    print(f'\033[1;32m 老子{name}准备做包子了 \033[0m')
    c1=consume('Wen Zongli')
    c2=consume('Zhou Zongli')
    c1.__next__()
    c2.__next__()

    for i  in range(10):
        time.sleep(1)
        print(f'\033[1;33m  做了1个包子  分成凉拌\033[0m')
        c1.send(i)
        c2.send(i)

from collections.abc import Iterable
isinstance('[]',Iterable)
isinstance('{}',Iterable)
isinstance('abc',Iterable)
isinstance('set(1,3,5)',Iterable)
isinstance('(abc)',Iterable)

from collections.abc import Iterator
isinstance('abc',Iterator) ## false
a= [1,2,3]
dir(a)## 查看a可以调用的所有内部方法  dir是python中一个相当重要的命令
isinstance('(x*2 for x in range(10))',Iterator) ## True

from collections.abc import Iterator
isinstance('iter(abc)',Iterator) ## false
a= [1,2,3]
isinstance('iter(a)',Iterator)

## compile and exec
code="for i in range(10):print(i)"
c=compile(code,"",'exec')
exec(c)

code2="1+2+3*4/29.2"
c2=compile(code2,'','eval') ## eval其实可以直接调用
eval(c2)
## compile甚至可以变到更大的代码段，类似动态导入的过程！ 动态import代码的过程！

[global]
timeout = 60
index-url = http://pypi.douban.com/simple
trusted-host = pypi.douban.com

transaction(tran_type,account,amount,logger)

from loguru import  logger  ## 好处是加快logger执行速度，同事logger 也可以起个别名，如果直接import loguru, 调用多次logger, 还得多次loguru.logger.info。
"""
import 本质是路径搜索 类似DNS 路由
会把对应文件模块解释一遍
"""

"""
包的本质是存储多个模块，就多个py文件，一个包里里面必须有一个__init__.py文件
专业表示：逻辑上组织模块是包
逻辑上组织python代码（比如类、变量、函数、关系等）叫做模块

导入模块的本质是把模块文件解释一遍
导入包的本质是把模块的__init__.py文件执行一遍(run __init__.py)（与模块有所区别）

run __init__.py 很关键， 也就是以后导入包的模块通过，包同级导入，即相对路径导入
比如： core目录下，我在__init__.py执行  from . import testModule,test_pickle_loads 等，但是不能import testModule, 因为import
此时是绝对导入，不具有以当前包围相对坐标系的功能。
所以run __init__.py的理解很重要  .代表的是__init__.py所在路径


"""
def sayHelloInModule(name):
    logger.info(f'hello world Mr|MRs{name}')
    ## sys.path就是一个列表 list  环境变量组合  想要import模块或者包必须保证模块或者包在我们的sys.path目录下能够找到，所以sys.path类似于操作系统的环境变量
    # logger.info(f'current sys.path = {sys.path}')

class Man(People,Relation):
    super(Man,self).__init__(self,name,age) <--super解决多继承问题（java只有单继承）

## 经典类  多继承优先找的是临近类
class A:
    pass

## 新式类  多继承优先找的是临近类
class A(Object):
    pass

def hell(self):
    print(f'hho')

Foo=type('Foo',(object),{'talk':hell}) ##object也可以省略，当前为新式类写法
f=Foo() ## Foo 其实是type的对象
f.talk() ##等价于调用hell()

def hellInit(self):
    print(f'hho {self.name}')

def __init__(self,name,age):
    self.name=name
    self.age = age
FooInit=type('FooInit',(object,),{'talk':hellInit,
                                  '__init__':__init__}) ##object也可以省略，当前为新式类写法

f2=FooInit('Ale',33)
f2.talk()

d=Dog("xiaowang")
choice=input(">>").strip()
## 简化很多代码
if(hasattr(d, choice)):
    getattr(d,choice)
else:
    setattr(d,choice,bulk)
    func=getattr(d,choice)
    func(d)
#    setattr(d,"newFunction",bulk)
#    d.newFunction()

## 前提，我只知道模块名字的字符串形式，如何动态导入类，并通过反射获得模块内的类、方法等
mod=__import__("lib.aa")
print(f'mod={mod}')
instance = getattr(mod.aa,"C")