python迭代器，生成器，装饰器

 1 l1 = ["hello","world",1,2]
 2 
 3 #for循环调用可迭代对象的__next__方法去取值，而且for循环会捕捉StopIteration异常，以终止对象
 4 for i in l1:
 5     print(i)
 6 
 7 aa = l1.__iter__()  #等同于内置函数aa = iter(l1) 创建了一个list_iterator 列表迭代器
 8 print(type(aa))
 9 print(next(aa))   #内置函数 next()查看第一次迭代器的值
10 print(aa.__next__())   #迭代器本身对象的方法，第二次迭代器的值   跟 内置函数方法都是一样的
11 print(next(aa))
12 print(next(aa))
13 print(next(aa))  #没有可迭代的值了也就是迭代完了，会报错：StopIteration
14 
15 
16 #迭代器迭代完，就不能再次迭代该迭代器 比如for 循环
17 for i in aa:
18     print(i)

 1 # 首先获得Iterator对象:
 2 it = iter([1, 2, 3, 4, 5]) #创建一个迭代器
 3 # 循环:
 4 while True:
 5     try:
 6         # 获得下一个值:
 7         x = next(it)
 8         print(x)
 9     except StopIteration:
10         # 遇到StopIteration就退出循环
11         break

 1 #列表生成式通过计算生成一个列表
 2 
 3 lis_gen = [ i for i in range(1,10)]  #列表生成式
 4 print(lis_gen)
 5 
 6 lis1_gen = [i for i in range(1,10) if i%2 == 0]  #生成一个偶数的列表
 7 print(lis1_gen)
 8 
 9 lis2_gen = [ i * i for  i in range(1,10) if i%2 == 1]  #生成以个奇数乘自已本身奇数的列表
10 print(lis2_gen)

1 gen_exp = (i for i in range(10))  #生成器表达式
2 print(gen_exp) #generator
3 # for i in gen_exp:  #取出生成器表达式的值，for循环
4 #     print(i)
5 print(gen_exp.__next__()) #next方法
6 print(gen_exp.__next__())
7 print(gen_exp.__next__())
8 print(gen_exp.__next__())
9 print(gen_exp.__next__())

1 gen = (i for i in range(10**100))  #生成器表达式
2 lis = [i for i in range(10**100)]  #列表生成式
3 
4 #生成器,更省内存，需要一个取一个
5 print(gen.__next__())
6 print(lis)  #需要在内存空间创建1-10**100序列

 1 >>> gen = (i for i in range(5))
 2 >>> gen
 3 <generator object <genexpr> at 0x0000004DE29A70A0>
 4 >>> next(gen)
 5 0
 6 >>> next(gen)
 7 1
 8 >>> next(gen)
 9 2
10 >>> next(gen)
11 3
12 >>> next(gen)
13 4
14 >>> next(gen)
15 Traceback (most recent call last):
16   File "<stdin>", line 1, in <module>
17 StopIteration

1 >>> g = (i for i in range(5))
2 >>> for i in g:
3 ...     print(i)
4 ...
5 0
6 1
7 2
8 3
9 4

1 def fib(number):
2     #得出几个斐波拉契数列
3     count,a,b = 0,0,1
4     while count < number:
5         print(b)
6         a,b = b,a+b
7         count += 1
8     return "done"
9 fib(5)

 1 def fib1(number):
 2     n,a,b = 0,0,1
 3     while n<number:
 4         yield b
 5         a,b = b,a+b
 6         n += 1
 7     return "done"
 8 aa = fib1(6)
 9 print(aa)  #generator
10 # print(aa.__next__())
11 for i in aa:
12     print(i)

 1 def packet():
 2     for i in range(1,10):
 3         print("开始生产包子")
 4         yield  "第 %d 屉包子" %(i)
 5         print("卖包子，买完再生产")
 6 cs = packet()  #生成一个做包子的生成器，相当于做包子的
 7 # print(cs)
 8 q = print(cs.__next__()) #卖包子的
 9 print(cs.__next__())
10 for i in cs:
11     print(i)

 1 #单线程一边发送，一边执行
 2 import time
 3 def consumer(name):
 4     print("%s 准备吃包子啦!" %name)
 5     while True:
 6        baozi = yield
 7 
 8        print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
 9 def producer(name):
10     c = consumer(‘A‘)
11     c2 = consumer(‘B‘)
12     c.__next__()
13     c2.__next__()
14     print("老子开始准备做包子啦!")
15     for i in range(10):
16         time.sleep(1)
17         print("做了2个包子!")
18         c.send(i) #发送的值，就是yield的返回值
19         c2.send(i)
20 producer("xixi")

 1 def deco(func):
 2     def wrapper(*args,**kwargs):
 3         res = func(*args,**kwargs)  #这里就相当于闭包
 4         print("一门高级语言")
 5         return res
 6     return wrapper
 7 
 8 @deco
 9 def go(x,y):
10     print("python",x,y)
11     return "done"
12 go(3,5)
13 # 结果
14 python
15 一个高级语言
16 
17 # 为什么要给装饰器加参数，如果被装饰的函数里面有参数，我们的装饰器是不是器也要加相应的参数，
18 我们的装饰器为什么要给wrapper(*args,**kwargs) func(*args,**kwargs)，可接收任意参数，因为我们被装饰的函数可能都是不同的的参数，而这个装饰器，需要给很多函数做装饰，但是很多函数的参数，功能都是不一样的，因此我们定义装饰器 的函数参数应该是加可变长参数
19 
20 #为什么给装饰里面加返回值
21 我们被装饰的函数，一般是有返回值，而执行装饰器(@decorator)  所以需要给wrapper 加上返回值来return fun()的执行结果，来保持被装饰的函数的一致性。

 1 user_list=[
 2     {‘name‘:‘yj‘,‘passwd‘:‘123‘},
 3     {‘name‘:‘xixi‘,‘passwd‘:‘123‘},
 4     {‘name‘:‘xiha‘,‘passwd‘:‘123‘},
 5     {‘name‘:‘lala‘,‘passwd‘:‘123‘},
 6 ]
 7 
 8 current_user={‘username‘:None,‘login‘:False}
 9 def auth(auth_type=‘file‘):
10     def auth_deco(func):
11         def wrapper(*args,**kwargs):
12             if auth_type == ‘file‘:
13                 if current_user[‘username‘] and current_user[‘login‘]:
14                     res=func(*args,**kwargs)
15                     return res
16                 username=input(‘用户名: ‘).strip()
17                 passwd=input(‘密码: ‘).strip()
18 
19                 for index,user_dic in enumerate(user_list):
20                     if username == user_dic[‘name‘] and passwd == user_dic[‘passwd‘]:
21                         current_user[‘username‘]=username
22                         current_user[‘login‘]=True
23                         res=func(*args,**kwargs)
24                         return res
25 
26                 else:
27                     print(‘用户名或者密码错误,重新登录‘)
28             elif auth_type == ‘ldap‘:
29                 print(‘巴拉巴拉小魔仙‘)
30                 res=func(*args,**kwargs)
31                 return res
32         return wrapper
33     return auth_deco
34 
35 
36 #auth(auth_type=‘file‘)就是在运行一个函数,然后返回auth_deco,所以@auth(auth_type=‘file‘)
37 #就相当于@auth_deco,只不过现在,我们的auth_deco作为一个闭包的应用,外层的包auth给它留了一个auth_type=‘file‘参数
38 @auth(auth_type=‘ldap‘)
39 def index():
40     print(‘欢迎来到主页面‘)
41 
42 @auth(auth_type=‘ldap‘)
43 def home():
44     print(‘这里是你家‘)
45 @auth(auth_type="file")
46 def shopping_car():
47     print(‘查看购物车啊亲‘)
48 
49 def order():
50     print(‘查看订单啊亲‘)
51 
52 # print(user_list)
53 index()
54 # print(user_list)
55 home()
56 shopping_car()