day18 装饰器（下）+迭代器+生成器

一、有参装饰器
二、迭代器
三、生成器

一、有参装饰器

1 前提

上节课讲了无参装饰器的用法，模板如下：

def outter(func):#参数写死，为了给语法糖传值

    def warpper(*args,**kwargs):#参数写死，为了给func传值

        res = func(*args,**kwargs)

        return res

    return warpper

@outter

def index():

    print("这是主页")

    return 1

res = index()

print(res)

>>>这是主页

>>>1

从这段模板代码我们可以看出，装饰器的两个函数我们都无法为它增加新的参数传值

所以，当我们的装饰器需要跟多参数的时候，就只能通过闭包函数为他传值

2 如何使用有参装饰器

下面通过一个需求来表现有参装饰器的用途：

例：编写装饰器对多个函数添加认证功能，如果登录成功过，其他函数就不需要再次登录

分析需求：我们要编写认证功能的话只要添加个简单的有判断的装饰器即可，但是要判断之前是否成功过，我们就需要用到全局变量，如果登录成功把全局变量修改即可。所以我们在装饰器内部就要再判断一下，这个全局变量的值是什么，这里就会出现矛盾

我们要先判断全局变量，如果没有登录过，就修改他的值，这里违背了变量的先定义后引用的原则

所以基于这个矛盾，我们需要对装饰器传值，而在上面模板中我们已经知道，装饰器的函数我们都无法为他传值，因为各有用途都写死了。所以我们只能用第二种传值方式：闭包

is_login = True

def auth(login):

    def outter(func):

        def warpper(*args,**kwargs):

            if login:

                name = input("你的名字：")

                pwd = input("你的密码：")

                if name == "hz" and pwd == "123":

                    print("登录成功")

                    func(*args,**kwargs)

                    global is_login

                    is_login=False

                else:

                    print("输入错误")

            else:

                func(*args,**kwargs)

        return warpper

    return outter

#语法糖的定义：被装饰函数 = @后面的东西（被装饰的函数）

#index = auth(is_login)(index)

#auth(is_login) == outter

#outter(index) ==warpper

@auth(is_login)

def index():

    print("你好")

index()

@auth(is_login)

def home():

    print("欢迎回家")

home()

3 有参装饰器模板

def 有参装饰器(x,y,z):

    def outter(func):

        def wrapper(*args, **kwargs):

            res = func(*args, **kwargs)

            return res

        return wrapper

    return outter

@有参装饰器(1,y=2,z=3)

def 被装饰对象():

    pass

4 修正装饰器

我们的装饰器最终目的就是要把（原函数+装饰器）修改成和没有修改的函数一样（属性上）

但是，我们之前的学习装饰器还没有完成最终目的

@timer

def home(name):

    '''

    home page function

    :param name: str

    :return: None

    '''

    time.sleep(5)

    print('Welcome to the home page',name)

print(help(home))

'''

打印结果：

Help on function wrapper in module __main__:

wrapper(*args, **kwargs)

None

每个函数在定义出来后就有非常多的属性，名字，注释等等，我们如果一一修改就非常麻烦，这里可以用functools模块下提供的一个装饰器wraps专门用来帮我们实现这个：

from functools import wraps

def timer(func):

    @wraps(func)

    def wrapper(*args,**kwargs):

        start_time=time.time()

        res=func(*args,**kwargs)

        stop_time=time.time()

        print('run time is %s' %(stop_time-start_time))

        return res

    return wrapper

二、迭代器

1 什么是迭代器

迭代：就是每一次重复都是基于上一次运行得到结果来进行循环，单纯的重复不是迭代

器：指工具

这里要区别两种类似的循环：

i = 0

while True:

    i+=1

    print(i)

while True:

    print("i")

这两种都叫循环，但是第一种实现的就是迭代的过程，第二种就是单纯的循环

2 为什么要有迭代器

迭代器就是取值的工具，涉及到把多个值循环取出的类型

例：字符串，列表，字典，集合，元组，打开的文件

而上述6种数据类型，又分为可索引取值和不可索引取值

可索引取值：字符串，列表，元组

l = [1,2,3,4,5,6]

count = 0

while count<len(l):

    print(l[count])

    count+=1

明显从中可以看出，索引取值的局限性，于是就有了迭代器：不依赖索引取值的方式。

3 如何用迭代器

3.1 可迭代对象

可迭代对象是什么，可以做一个比喻

桌子上有三个东西，一个是活着的鸡，一个是烤箱，一个是烤鸡

活鸡：不能吃的东西，但是可以通过烤箱变成可以吃的烤鸡

烤箱：是一个把活鸡转换成烤鸡的工具

烤鸡：可以吃的东西

把上述比喻转化成程序思维

可迭代对象：不能进行迭代循环，但是可以通过工具转化成迭代器

“——iter——”方法：可以把可迭代对象转化成迭代器的工具

迭代器：可以进行迭代循环

这里就会有人有疑问，在编程中如何一下子判断这个对象是不是可迭代对象

我们可以通过iter方法测试一下，有这个内置方法他就是可迭代对象

s1=''

s1.__iter__()

l=[]

l.__iter__()

t=(1,)

t.__iter__()

d={'a':1}

d.__iter__()

set1={1,2,3}

set1.__iter__()

with open('a.txt',mode='w') as f:

    f.__iter__()

    pass

通过这个测试，我们发现我们需要测试的6种数据类型都是可迭代对象

那么，如何用可迭代对象进行迭代循环呢

第一步：把可迭代对象转化成迭代器

第二步：用next方法读取迭代器内的值

d={"A":1,"B":2}

d_i = d.__iter__()

while True:

    print(d_i.__next__())

>>>A

>>>B

>>>抛出异常StopIteration

这里我们对抓取异常重新处理循环

d={"A":1,"B":2}

d_i = d.__iter__()

while True:

    try:

        print(d_i.__next__())

    except StopIteration:

        break

>>>A

>>>B

3.2 可迭代对象和迭代器对象详解

可迭代对象（可以转换成迭代器的对象）：内置有iter方法的对象

可迭代对象.iter_（）：得到迭代器对象

迭代器对象：内置有iter方法和next方法的对象

迭代器对象._next _():得到迭代器的下一个值

迭代器对象._next _()：得到迭代器对象本身，就是和没调用一样

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

迭代器对象：文件对象

4 for循环的工作原理

我们刚刚已经通过while循环解决了不可索引数据类型的迭代循环，这和for循环的工作原理基本一致

第一步：把我们需要循环的数据类型转换成迭代器对象

第二步：通过next方法拿到一个返回值，把这个值给i

第三步：循环步骤二，直到抛出StopIteration异常，for循环会捕捉异常并退出循环

l = [1,2,3]

for i in l :

    print(i)

>>>1

>>>2

>>>3

5 迭代器的优缺点

优点：

为序列与非序列类型提供了一种统一的迭代取值方式
惰性计算，迭代器本身是一个数据列，可以只在需要的时候去调用next取得下一个值，在同一时间内，迭代器只存在一个值。所以迭代器的容量是无线大的，但是对于其他的容器类型，如列表，通常不会一次性存放很多个值，受内存大小限制。

缺点：

除非用完整个迭代器，否则无法获取迭代器长度
只能取下一个值，不能控制他如何取值，如果要重新开始，就要重新定义一个迭代器对象

三、生成器

我们之前获得的迭代器都是通过可迭代对象获得的，那么如果自定义一个迭代器呢

在函数内一旦存在yield关键字，调用函数并不会执行代码

会返回一个生成器对象，生成器就是自定义的迭代器

def func():

    print('第一次')

    yield 1

    print('第二次')

g = func()#返回一个生成器对象

#g.__iter__()

#g.__next__()

#生成器就是迭代器

res = g.__next__()

print(res)

#通过next方法调用迭代器的下一个值，会执行第一个yield上面的代码，并将该yield的返回值返回

>>>第一次

>>>1

这里可以优化一下写法

iter(可迭代对象) == 可迭代对象.__iter__()

next(可迭代对象) == 可迭代对象.__next__()

模拟range，自定义一个迭代器

def my_range(start,stop,step):

    while start<stop:

        yield start #生成器取下一个值时函数从这下面开始运行

        start += step

res = my_range(0,1000,7)

print(res.__next__())

print(res.__next__())

>>>0

>>>7

yield关键字不同于return，return是直接把函数结束，而yield是把函数在这里挂起，等待下一次调用，可以返回多个返回值