迭代器

带参装饰器
通常，装饰器为被装饰的函数添加新功能，需要外界的参数

-- outer参数固定一个，就是func

-- inner参数固定同被装饰的函数，也不能添加新参数

-- 可以借助函数的嵌套定义，外层给内层传参

def wrap(info):

def outer(func):

# info = 0

def inner(*args, **kwargs):

print('新：拓展的新功能，可能也需要外界的参数%s' % info)
res = func(*args, **kwargs)

return res

return inner

return outer

@wrap('外部参数')

def fn(): pass

系统的wraps带参装饰器：改变inner的假指向，本质外界使用的还是inner，但是打印显示的是wraps中的函数

from functools import wraps
def
outer(func):

@wraps(func)

def inner(*args, **kwargs):

res = func(*args, **kwargs)

return res

return inner

@outer

def fn(): pass

迭代对象
迭代器：循环反馈的容器(集合类型)

-- 不同于索引取值，但也可以循环的从容器对象中从前往后逐个返回内部的值

优点：不依赖索引，完成取值

缺点：不能计算长度，不能指定位取值(只能从前往后逐一取值)

可迭代对象
可迭代对象：有__iter__()方法的对象是可迭代对象，可迭代对象调用__iter__()得到迭代器对象

ls = [4, 1, 5, 2, 3]

res = ls.__iter__() # => 可迭代对象

print(res) <list_iterator object at 0x000002732B0C7470>

迭代对象
迭代器对象：有__next__()方法的对象是迭代器对象，迭代器对象依赖__next__()方法进行取值

with open('1.txt', 'rb') as f:

res = f.__next__() # 文件中的第一行内容
print(res)
res = f.__next__() # 文件中的第二行内容
print(res)

for循环迭代器
直接用while True循环在迭代器对象中通过 __next__() 取值，取空时，取空再取值，报StopIteration异常

ls = [3, 1, 2, 3, 5]

iterator = ls.__iter__()

while True:

try:

print(iterator.__next__())

except StopIteration:

# print('取空了')

break

for循环就是对while取迭代器对象的封装

for v in ls:

print(v)

for v in ls.__iter__(): #可迭代对象.__iter__() => 迭代器对象
print(v)

iterator = ls.__iter__()

for v in iterator: # 迭代器对象.__iter__() => 自身
print(v)

for循环迭代器的工作原理：

for v in obj: pass
#
1）获取obj.__iter__()的结果，就是得到要操作的 迭代器对象

2）迭代器对象通过__next__()方法进行取值，依次将当前循环的取值结果赋值给v

3）当取值抛异常，自动处理StopIteration异常结束取值循环

生成器
生成器：自定义的迭代器对象

-- 就是用函数语法来声明生成器，用yield关键字取代return关键字来返回值，参数没有多少变化

总结：有yield关键字的函数，函数名() 不是调用函数，而是生成得到 生成器对象，生成器对象就是迭代器对象，可以通过 __next__() 进行取值

执行流程:
def fn():

yield 1

yield 3

yield 5

obj = fn()
obj.__next__()
从开始往下执行，遇到第一个yield停止，拿到yield的返回值
obj.__next__()
从上一次停止的yield往下执行，在再遇到的yield时停止，拿到当前停止的yield的返回值

...
以此类推，直到无法获得下一个yield，抛StopIteration异常

可以直接被for循环遍历

for v in fn():

print v

案例一：创建生成器，从其取值，依次得到1! 2! 3! ...

def jiecheng():

ji = 1

count = 1

while True:

ji *= count

yield ji

count += 1

obj = jiecheng()

print(obj.__next__())

print(obj.__next__())

print(obj.__next__()) # 可以无限取

案例二：

def jiecheng_num(num):

ji = 1

for i in range(1, num + 1):

ji *= i

yield ji

# ..。

obj = jiecheng_num(3)

print(obj.__next__())

print(obj.__next__())

print(obj.__next__())

print(obj.__next__()) # 有异常了

for v in jiecheng_num(5):

print(v) # 会自动处理异常停止

案例三：
def my_range(num): # => [0, 1, 2, ..., num - 1]
count = 0

while count < num:

yield count

count += 1

for v in my_range(10):

print(v, end=' ')

print(list(my_range(10)))