六、迭代器、生成器和装饰器

1.迭代器
2. 生成器
3. 装饰器

1.迭代器

定义

能被next()函数进行调用且不断返回下一个值的对象。其内置方法中包含__iter__（返回迭代器本身）和__next__（返回容器的下一个元素）。
特征

迭代器会生成惰性序列，它通过计算把值依次的返回，一边循环一边计算，而不是一次性得到所有的数据。
优点

需要数据的时候，一次取一个，可以在很大程度上节省内容空间，而不是一次性把所有的数据存入内存中；此外，可以遍历无限量的数据。

创建

使用iter()函数来创建。

string = iter('abcd')
print(next(string))
print(next(string))
print(next(string))
print(next(string))
# 遍历完成之后继调用
print(next(string))

# 输出结果
StopIteration
a
b
c
d

# 注意：当遍历完序列时，会引发一个StopIteration异常。使用for循环可以规避整个问题（for循环的底层使用了next方法）。
string = iter('abcd')
for item in string:
    print(item)
# 输出结果
a
b
c
d

2. 生成器

定义

包含了yield语句的函数。
特征

执行生成器函数时，其内部代码不执行，而是返回一个生成器对象（特殊的迭代器）。生成器可以暂停函数并返回一个中间结果（遇到yield本次循环就终止，并返回yield后的值），可以被for循环或者用next函数逐个取值。

格式

# 格式一
def fun():
    print('第一次执行')
    yield 1
    print('第二次执行')
    yield 2
    print('第三次执行')
    yield 3

result = fun()
print(result, type(result))
for i in result:
    print(i)
 

# 格式二
def fun():
    print('第一次执行')
    yield 1
    print('第二次执行')
    yield 2
    print('第三次执行')
    yield 3

result = fun()
print(next(result))
print(next(result))
print(next(result))


# 输出结果
<generator object fun at 0x000001A203DD5A20> <class 'generator'>
第一次执行
1
第二次执行
2
第三次执行
3

注意

生成器中不能包含return语句，遇到return语句则会结束生成器。


def fun():
    print('第一次执行')
    yield 1
    print('第二次执行')
    yield 2
    return 123
    print('第三次执行')
    yield 3

for i in fun():
    print(i)
  
# 输出结果
第一次执行
1
第二次执行
2

生成器推导式

result = (lambda: i ** 2 for i in range(1, 5))
print(type(result))
for i in result:
    print(i())
    
# 输出结果
<class 'generator'>
1
4
9
16


# 对比列表推导式
result = [lambda: i ** 2 for i in range(1, 5)]
print(type(result))
for i in result:
    print(i())
   
# 输出结果
<class 'list'>
16
16
16
16

3. 装饰器

定义

在不改变原函数内部代码的基础上，在函数执行之前和之后自动执行某个功能。

装饰器编写格式

def 外层函数(传入参数):
    def 内层函数(*args, **kwargs):
        result = 传入参数(*args, **kwargs)
        return result
    return 内层函数

装饰器应用格式

@外层函数
def index():
    pass

index()

作用

# 和index函自身相比，使用装饰器之后，执行index函数可以在原函数的基础上多执行print('执行原函数前')和print('执行原函数后')两条语句，此处是以最简单的方式来进行说明，完全可以根据需求将这两个语句换成功能更复杂的语句块。

def 外层函数(传入参数):
    def 内层函数(*args, **kwargs):
        print('执行原函数前')
        result = 传入参数(*args, **kwargs) # 执行原函数并返回值
        print('执行原函数后')
        return result
    return 内层函数

@外层函数
def index():
    pass

index()

例子

def fun(arg):
    def inner():
        print('执行函数前添加的功能：', 1)
        v = arg()
        print('执行函数后添加的功能：', 3)
        return v
    return inner

# 第一步：执行fun函数并将下面的函数作为参数传递，相当于：fun(index)
# 第二步：将fun的返回值重新赋值给下面的函数名，相当于：index = fun(index)
@fun
def index():
    print('函数自己的功能：', 2)
    return 666

index()

# 输出结果为
执行函数前添加的功能： 1
函数自己的功能： 2
执行函数后添加的功能： 3

# 若没有@fun语句（没有使用装饰器）,输出结果为
函数自己的功能： 2

带参数的装饰器

# 可以用于连续多次重复执行函数
def with_parameter(count):
    def outer(arg):
        def inner():
            for i in range(count):
                print('
第%d次执行' % (i + 1))
                print('执行函数前添加的功能：', 1)
                v = arg()
                print('执行函数后添加的功能：', 3)
            return v
        return inner
    return outer

# 相当于：index = with_parameter(3)(index)
@with_parameter(3)
def index():
    print('函数自己的功能：', 2)
    return 666

result = index()
print('
函数最后的返回结果：', result)

# 输出结果

第1次执行
执行函数前添加的功能： 1
函数自己的功能： 2
执行函数后添加的功能： 3

第2次执行
执行函数前添加的功能： 1
函数自己的功能： 2
执行函数后添加的功能： 3

第3次执行
执行函数前添加的功能： 1
函数自己的功能： 2
执行函数后添加的功能： 3

函数最后的返回结果： 666

装饰器的嵌套

def outer1(fun):
    def inner1():
        print('This is 001')
        result1 = fun()
        print('This is 002')

        return result1

    return inner1


def outer2(fun):
    def inner2():
        print('This is 003')
        result2 = fun()
        print('This is 004')

        return result2

    return inner2


@outer1
@outer2
def origin():
    print('This is initial')


origin()

# 输出结果
This is 001
This is 003
This is initial
This is 004
This is 002

'''
逻辑法分析：
步骤一：origin = outer2(origin)，outer2(origin) == inner2
步骤二：origin = outer1(outer2(origin))，origin = outer1(inner2)，outer1(inner2) == inner1
步骤三：执行origin()等价于inner1()，此时输出This is 001；接着执行inner2()，此时输出This is 003；然后执行origin()原函数，此时输出This is initial；origin()原函数执行完毕，接着输出This is 004；inner2()执行完毕，接着输出This is 002，至此，整个函数执行完毕。
'''

'''
装饰器思想法分析：
outer2是origin的装饰器，outer1又是outer2的装饰器。
因此，在执行该嵌套装饰器时，outer1的目的是在未改变outer2的情况下，在其执行前后添加所需的功能，所以outer1的'This is 001'最先输出，接着输出outer2的内容。而outer2是origin的装饰器，所以outer2的目的是在未改变origin的情况下，在其执行前后添加所需的功能，所以outer的'This is 003'先输出，接着输出origin的'This is initial'，然后输出outer2的'This is 004'，最后输出outer1的'This is 002'。
'''

# 注意：多层装饰器嵌套时，按从下往上的方向执行。