python三大器：装饰器，迭代器，生成器

此文与其他文章不同，仅为个人学习笔记使用，编写过程中难免有错误，望各位读者提出，共同进步。

装饰器，迭代器，生成器是python开发过程中重要的工具，装饰器相较于其他两个来说较难以理解。

1.装饰器

通俗的来说是用来为其他区函数增加其他功能的，同时遵循一个基本原则：开放封闭原则：开放指对拓展功能开放，封闭指对修改源代码是封闭的。 1.1 简简单单先定义一个函数：

def index(x, y): print("index %s,%s" % (x, y)) index(111, 222)

不难看出结果应该是：

index 111,222

当我们想为这段代码添加一个运行时间的代码,但又不想破坏其本身的完整型 想到利用time方法可以实现：

import time def index(x,y): start = time.time() time.sleep(3) print("index %s,%s" %(x,y)) stop = time.time() print(stop - start) index(111,222)

输出：

index 111,222 3.0005669593811035

1.2 不出意外，运行时间是能统计出来，但是我们破坏了代码的完整性。这算是个失败案例，但是我们想到可以在函数内调用其他函数去实现：定义一个新的函数去接收index；运行1.1函数实际上就是在调用index(111,222)，那我们想到在调用阶段为其添加统计时间功能

def index(x,y): print("index %s,%s" % (x, y)) start = time.time() time.sleep(3) index(111,222) stop = time.time() print(stop - start)

输出：

index 111,222 3.000377655029297

结果也是合情合理，但是我们想到在开发过程中 应该会重复调用多次1.1的函数，所以为了代码的简洁性，我们把调用阶段包装成一个函数：

import time def index(x,y): print("index %s,%s" % (x, y)) def timee(x,y): start = time.time() time.sleep(3) index(x,y) stop = time.time() print(stop - start) timee(1,2)

输出：

index 1,2 3.0007386207580566

此时不管有多少需求 我只需要运用time（x,y）函数来掉用。 1.3这时候，我们将index参数写活，用*args,**kwargs进行定义，这样可以优化需求：

import time def timee(*args,**kwargs)： start = time.time() index(*args,**kwargs) stop = time.time() print(stop - start) def index(x, y, z): time.sleep(3) print("index %s,%s,%s" % (x, y, z)) timee(1,2,3)

输出：

index 1,2,3 3.0002880096435547

定义阶段：timee(*args,**kwargs)：中timee如何调用 就怎么原封不动的index。这是看上去很完美，实际上还有很大的缺陷：timee函数只能为index函数做装饰，如果有其他函数还需要另外重写，不符合代码的简洁性，我们想到可以用嵌套函数在外层把函数装饰参数，

import time def index(x,y,z): time.sleep(3) print("index %s,%s,%s" % (x,y,z)) def outter(func): def timee(*args,**kwargs): start = time.time() func (*args,**kwargs) stop = time.time() print(stop - start) return timee index= outter(index) index(1,2,3)

1.4当我们相想为多个函数添加运行时间功能时，那么另外定义一个就好了：

import time def index(x,y,z): time.sleep(3) print("index %s,%s,%s" % (x,y,z)) return 456 def home (name): time.sleep(2) print("welcome %s come to home page"%name) return 123 def outter(func): # func = index # 的内存地址 def timee(*args,**kwargs): # timee怎么定义的，怎么给index调用，原封不动 start = time.time() func (*args,**kwargs) stop = time.time() print(stop - start) #return 123 #此时才算有timee的返回值 return timee # 是属于outter的返回值 home = outter(home) index= outter(index) r = index(1,2,3) res = home('egon') print('返回值--》',res) print('返回值--》',r)

输出：

index 1,2,3 3.01408314704895 welcome egon come to home page 2.0104966163635254 返回值--》 None 返回值--》 None

我们可以看出想要为home添加功能，不需要改变原有的整体，只用添加相关代码即可， 但是如果我们想为成千上万个函数增加统计运行时间，俺么每次一次代码就需要定义一行，造成了代码冗余，那么@outter这个语法糖可以解决这个问题 1.5@装饰器

import time def outter(func): # func = index # 的内存地址 def timee(*args,**kwargs): # timee怎么定义的，怎么给index调用，原封不动 start = time.time() func (*args,**kwargs) stop = time.time() print(stop - start) # return 123 #此时才算有timee的返回值 return timee # 是属于outter的返回值 @outter #index= outter(index) # home = wrapper的内存地址 def index(x,y,z): time.sleep(3) print("index %s,%s,%s" % (x,y,z)) return 456 @outter #home = outter(home) # f = 当初那个timee函数的内存地址 def home (name): time.sleep(2) print("welcome %s come to home page"%name) return 123 r = index(1,2,3) res = home('egon') print('返回值--》',res) print('返回值--》',r) print(home)

输出：

index 1,2,3 3.007416009902954 welcome egon come to home page 2.0053913593292236 返回值--》 None 返回值--》 None <function outter.<locals>.timee at 0x00907808>

1.6 我们发现打印home时，home的属性已经被指向timee，这肯定不是我们所想要的，functools功能帮我们解决了这个问题：

from functools import wraps def outter(func): @wraps(func) def wrapper(*args,**kwargs): res = func(*args,**kwargs) return res wrapper.__name__ = func.__name__# 手动将原函数的属性赋值给wrapper函数 return wrapper @outter# index= outter(index) def index(x,y): '''这是主页功能''' print(x,y) index.__name__ = 'index' print(index.__name__) print(help(index))

这里我们把index.__name__指向了index 因此帮助文档展示的就是index的注释 输出：

index Help on function index in module __main__: index(x, y) 这是主页功能 None

1.7 有参装饰器：如果装饰器本身需要参数，那么就编写一个返回装饰器的高阶函数：

import functools def log(text): def decorator(func): @functools.wraps(func)#在定义wrapper()的前面加上@functools.wraps(func)即可。 def wrapper(*args, **kw): print('%s %s():' % (text, func.__name__)) return func(*args, **kw)#返回now函数的打印值 return wrapper return decorator @log('execute') def now(): print('2013-12-25') return 1 print(now())#wrapper

此时，now() = log(‘execute’)now() 输出：

execute now(): 2013-12-25 1

1.8叠加多个装饰器的加载，运行分析：

def deco1(func1): def wrapper1(*args, **kwagrs): res1 = func1(*args, **kwagrs) print("第一个装饰器") return res1 return wrapper1 def deco2(func2): def wrapper2(*args, **kwagrs): print("第二个装饰器") res2 = func2(*args, **kwagrs) return res2 return wrapper2 def deco3(x): def outer3(func3): def wrapper3(*args, **kwagrs): print("第三个装饰器") res3 = func3(*args, **kwagrs) return wrapper3 return outer3 @deco1 @deco2 @deco3(111) def index(x, y): print('from index %s,%s' % (x, y)) print(index(1, 2))

加载顺序应该是自下而上：outer3–>index = outer3(index) -->index = wrapper3的内存地址 index = deco2(wrapper3的内存地址)–>index = wrapper2的内存地址 index = deco1(wrapper2的内存地址)–>index = wrapper1的内存地址 此时打印index(1, 2)返回的应该是 wrapper1的内存地址 执行顺序与加载顺序相反 输出：

第二个装饰器 第三个装饰器 from index 1,2 第一个装饰器 None

2迭代器

迭代器是迭代取值的工具，迭代是一个重复的工具，每次重复都是基于上一次的结果而继续的，单纯的重复并不是迭代。能把多个值循环取出来的类型有：列表，字符串，元组，字典，集合，文件。 先简单列出一个while循环取值：

count =['e','q','f'] q = 0 while q<len(count): print(count[q]) q+=1

上述取值的当时只是适用于有索引的数据类型。 2.1可迭代对象： 但凡内置有__iter__方法的都称之为可迭代的对象，那么我们考察一下上述类型是否为可迭代对象。

s1 ='' print(s1.__iter__()) l = [] print(l.__iter__()) d = {'a':1} print(d.__iter__()) t = (1,) print(t.__iter__()) set1 = {1,2,3} print(set1.__iter__()) with open ("C:/Users/wxl/Desktop.111.txt",mode = "w") as f: pass print(f.__iter__())

输出：列表，字符串，元组，字典，集合，文件均是可迭代对象

<str_iterator object at 0x01DEE6E8> <list_iterator object at 0x01DEE6E8> <dict_keyiterator object at 0x01E048C0> <tuple_iterator object at 0x01DEE6E8> <set_iterator object at 0x01E0D4C8> Traceback (most recent call last): File "C:/Users/wxl/Desktop/笔记.py", line 2260, in <module> print(f.__iter__()) ValueError: I/O operation on closed file.

由此可见： 2.3迭代器对象：调用可迭代对象下的.__iter__方。法会将其转换成迭代器对象 以列表为例：

d = {'a':1,'b':2,"c":3}#调用可迭代对象下的.__iter__方。法会将其转换成迭代器对象 res = d.__iter__() while True: try: print(res.__next__()) except StopIteration: break

输出：

a b c

利用迭代器取值：

d = {'a':1,'b':2,"c":3}#调用可迭代对象下的.__iter__方。法会将其转换成迭代器对象 c = d.__iter__() print(c.__next__()) print(c.__next__())

这里的c是一个迭代器对象，迭代器的内置方法:next：得到迭代器下一个值 输出：

a b

可迭代对象与迭代器对象： 可迭代对象：可以转换为迭代器对象的对象：同时内置有.__iter__方法 迭代器对象：内置有.__next__方法且内置有.__iter__方法 迭代器对象.next：得到迭代器下一个值 迭代器对象.iter：得到迭代器本身 2.4for循环工作原理： 先写一个简单的for循环：

d = [12,2,3] for i in d: print(i)

我们在用迭代器实现一下：

d = [12,2,3] c = d.__iter__() print(c.__next__()) print(c.__next__()) print(c.__next__())

二者输出都是：

12 2 3

那么上述代码中在运行一次print(c.next())会产生什么呢？

Traceback (most recent call last): File "C:/Users/wxl/Desktop/笔记.py", line 2356, in <module> print(c.__next__()) StopIteration

可以看出运行一次就读取一行信息。若把值取干净，若再次调用则会抛出异常。想要再次运行的话重新再定义一次迭代器对象就好了。

接下来解释一下for循环工作原理： 1.d.iter()得到一个迭代器对象 2.迭代器对象.next()会拿到一个返回值，然后将该返回值赋值给i 3.往复循环步骤2，知道抛出异常，佛如循环会捕捉异常然后结束循环 缺点： 1.取值不如索引方便， 2.是一次性用具。

3.生成器：

自定义迭代器:在函数内有yield关键字，调用函数指挥返回一个生成器

def func(): print("第一次") yield 1 print("第2次") yield 2 print("第3次") yield 3 print("第4次") res = func() print(res)

输出：

<generator object func at 0x031A33E0>

看出func是generator（生成器）generator不会把所有保存在内存中，而是一边计算一边调用，

res.__iter__() q = res.__next__() print(q)#1 print(q)#1

只调用一次去多次打印迭代器对象得到多次重复的值：

第一次 1 1 1

在python中为了让q = res.next()书写更方便，简化成了next（res)