python迭代器、生成器和装饰器

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/sunchengquan/article/details/84494101

生成器

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

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

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

生成器表达式(generator expression)

L = [x + 1 for x in range(10)]
print(L)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

列表生成式复习

实现列表元素加1，列表生成式与其它方法比较：

#普通方法1
b = []
for i in range(10):
    b.append(i+1)
print(b)

#普通方法2
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for index,i in enumerate(a):
    a[index] +=1
print(a)

#map,lambda
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = map(lambda x:x+1, a)
print(list(a))

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

g = (x + 1 for x in range(10))
print(g)

<generator object <genexpr> at 0x7fe03ad859a8>

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

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数（or __next__()）获得generator的下一个返回值：

next(g)

1

next(g)

2

next(g)

3

g.__next__()

4

g.__next__()

5

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

扫描二维码关注公众号，回复： 4229424 查看本文章

上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

g = (x * x for x in range(10))
for n in g:
    print(n,end=";")

0;1;4;9;16;25;36;49;64;81;

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误

通过使用yield关键字定义

生成器对象是通过使用yield关键字定义的函数对象，因此，生成器也是一个函数。生成器用于生成一个值得序列，以便在迭代器中使用。

"""
第一是直接作为脚本执行，
第二是import到其他的python脚本中被调用（模块重用）执行。
因此if __name__ == '__main__': 的作用就是控制这两种情况执行代码的过程，
在if __name__ == '__main__':下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而import到其他脚本中是不会被执行的。
"""

def myYield(n):
    while n>0:
        print('开始生成。。。')
        yield n
        print('完成一次。。。')
        n -= 1
if __name__ == '__main__':
    a = myYield(3)
    print('已经实例化生成器对象')
#     a.__next__()
#     print('第二次调用__next__()方法：')
#     a.__next__()

已经实例化生成器对象

yield 语句是生成器中的关键语句，生成器在实例化时并不会被执行，而是等待调用其__next__()方法才开始运行。并且当程序运行完yield语句后就会“吼（hold）住”，即保持当前状态且停止运行，等待下一次遍历时才恢复运行。

程序运行的结果中的空行后的输出“已经实例化生成器对象”之前，已经实例化了生成器对象，但生成器并没有运行（没有输出‘开始生成’）。当第一次手工调用__next__()方法之后，才输出‘开始生成’，标志着生成器已经运行，而在输出‘’第二次调用__next__()方法‘’之前并没有输出‘完成一次’，说明yield语句运行之后就立即停止了。而第二次调用__next__()方法之后，才输出‘完成一次’，说明生成器的回复运行是从yield语句之后开始运行的

return_value = a.__next__()
print(return_value)

开始生成。。。
3

print('第二次调用__next__()方法：')

第二次调用__next__()方法：

return_value = a.__next__()
print(return_value)

完成一次。。。
开始生成。。。
2

著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

注意，赋值语句：

a, b = b, a + b

相当于：

t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

上面的函数可以输出斐波那契数列的前N个数：

fib(5)

1
1
2
3
5





'done'

上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print(b)
        yield  b
        a,b = b,a+b
        n += 1
    return 'well done' 

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

f = fib(5)
print(f)
print(list(f))

#重新实例化生成器对象
f = fib(5)

<generator object fib at 0x7fe038493840>
[1, 1, 2, 3, 5]

print(f.__next__())
print(f.__next__())
print("干点别的事")
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())

1
1
干点别的事
2
3
5



---------------------------------------------------------------------------

StopIteration                             Traceback (most recent call last)

<ipython-input-18-9609f54647c6> in <module>
      5 print(f.__next__())
      6 print(f.__next__())
----> 7 print(f.__next__())


StopIteration: well done

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

g = fib(6)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
        print('Generator return value:', e.value)
        break

g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: well done

from itertools import islice
def fib():
    a,b = 0,1
    while True:
        yield b
        a,b = b,a+b
f = fib()
print(list(islice(f ,0,10)))

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

生成器在Python中是一个非常强大的编程结构，可以用更少地中间变量写流式代码，此外，相比其它容器对象它更能节省内存和CPU，当然它可以用更少的代码来实现相似的功能。现在就可以动手重构你的代码了，但凡看到类似

def something():
    result= []
    for ... in ...：
        result.append(x)
        return result

都可以用生成器函数来替换：

def iter_something():
    result = []
    for ... in ...：
        yield x

杨辉三角

期待输出:

[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

def triangles():
    result = [1]
    while True:
        yield result
        result = [1] + [result[i] + result[i+1] for i in range(len(result)-1)] + [1]

n = 0
results = []
for t in triangles():
    print(t)
    results.append(t)
    n = n + 1
    if n == 10:
        break
if results == [
    [1],
    [1, 1],
    [1, 2, 1],
    [1, 3, 3, 1],
    [1, 4, 6, 4, 1],
    [1, 5, 10, 10, 5, 1],
    [1, 6, 15, 20, 15, 6, 1],
    [1, 7, 21, 35, 35, 21, 7, 1],
    [1, 8, 28, 56, 70, 56, 28, 8, 1],
    [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
]:
    print('测试通过!')
else:
    print('测试失败!')

[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
测试通过!

迭代器

迭代器概述

可以直接作用于for循环的数据类型有以下几种：

• 一类是集合数据类型,如list,tuple,dict,set,str等
• 一类是generator ，包括生成器和带yeild的generator function

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

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

a = [i for i in range(10)]
next(a)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-23-8981550fe3e0> in <module>
      1 a = [i for i in range(10)]
----> 2 next(a)


TypeError: 'list' object is not an iterator

list，dict，str虽然是Iterable，却不是Iterator

from collections import Iterator
from collections import Iterable
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))
print(isinstance({},Iterable))
print(isinstance('abc',Iterable))

False
True
True
True

生成器就是一个迭代器

a = (i for i in range(10))
print(next(a))
print(isinstance(a,Iterator))

0
True

iter()函数 创建迭代器

iter（iterable）#一个参数，要求参数为可迭代的类型

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

print(isinstance({},Iterator))
print(isinstance('abc',Iterator))
print(isinstance(iter({}),Iterator))
print(isinstance(iter('abc'),Iterator))

False
False
True
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对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    print(x,end=',')

1,2,3,4,5,

实际上完全等价于：

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x,end=',')
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

1,2,3,4,5,

创建一个迭代器(类)

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行

__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

from itertools import islice
class Fib:
    def __init__(self):
        self.prev = 0
        self.curr = 1
    def __iter__(self):
        return self
    def __next__(self):
        self.prev,self.curr = self.curr,self.prev+self.curr
        return self.curr
f = Fib()
print(list(islice(f ,0,10)))

[1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Fib既是一个可迭代对象（因为它实现了 __iter__方法），又是一个迭代器（因为实现了 __next__方法)

StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

class MyNumbers:
    def __init__(self):
        self.a = 1
    
    def __iter__(self):
        return self

    def __next__(self):
        if self.a <= 20:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration

myclass = MyNumbers()
myiter = MyNumbers()
# myiter = iter(myclass)
 
for x in myiter:
    print(x,end=",")

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,

内置迭代器工具

比如 itertools 函数返回的都是迭代器对象

count无限迭代器

from itertools import count
counter = count(start=10)  
print(next(counter))
print(next(counter)) #python内建函数next()对itertools创建的迭代器进行循环

10
11

cycle 无限迭代器，从一个有限序列中生成无限序列：

from itertools import cycle
colors = cycle(['red','black','blue'])
print(next(colors))
print(next(colors))
print(next(colors))
print(next(colors))
print(next(colors))  

red
black
blue
red
black

itertools的子模块 islice 控制无限迭代器输出的方式

islice的第二个参数控制何时停止迭代，迭代了11次后停止，从无限的序列中生成有限序列：

from itertools import count
counter = count(start=10)
i=4
print(next(counter))
while i > 0:
    print(next(counter))
    i -= 1

10
11
12
13
14

from itertools import count
for i in count(10):
    if i > 14 :
        break
    else:
        print(i)

10
11
12
13
14

from itertools import islice
from itertools import count
for i in islice(count(10),5):
    print(i)

10
11
12
13
14

from itertools import cycle
from itertools import islice
colors = cycle(['red','black','blue'])
limited = islice(colors,0,4)
for x in limited:
    print(x)

red
black
blue
red

装饰器

器，代表函数的意思

装饰器：本质是函数（装饰其他函数）就是为其他函数添加附加功能

每个人都有的内裤主要功能是用来遮羞，但是到了冬天它没法为我们防风御寒，咋办？我们想到的一个办法就是把内裤改造一下，让它变得更厚更长，这样一来，它不仅有遮羞功能，还能提供保暖，不过有个问题，这个内裤被我们改造成了长裤后，虽然还有遮羞功能，但本质上它不再是一条真正的内裤了。于是聪明的人们发明长裤，在不影响内裤的前提下，直接把长裤套在了内裤外面，这样内裤还是内裤，有了长裤后宝宝再也不冷了。装饰器就像我们这里说的长裤，在不影响内裤作用的前提下，给我们的身子提供了保暖的功效。

原则：

• 1 不能修改被装饰的函数的源代码
• 2 不能修改被装饰的函数的调用方式

实现装饰器知识储备：

• 1 函数即“”变量“”

• 2 高阶函数

  a 把一个函数名当做实参传给另一个函数

  b 返回值中包含函数名

高阶函数

import time
def bar():
    time.sleep(3)
    print('in the bar')
def test2(func):
    print(func)
    return func

print(test2(bar)) #调用test2，打印bar的内存地址，返回bar的内存地址，又打印

<function bar at 0x7fe03849e620>
<function bar at 0x7fe03849e620>

bar=test2(bar) # 返回的bar的内存地址，赋值给bar
bar() #run bar

<function bar at 0x7fe03849e620>
in the bar

嵌套函数

x = 0
def grandpa():
    x = 1
    print(x)
    def dad():
        x =2
        print(x)
        def son():
            x =3
            print(x)
        son()
    dad()

grandpa()

1
2
3

高阶函数+嵌套函数 = 装饰器

import time
def timer(func): #timer(test1) func=test1
    def deco(*args,**kwargs):  #非固定参数
        start_time=time.time()
        func(*args,**kwargs) #run test1()
        stop_time = time.time()
        print("the func run time is %s" %(stop_time-start_time))
    return deco
@timer #test1=timer(test1) 把deco的内存地址返回给test1
def test1():
    time.sleep(1)
    print('in the test1')

@timer # test2 = timer(test2) = deco test2(name) =deco(name)
def test2(name,age):
    print("test2:",name,age)

test1() #实际上是在执行deco
test2("alex",22)

in the test1
the func run time is 1.001246452331543
test2: alex 22
the func run time is 0.00011372566223144531

类装饰器

没错，装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的__call__方法

class Foo(object):
    def __init__(self, func):
        self._func = func

    def __call__(self):
        print ('class decorator runing')
        self._func()
        print ('class decorator ending')

@Foo
def bar():
    print ('bar')
bar()

class decorator runing
bar
class decorator ending

装饰器可以把与业务逻辑无关的代码抽离出来，让代码保持干净清爽，而且装饰器还能被多个地方重复利用。比如一个爬虫网页的函数，如果该 URL 曾经被爬过就直接从缓存中获取，否则爬下来之后加入到缓存，防止后续重复爬取。

def web_lookup(url, saved={}):
    if url in saved:
        return saved[url]
    page = urllib.urlopen(url).read()
    saved[url] = page
    return page

pythonic

import urllib.request as urllib # py3
def cache(func):
    saved= {}
    def wrapper(url):
        if url in saved:
            return saved [url]
        else:
            page = func(url)
            saved [url] = page
            return page
    return wrapper
    
@cache
def web_lookup(url):
    return urllib.urlopen(url).read()

用装饰器写代码表面上感觉代码量更多，但是它把缓存相关的逻辑抽离出来了，可以给更多的函数调用，这样总的代码量就会少很多，而且业务方法看起来简洁了。

带参数的decorator

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

还差最后一步。因为我们讲了函数也是对象，它有__name__等属性，但你去看经过decorator装饰之后的函数，它们的__name__已经从原来的’now’变成了’wrapper’：

@log('execute')
def now():
    print('2015-3-25')
    
now()
now.__name__

execute now():
2015-3-25





'wrapper'

因为返回的那个wrapper()函数名字就是’wrapper’，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。

不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now():
    print('2015-3-25')
    
now()
now.__name__

execute now():
2015-3-25





'now'

那么不带参数decorator，也是一样的

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

实例—登录认证

import functools


user,passwd = 'sun' ,'123'
def auth(auth_type):
    print("auth func:",auth_type)
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args,**kwargs):
            print('wrapper func args:',*args,**kwargs)
            if auth_type == 'local':
                username = input('Username:').strip()
                password = input("Password:").strip()
                if user == username and passwd == password:
                    print("\033[32;1mUser has passed authentication\033[0m")
                    res = func(*args, **kwargs) 
                    print("--after authentication--")
                    return res
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == 'ldap':
                res = func(*args, **kwargs)
                print("搞毛线ldap,不会。。。。")
                return res

        return wrapper
    return decorator

def index():
    print("welcome to index page")

@auth(auth_type='local')
def home():
    print("welcome to home page")
    return 'from home'

@auth(auth_type='ldap')
def bbs():
    print("welcome to bbs page")


index()
print(home())  #wrapper
bbs()

auth func: local
auth func: ldap
welcome to index page
wrapper func args:
Username:sun
Password:123
User has passed authentication
welcome to home page
--after authentication--
from home
wrapper func args:
welcome to bbs page
搞毛线ldap,不会。。。。