七.python迭代器&生成器&装饰器

1.迭代器

1.1 什么是可迭代对象（Iterable）？

• 定义：可以直接作用于for循环的对象统称为可迭代对象，即Iterable。

　　可迭代对象包括:
　　　　1.集合数据类型:如list、tuple、dict、set、str等；
　　　　2.生成器类型:包括生成器和带yield的生成器函数。

1.2 什么又是迭代器（Iterator）？

• 定义：可以被next()或__next__()函数调用并不断返回下一个值（直到没有数据时抛出StopIteration错误）的对象称为迭代器，即Iterator。
• 迭代器的生成： __iter__()生成迭代对象时调用

　　注意：可迭代对象和迭代器不是一个概念，不要混淆。

　　使用内置函数isinstance和collections测试：

>>> import collections
>>> print(isinstance([], collections.Iterable)) #判断列表是不是可迭代的
True
>>> print(isinstance([], collections.Iterator)) #判断列表是不是迭代器
False
>>> 
>>> print(isinstance((), collections.Iterable)) #判断元组是不是可迭代的
True
>>> print(isinstance((), collections.Iterator)) #判断元组是不是迭代器
False
>>> 
>>> print(isinstance({}, collections.Iterable)) #判断字典是不是可迭代的
True
>>> print(isinstance({}, collections.Iterator)) #判断元组是不是迭代器
False
>>> 

　　以上表明，列表，字典，元组，等都是可迭代的，但都不是迭代器。

　　迭代器例子：

#因为列表不是迭代器，所以没有__next__方法
>>> a = [1,2,3,4]
>>> a.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute '__next__'

#用__iter__()生成迭代器，迭代器可以被__next__调用，每次返回一个值，直到没有数据时抛出StopIteration错误
>>> a = [1,2,3,4]
>>> b = a.__iter__()
>>> print(type(b))
<class 'list_iterator'>
>>> b.__next__() 
1
>>> b.__next__()
2
>>> b.__next__()
3
>>> b.__next__()
4
>>> b.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 

 

2.生成器

2.1 什么是生成器？

• 生成器就是迭代器，可以理解为一种数据类型，这种类型自动实现了迭代器协议.（其他的数据类型需要调用自己内置的__iter__方法）。
• 优点：

1. 效率高，相当于边生产边出售
2. 节省内存空间，按需构建，不是一次性构建
3. 保留函数运行的状态。不是从头运行，是从上一次的状态执行

2.2 生成器在python中的表现形式

1. 生成器表达式：类似于列表推导，但是，生成器按需返回结果的一个对象，而不是一次构建一个结果列表
2. 生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次从它离开的地方继续执行

　　示例：

#普通函数
>>> def test():
...     return 1      
...     return 2
...     return 3
...
>>> g = test()
>>> print(g)        #遇到一个return就停止
1
>>> print(g)        #遇到一个return就停止
1
>>>
>>> print(g.__next__()) #没有__next__()方法
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute '__next__'


#生成器函数
>>> def test():
...     yield 1
...     yield 2
...     yield 3            #和return不同的是可以返回多次
...
>>> g = test()
>>>
>>> print(g.__next__())    #生成器自动实现了迭成器,所以会有__next__()方法。
1
>>> print(g.__next__())    #第二次运行保存上一次运行的结果，就是上面说的保存状态。
2
>>> print(g.__next__())
3
>>> print(g.__next__())    #和迭代器一样，取完了就报StopIteration错。
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

生成器函数示例

 1 #比如我们要生成一个100万条数据的列表
 2 #我们会这样生成
 3 li = []
 4 for i in range(1000000):
 5     li.append(i)                    
 6 print(li)                            #这样有个缺点，占用内存较大
 7 >>> li = (x for x in range(1000000)) #这就是生成器表达式，和上面唯一不同的是，取一个，给一个，不占用空间。
 8 >>> li.__next__()
 9 0
10 >>> li.__next__()
11 1
12 >>> li.__next__()
13 2
14 >>> li.__next__()
15 3
16 >>>    

 

2.4 生成器send的用法***

• send主要是用于外部与生成器对象的交互，send的参数是指(上一次被挂起的yield语句的返回值)***

#*** yield 相当于return ，return是控制函数的返回值的
#x=yield的另外一个特性，接受send传过来的值,赋值给x

def test():
    print('one')
    first = yield 1      
    print('two', first)
    yield 2
    print('three')
    yield 3
res = test()

#第一次调用
print(res.__next__())
#结果(本次结果one是正常打印，None相当于没有返回值)
one
None

#第二种调用send(本次结果one是正常打印，None是函数没有返回值，two 是正常打印，"我是first"发送给了first，也就是第一次返回的值，2是正常打印)
print(res.__next__())
print(res.send('我是first')) # 这里的'我是first'就是上一次被挂起的yield语句的返回值。 
#结果
one
None
two 我是first
2

2.5 生产者消费者模型

• 这里学习下生产者消费者模型，以简单介绍下生成器的好处及原理。巩固下send的知识。

　　首先假设，路边拔丝蛋糕的买卖（两种方法）

　　1.第一种实现方法，做好了100盒准备卖，用100秒做好100盒蛋糕，然后一盒一盒的卖，来买蛋糕的人只能等做好100盒才能买。所有人都等着。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time
def shengchan():
    dangao = []
    for i in range(100):  
        time.sleep(1)
        dangao.append('第%s盒蛋糕' %i)
    return dangao

def mai(res):
    for index,dg in enumerate(res):
        time.sleep(1)
        print('第%s个人，买个%s' %(index,dg))

result = shengchan()
mai(result)

结果：
第0个人，买个第0盒蛋糕
第1个人，买个第1盒蛋糕
第2个人，买个第2盒蛋糕
第3个人，买个第3盒蛋糕
第4个人，买个第4盒蛋糕
第5个人，买个第5盒蛋糕
第6个人，买个第6盒蛋糕
第7个人，买个第7盒蛋糕
第8个人，买个第8盒蛋糕
第9个人，买个第9盒蛋糕
第10个人，买个第10盒蛋糕
....
第99个人，买个第99盒蛋糕

　　2.第二种实现方法，做一盒卖一盒，用1秒做一盒蛋糕被人买走了，又做了一盒又被人买走了，所有买蛋糕的人只等一秒就开心的买走了想要的蛋糕。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time
def mai(name):
    print('我是[%s],我要买一盒拔丝蛋糕' %name)
    while True:
        dangao=yield
        time.sleep(1)
        print('%s 买走了[%s]一盒' %(name,dangao))


def shengchan():
    c1 = mai('zhangsan')
    c2 = mai('lisi')
    c3 = mai('wangwu')
    c4 = mai('zhaoliu')
    c1.__next__()
    c2.__next__()
    c3.__next__()
    c4.__next__()
    for i in range(100):
        time.sleep(1)
        c1.send('拔丝蛋糕')
        c2.send('拔丝蛋糕')
        c3.send('拔丝蛋糕')
        c4.send('拔丝蛋糕')
shengchan()

结果：
我是[zhangsan],我要买一盒拔丝蛋糕
我是[lisi],我要买一盒拔丝蛋糕
我是[wangwu],我要买一盒拔丝蛋糕
我是[zhaoliu],我要买一盒拔丝蛋糕
zhangsan 买走了拔丝[蛋糕]一盒
lisi 买走了拔丝[蛋糕]一盒
wangwu 买走了拔丝[蛋糕]一盒
zhaoliu 买走了拔丝[蛋糕]一盒
zhangsan 买走了拔丝[蛋糕]一盒
lisi 买走了拔丝[蛋糕]一盒
wangwu 买走了拔丝[蛋糕]一盒
zhaoliu 买走了拔丝[蛋糕]一盒

总结：第二种方法要比第一种方法的效率高，这就是生成器的好处。边做边买。

2.6 列表解析&三元表达式简介

2.6.1 三元表达式

#基本判断
>>> x=1
>>> y=2
>>> if x > y:
...     print(x)
... else:
...     print(y)
...
2
>>>
    
#三元表达式判断
>>> x=1
>>> y=2
>>> res= print(x) if x > y else print(y)
2
>>>

#函数返回
>>> def max_xy(x, y):
...     if x > y:
...         return x
...     else:
...         return y
...
>>> max_xy(1,2)
2
>>>
#三元表达式返回
>>> def max_xy(x, y):
...     return x if x > y else y
...
>>> max_xy(1,2)
2
>>>

2.6.2 列表解析

#普通方式

>>> a='hello'
>>> l=[]
>>> for i in a:
...     res=i.upper()
...     l.append(res)
...
>>> print(l)
['H', 'E', 'L', 'L', 'O']
>>>

#列表解析方式

>>> a='hello'
>>> l=[i.upper() for i in a]
>>> print(l)
['H', 'E', 'L', 'L', 'O']
>>>

#普通方式

>>> l=[1,2,3,4,5]
>>> l_new=[]
>>> for i in l:
...     if i > 3:
...         l_new.append(i)
...
>>>
>>> print(l_new)
[4, 5]
>>>

#列表解析方式
>>> l=[1,2,3,4,5]
>>> res=[i for i in l if i > 3]
>>> print(res)
[4, 5]
>>>

#普通方式

>>> l=[]
>>> for i in range(10):
...     l.append(i)
...
>>> print(l)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

#列表解析方式

>>> res=[i for i in range(1,10)]
>>> print(res)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
 
#普通方式

>>> ret = []
>>> for x in range(5):
...     if x % 2 == 0:
...         for y in range(5):
...             if y % 2 ==1:
...                 ret.append((x,y))
...
>>> print(ret)
[(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]
print(ret)

#列表解析方式
>>> ret = [(x,y) for x in range(5) if x % 2==0 for y in range(5) if y % 2 ==1]
>>> print(ret)
[(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]
>>>

 

3.装饰器

3.1 什么是装饰器

• 借鉴了知乎上大神形象的比喻，内裤可以用来遮羞，但是到了冬天它没法为我们防风御寒，聪明的人们发明了长裤，有了长裤后宝宝再也不冷了，装饰器就像我们这里说的长裤，在不影响内裤作用的前提下，给我们的身子提供了保暖的功效。^_^.....^_^
• 定义：装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
• 遵循以下两个原则：

　　　1.不能修改被修饰函数的源代码

　　　2.不能修改被修饰函数的调用方式

• 装饰器储备知识：装饰器=高阶函数+函数嵌套+闭包(缺一不可)

 3.2 装饰器的好处

• 比如要实现计算一个函数的运行时间，示例。

　　原始函数

import time
def cale(n):
    res = 0
    for i in n:
        time.sleep(1)
        res+=i
    return res

print(cale(range(10)))

　　计算函数的运行时间（普通方式）

import time
def cale(n):
    start_time = time.time()
    res = 0
    for i in n:
        time.sleep(1)
        res+=i
    stop_time = time.time()
    print('函数的运行时间是%s' %(stop_time-start_time))
    return res
print(cale(range(10)))

　　这里我们可以实现，在函数之中加了个计算时间的逻辑，如果需求是要计算所有函数的运行时间，那么就显得笨重。这时候就用到装饰器了。

　　计算函数的运行时间（装饰器方式）

#装饰器
import time
def zhuangshi(func):                #高阶函数，参数是一个函数
    def wapper(*args,**kwargs):     #函数之内定义函数，是函数的嵌套
        start_time = time.time()    #闭包：在一个作用域里放入定义变量，相当于打了一个包
        res = func(*args,**kwargs)
        stop_time = time.time()     #闭包：在一个作用域里放入定义变量，相当于打了一个包
        print('函数的运行时间是%s' % (stop_time - start_time))
        return res
    return wapper                   #高阶函数，返回值是一个函数

@zhuangshi                          #@zhuangshi是装饰器的用法，要装饰哪个函数就在函数前加“@装饰器名（装饰器函数名）”等同于cale=zhuangshi(cale)
def cale(n):
    res = 0
    for i in n:
        time.sleep(1)
        res+=i
    return res

print(cale(range(10)))              #符合装饰器的原则，调用方式不变

#结论=======>装饰器=高阶函数+函数嵌套+闭包

　　这样就实现了在任何函数前面加@zhuangshi，就可以计算函数的运行时间了。

  3.3 带参数的装饰器

• 无参数装饰器（以登录京东、访问家目录、访问购物车、为例的装饰器）

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#用户列表
user_list = [
    {'name':'zhangsan','passwd':'123'},
    {'name':'lisi','passwd':'456'},
    {'name':'wangwu','passwd':'789'},
]
#全局变量一改，其他子程序都会改,用来跟踪用户的登录状态
user_dic={'username':None,'login':False}

#无参数装饰器
def auth_func(func):
    def wapper(*args, **kwargs):
            if user_dic['username'] and user_dic['login']:  # 这里判断状态
                res = func(*args, **kwargs)
                return res
            username = input('username: ').strip()
            passwod = input('password: ').strip()
            for userdic in user_list:
                if username == userdic['name'] and passwod == userdic['passwd']:
                    user_dic['username'] = username
                    user_dic['login'] = True
                    res = func(*args, **kwargs)
                    return res
            else:
                print('用户名或密码错误')
    return wapper

@auth_func
def index():
    print('欢迎来到京东主页')

@auth_func
def home(name):
    print('欢迎%s来到家目录' %name)

@auth_func
def shopping_car(name):
    print('欢迎来到购物车，%s的购物车里有[%s,%s,%s]' %(name,'洗面奶','牛奶','酸奶'))

print('开始---------------------->',user_dic)
index()
print('结束---------------------->',user_dic)

print('\n')
print('开始---------------------->',user_dic)
home('all is well')
print('结束---------------------->',user_dic)
print('\n')

print('开始---------------------->',user_dic)
shopping_car('all is well')
print('结束---------------------->',user_dic)

#################################################
#输出结果

开始----------------------> {'login': False, 'username': None}
username: zhangsan
password: 123
欢迎来到京东主页
结束----------------------> {'login': True, 'username': 'zhangsan'}


开始----------------------> {'login': True, 'username': 'zhangsan'}
欢迎all is well来到家目录
结束----------------------> {'login': True, 'username': 'zhangsan'}


开始----------------------> {'login': True, 'username': 'zhangsan'}
欢迎来到购物车，all is well的购物车里有[洗面奶,牛奶,酸奶]
结束----------------------> {'login': True, 'username': 'zhangsan'}

• 带参数装饰器（给装饰器加上参数，参数为登录京东、访问家目录、访问购物车、加上不同的验证类型）

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#用户列表
user_list = [
    {'name':'zhangsan','passwd':'123'},
    {'name':'lisi','passwd':'456'},
    {'name':'wangwu','passwd':'789'},
]
#全局变量一改，其他子程序都会改,用来跟踪用户的登录状态
user_dic={'username':None,'login':False}

#带参数装饰器
#要给装饰器传参数这里我们就多加一层auth来实现，最外面层传参数，最里层能收到。
def auth(auth_type='filedb'):
    def auth_func(func):
        def wapper(*args,**kwargs):
            if auth_type == 'auth_1':
                print("认证类型是", auth_type)
                if user_dic['username'] and user_dic['login']:   #这里判断状态，session
                    res = func(*args, **kwargs)
                    return res
                username = input('username: ').strip()
                passwod = input('password: ' ).strip()
                for userdic in user_list:
                    if username == userdic['name'] and passwod == userdic['passwd']:
                        user_dic['username'] = username
                        user_dic['login'] = True
                        res = func(*args,**kwargs)
                        return res
                else:
                    print('用户名或密码错误')
            elif auth_type == 'auth_2':
                print("认证类型是", auth_type)
                res = func(*args, **kwargs)
                return res
            else:
                print("不知道的类型")
                res = func(*args, **kwargs)
                return res
        return wapper
    return auth_func


@auth(auth_type='auth_1') #这里参数为auth_1
def index():
    print('欢迎来到京东主页')

@auth(auth_type='auth_2') #这里参数为auth_2
def home(name):
    print('欢迎%s来到家目录' % name)

@auth(auth_type='auth_3') #这里参数为auth_3
def shopping_car(name):
    print('欢迎来到购物车，%s的购物车里有[%s,%s,%s]' % (name, '洗面奶', '牛奶', '酸奶'))

print('开始---------------------->',user_dic)
index()
print('结束---------------------->',user_dic)

print('\n')
print('开始---------------------->',user_dic)
home('all is well')
print('结束---------------------->',user_dic)
print('\n')

#################################################
#输出结果

开始----------------------> {'username': None, 'login': False}
认证类型是 auth_1
username: zhangsan
password: 123
欢迎来到京东主页
结束----------------------> {'username': 'zhangsan', 'login': True}


开始----------------------> {'username': 'zhangsan', 'login': True}
认证类型是 auth_2
欢迎all is well来到家目录
结束----------------------> {'username': 'zhangsan', 'login': True}


开始----------------------> {'username': 'zhangsan', 'login': True}
不知道的类型
欢迎来到购物车，all is well的购物车里有[洗面奶,牛奶,酸奶]
结束----------------------> {'username': 'zhangsan', 'login': True}