迭代器、生成器和装饰器

列表生成式

如果现在要给一个列表里的每个值都增加1，你会想到怎么做呢？

a=[2,3,4,5,6,7,8,9]

#方法一
b=[]
for i in a:
    b.append(i+1)
print(b)
#方法二：
a=map(lambda x:x+1,a)
for i in b:
    print(i)

#列表生成式
a = [i + 1 for i in a]
print(a)

生成器

特性：
1、只有在调用时才会生成相应的数据
2、只记录当前位置
3、只有一个__next__方法

　
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

　　所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python    中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

a=[i*i for i in range(10) ] #列表生成式
g=(i*i for i in range(10)) #生成器
print(a)
print(g)

>>>[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>><generator object <genexpr> at 0x008E4C00>

创建a和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

如何打印出generator的每一个元素？

print(next(g)) #next方法（内置方法）

print(g.__next__()) #__next__方法

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

像上面这种不断调用next（g）实在是太麻烦了，正确的方法是使用for循环，因为generator也是可迭代对象

g=(i*i for i in range(10))
for i in g:
    print(i)

一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器

#菲波那契数列生成器

def fib1(max):
    n,a,b=0,0,1
    while n<max:
        # print(b) 只需要把print(b)改为yield b 就可以把fib函数变成generator
        yield b
        a, b = b, a + b
        n += 1
    return 'done'

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

for i in fib1(10):
    try:
        print(f.__next__())
    except StopIteration as e:
        print("The error is:",e.value)
        break

迭代器
　　迭代的意思是重复做一些事很多次，迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

特点：

1. 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
2. 不能随机访问集合中的某个值 ，只能从头到尾依次访问
3. 访问到一半时不能往回退
4. 便于循环比较大的数据集合，节省内存

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

　　一类是集合数据类型，如list、tuple、dict、set、str等；

　　一类是generator，包括生成器和带yield的generator function。

　　这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

可以使用isinstance()判断一个对象是否是Iterable对象：

from collections import Iterable
print(isinstance([],Iterable))

True

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

from collections import Iterator
print(isinstance(iter({}),Iterator))

True

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

小结

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

 

装饰器

装饰器：本质上是函数，(装饰其他函数)就是为其他函数添加附加功能

原则：
　　1、不能修改被装饰的函数的源代码、调用方法。

实现装饰器的知识储备
　　1、函数即变量
　　2、高阶函数
　　　　a.把一个函数名当做实参传给另一个函数
　　　　(在不修改被装饰函数源代码的情况下为其添加功能)
　　　　b、返回值中包含函数名
　　　　(不修改函数的调用方式)
　　3、嵌套函数
高阶函数+嵌套函数=》装饰器

 嵌套函数：

#在一个函数内部再去定义一个函数
def foo():
    print("in the foo")
    def bar():
        print("in the bar")

装饰器：

import time
def timer(func):
    def wrapper(*args ,**kwargs):
        start_time=time.time()
        func(*args,**kwargs)
        stop_time=time.time()
        print("The test run %s second"%(stop_time-start_time))
    return wrapper #返回wrapper函数的内存地址 然后系统会去自动调用执行-->=wrapper()

@timer # test1=timer(test1)-->wraper
def test1():
    time.sleep(3)
    print('This is the test1')
test1()#wraper()

@timer
def test2(name):
    print("Hello my name is %s"%(name))
test2('Li')

利用生成器实现单线程下的并行效果（协程）

import  time ,random
def consumer(name):
    print("顾客%s准备吃包子了"%name)
    while True:
        baozi=yield
        print("%s来了，被%s吃了"%(baozi,name))

f=consumer('陈大蒜')#只是把consumer变成生成器，并不会执行下面print语句，只有执行f.__next__()才会往下走，直到yield
f.__next__()#只是唤醒yield
# f.send('韭菜包子')#唤醒yield并同时给yield传值

def producer(name):
    count=input("请输入顾客人数：")
    if count.isdigit():
        count=int(count)
        list=[i+1 for i in range(count)]
        for i in range(len(list)):
            list[i]=consumer(i+1)
            list[i].__next__()
        print("%s要开始做包子了" % name)
        for i in range(10):
            time.sleep(3)
            print('做了2个包子')
            list[random.randint(0,len(list)-1)].send('韭菜包子')
            list[random.randint(0,len(list)-1)].send('香菇瘦肉包子')
    else:
        print("您所输入的人数无效；")
producer('牛魔王')

装饰器语法糖@

# 用户登录验证装饰器
user,pwd="li",'123456'
def auth(auth_type):
    print("The func is: %s"%auth_type)
    def outer_wrapper(func):
        def wrapper(*args,**kwargs):
           if auth_type=='local':
               username = input('Please input your username:').strip()
               password = input('Please input your password:').strip()
               if username == user and password == pwd:
                   # func()
                   res = func()  # 获取func的返回值
                   print("33[31;1m The authentication have passed successfully33[0m")
                   return res  # 返回func的返回值
               else:
                   print("33[31;1m The authentication didn't passed 33[0m")
           elif auth_type=='ldap':
               print('What is the ldap？')
           else:
               print('something else authentication')
        return wrapper
    return outer_wrapper

def index():
    print("This is the index page")
    
 #使用@调用装饰器进行装饰
@auth(auth_type="local")#调用auth(auth_type="file")后返回outer_wrapper,然后把函数名home当做实参传给outer_wrapper(outer_wrapper(home))开始调用，然后返回wrapper赋给home， 即home=outer_wrapper(home)
def home():
    print("This is the home page")
    return "from the home"

@auth(auth_type='ldap')
def bbs():
    print("This is the bbs page")

index()
home()
print(home())
bbs()