python第十四天

今日内容

1. 带参装饰器  |  wrapper

2. 迭代器

3. 可迭代对象

4.迭代器对象

5.for 迭代器

6.枚举对象

带参装饰器

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

　　　　----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
fn()

# 系统自带的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
fn()

迭代器

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

2.可迭代对象：可以通过某种方式得到迭代器对象

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

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

可迭代对象

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

ls = [9,8,7,6,5,4,3]
res = ls.__iter__()  # --> 可以使用__iter__方法，可迭代对象。
print(res)           # <list_iterator object at 0x0000026A432481D0>  此处的iterator的意思是迭代器对象，
                     # 因为使用__iter__后会转为__next__(迭代器对象)

迭代器对象

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

with open('1.txt','rb')as f:
    res = f.__next__()　 #  可调用__next__方法。迭代器对象
    print(res)          #  会把文件中的第一行内容读出来
    res = f.__next__()
    print(res)          # 再次执行会把第二行内容读出来。 迭代器缺点，只能从前往后依次取值。
                        # 以此类推，直至取空，如果取空后未停止依旧报错

for循环迭代器

如果直接用while True 循环在迭代器对象中通过__next__()的方法取值，如果值取空后没有停止取值，继续取值会抛出异常：StopIteration

ls = [3,2,5,4,1]
iterator = ls.__iter__()
while True:
    print(iterator.__next__())  #  如果直接通过迭代器循环。数值取完后会报错 StopIteration

不过我们可以通过try 来捕获异常，并处理异常。for的工作原理就是如此，

ls = [3,2,5,4,1]
iterator = ls.__iter__()
while True:
    try:                            # 可以查看异常的语句
        print(iterator.__next__())
    except StopIteration:          #  捕获异常信息，并把遗产是个信息处理掉
        break

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

ls = [3,2,5,4,1]
for v in ls:
    print(v)

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

for v in obj: pass

1.获取被循环对象(obj)的__iter__()的结果，得到要操作的迭代器对象

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

3.当值取空后，自动处理StopIteration异常，然后结束循环

枚举对象

给可迭代器对象及迭代器对象添加迭代索引，关键字为 enumerate

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

for v in my_range(10):
　　print(v, end=' ')

print(list(my_range(10)))