装饰器，迭代器，生成器
一、装饰器
无参装饰器的实现
如果想为下述函数添加统计其执行时间的功能
import time
def index():
time.sleep(3)
print('Welcome to the index page’)
return 200
index() #函数执行
闭包函数的方案：
import time
def index(): # index = 被装饰对象index函数的内存地址
time.sleep(1)
print('from index')
def outter(func): # func = 被装饰对象index函数的内存地址
def wrapper():
start = time.time()
func() # 被装饰对象index函数的内存地址()
stop = time.time()
print('run time is %s' %(stop - start))
return wrapper # 千万别加括号
index = outter(index) # outter(被装饰对象index函数的内存地址) -> 返回wrapper函数的内存地址---> index = wrapper函数的内存地址
print(index)
index()
无参装饰器的方案，将wrapper伪装成被装饰的函数，那么应该装的尽可能像一些：
import time
def index(): # index = 被装饰对象index函数的内存地址
time.sleep(1)
print('from index'
def home(name):
time.sleep(2)
print("welcome %s to home page" %name)
return 123
def outter(func): # func = 被装饰对象index函数的内存地址
def wrapper(*args,**kwargs):
start = time.time()
res = func(*args,**kwargs) # 被装饰对象index函数的内存地址(x,y,z)
stop = time.time()
print('run time is %s' %(stop - start))
return res
return wrapper # 千万别加括号
index = outter(index) # outter(被装饰对象index函数的内存地址) -> 返回wrapper函数的内存地址---> index = wrapper函数的内存地址
home = outter(home)
# print(index)
res = home("egon") # wrapper("egon")
print(res)
res = index() # wrapper()
print(res)
装饰器的语法糖。被装饰函数的正上方，单独一行
mport time
from functools import wraps
def outter(func): # func = 被装饰对象index函数的内存地址
@wraps(func)
def wrapper(*args,**kwargs):
start = time.time()
res = func(*args,**kwargs) # 被装饰对象index函数的内存地址(x,y,z)
stop = time.time()
print('run time is %s' %(stop - start))
return res
return wrapper # 千万别加括号
@outter # index = outter(index) # outter(被装饰对象index函数的内存地址) -> 返回wrapper函数的内存地址---> index = wrapper函数的内存地址
def index(): # index = 被装饰对象index函数的内存地址
"""这是index函数"""
time.sleep(1)
print('from index')
@outter # home = outter(home)
def home(name):
time.sleep(2)
print("welcome %s to home page" %name)
return 123
# res = home("egon") # wrapper("egon")
# print(res)
# res = index() # wrapper()
# print(res)
print(index.__name__)
print(index.__doc__)
无参装饰器的模板
def outter(func):
def wrapper(*args,**kwargs):
res = func(*args,**kwargs)
return res
return wrapper
@outter
def index():
print('index')
index()
以登录功能为案例：
def login(func):
def wrapper(*args,**kwargs):
name = input('username>>>: ').strip()
pwd = input('password>>>: ').strip()
if name == 'egon' and pwd == "123":
res = func(*args,**kwargs)
return res
else:
print('账号密码错误')
return wrapper
@login
def index():
print('index')
index()
叠加多个装饰器
1、加载顺序(outter函数的调用顺序):自下而上
2、执行顺序(wrapper函数的执行顺序):自上而下
def deco1(func1): # func1 = wrapper2的内存地址
def wrapper1(*args,**kwargs):
print('==========>wrapper1')
res1 = func1(*args,**kwargs)
print('end1')
return res1
return wrapper1
def deco2(func2): # func2 = wrapper3的内存地址
def wrapper2(*args,**kwargs):
print('==========>wrapper2')
res2 = func2(*args,**kwargs)
print('end2')
return res2
return wrapper2
def deco3(func3): # func3 = 被装饰的index的内存地址
def wrapper3(*args,**kwargs):
print('==========> wrapper3')
res3 = func3(*args,**kwargs)
print('end3')
return res3
return wrapper3
# index = wrapper1的内存地址
@deco1 # deco1(wrapper2的内存地址) -> wrapper1的内存地址
@deco2 # deco2(wrapper3的内存地址) -> wrapper2的内存地址
@deco3 # deco3(被装饰的index的内存地址) -> wrapper3的内存地址
def index():
print('index...')
index()
二、迭代器
1、迭代器的概念：迭代器指的是迭代取值的工具，迭代就是一个重复的过程，但是每一次重复都是在上一次的基础之上进行的，而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代
2、为何要有迭代器？什么是可迭代对象？什么是迭代器对象？
#1、为何要有迭代器？
对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器
#2、什么是可迭代对象？
可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下
'hello'.__iter__
(1,2,3).__iter__
[1,2,3].__iter__
{'a':1}.__iter__
{'a','b'}.__iter__
open('a.txt').__iter__
#3、什么是迭代器对象？
可迭代对象执行obj.__iter__()得到的结果就是迭代器对象
而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象
调用迭代器对象的__iter__方法得到的它自己，就跟没调用一样
调用迭代器对象的__next__方法返回下一个值，不依赖索引
可以一直调用__next__直到取干净，则抛出异常StopIteration
文件类型是迭代器对象
open('a.txt').__iter__()
open('a.txt').__next__()
#4、注意：
迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象
for 循环迭代
nums_iter = iter(nums)
while True:
try:
res = next(nums_iter)
print(res)
except StopIteration:
break
1、先调用in后那个对象的__iter__方法，拿到迭代器对象
2、 res = next(迭代器对象)，执行一次循环体代码
3、循环往复步骤2，直到值取干净抛出异常StopIteration，for会捕捉异常结束循环
for res in nums:
print(res)
#基于for循环，我们可以完全不再依赖索引去取值了
dic={'a':1,'b':2,'c':3}
for k in dic:
print(dic[k])
#for循环的工作原理
#1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic
#2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码
#3: 重复过程2，直到捕捉到异常StopIteration,结束循环
迭代器的优缺点
#优点：
- 提供一种统一的、不依赖于索引的迭代方式
- 惰性计算，节省内存
#缺点：
- 无法获取长度（只有在next完毕才知道到底有几个值）
- 一次性的，只能往后走，不能往前退
三、生成器
1、什么是生成器
#只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码，得到的返回值即生成器对象
def func():
print('====>first')
yield 1
print('====>second')
yield 2
print('====>third')
yield 3
print('====>end')
g=func()
print(g) #<generator object func at 0x0000000002184360>
有了yield关键字，我们就有了一种自定义迭代器的实现方式。yield可以用于返回值，但不同于return，函数一旦遇到return就结束了，而yield可以保存函数的运行状态挂起函数，用来返回多次值。yield的总结
1、把函数做成迭代器
2、对比return，可以返回多次值，可以挂起/保存函数的运行状态
2、生成器就是迭代器
生成器内置有__iter__和__next__方法，所以生成器本身就是一个迭代器
g.__iter__
g.__next__
生成器就是迭代器，因此可以这么取值
res=next(g)
print(res)
