4.29—014—周一

今日所学内容

一、带参装饰器

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

　　-- 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

二、迭代器

迭代器对象: 可以不用依赖 索引 取值的容器

可迭代对象：可以通过某种方法得到迭代器对象

迭代器优点：可以不用依赖索引取值

迭代器缺点：只能从前往后依次取值

1、可迭代对象：

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

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

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

　　print(res)  # <list_iterator object at 0x000002732B0C7470>

　　可迭代对象有哪些：str | list | tuple | set | dict | range() | enumerate() | file | 生成器对象

2、迭代器对象：

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

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

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

　　　　print(res)

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

　　　　print(res)

　　迭代器对象有哪些：set

3、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异常 结束取值循环

三、枚举对象

给可迭代对象及迭代器对象添加 迭代索引

　　s = 'abc'

　　for v in enumerate(s):

　　　　print(v)  # (0 'a') | (1 'b') | (2 'c')

四、生成器

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

　　-- 就是用函数语法来声明生成器，用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

　　print(my_range(10))    ==>  <generator object my_range at 0x00000209CA623A40>  my_range(10)  的地址

 

 

　　for v in my_range(10):

　　　　print(v, end=' ')

　　print(list(my_range(10)))   ==>  [0,1,2,3,4,5,6,7,8,9]