Python_装饰器、迭代器、生成器

一、装饰器

装饰器的存在是为了实现开放封闭原则：　　

• 封闭： 已实现的功能代码块不应该被修改；
• 开放： 对现有功能的扩展开放。

理解装饰器的三要素：

• 函数的作用域
• 高阶函数
• 闭包

1. 闭包

闭包定义：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包（closure）

def test_1(x = 20):
    def test_2():                                           # 条件一： test_2就是内部函数
        print(x)                                            # 条件二： 对外部函数变量的引用
    return test_2()                                         # 结论： 内部函数test_2就是一个闭包
test_1()

2. 装饰器的应用

现在有如下一段代码，需要测算出代码的执行时间。

def foo():
    print('foo...')
foo()

对功能进行扩展：

由于代码执行太快，使用sleep暂停2s，此次修改没有执行开放封闭原则，修改了原代码。

import time
def foo():
    start = time.time()
    print('foo...')
    time.sleep(2)
    end = time.time()
    print(end - start)

foo()

此次修改改变了调用方式，差评！

import time
def foo():
    print('foo...')

def show_time(func):
    start = time.time()
    func()
    time.sleep(3)
    end = time.time()
    print('spend %s' % (end - start))

show_time(foo)

完美实现！五星好评~~

import time
def show_time(f):
    def func():
        start = time.time()
        f()
        time.sleep(3)
        end = time.time()
        print('spend %s' % (end - start))
    return func

@show_time                      # @show_time 等价于 “foo = show_time(foo)”
def foo():
    print('foo...')
foo()

装饰器之功能函数的参数：

前边写了功能函数中没有带参数，如果功能功能函数中有参数呢？

import time
def show_time(f):
    def func(*a):
        start = time.time()
        f(*a)
        time.sleep(3)
        end = time.time()
        print('spend %s' % (end - start))
    return func

@show_time
def add(*a):
    num = 0
    for i in a:
        num = num +i
    print(num)
add(2, 2, 3, 4, 7)

装饰器之装饰器函数的参数：

有这样一个需求，在代码执行的过程中有的需要记录日志，有的不需要记录日志，怎么办呢？给原本装饰器外再套一个装饰器，功能函数执行过程中再进行判断。

import time

def logger(flag = 'True'):
    def show_time(x):
        def func():
            start = time.time()
            x()
            time.sleep(3)
            end = time.time()
            print('spend %s' % (end - start))
            if flag == 'True':
                with open('装饰器测试文件', 'w', encoding='utf8') as f:
                    f.write('添加日志测试！！！')
        return func
    return show_time

@logger()
def foo():
    print('foo...')
foo()

二、生成器

1.  列表生成式

现在有个需求，将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]中的每个值都加一，怎么实现？

先介绍两种之前学过的方法：

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
b = []
for i in a:
    b.append(i+1)
a = b
print(a)

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for index,i in enumerate(a):
    a[index] +=1
print(a)

列表生成式方法：

a = [i + 1 for i in range(10)]
print(a)

列表生成式带函数创建方法：

def add(n):
    return n + 1
s = [add(x) for x in range(10)]
print(s)

2. 生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个生成器方法有很多种，第一种就是将列表生成式的“[]”换为“()”，生成器本身为可迭代对象。

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

# 列表生成式
L = [x*x for x in range(10)]
print(L)

# 生成器
g = (x*x for x in range(10))
print(g)

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。我们不可能一直调用next(g)，在上边说过，生成器本身就是可迭代对象，所以可以使用for循环来取值。

s = (x*x for x in range(10))
for i in s:
    print(i)

0
1
4
9
16
25
36
49
64
81

所以，我们创建了生成器，就永远不会调用next方法，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

# 生成器：斐波那契
def fib(max):
    n, before, after = 0, 0, 1
    while n < max:
        yield (before)
        before, after = after, before + after
        n = n + 1
g = fib(8)

for i in fib(8):
    print(i)

# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))

# print(next(fib(8)))                                                           # 每次都是从头算
# print(next(fib(8)))
# print(next(fib(8)))
# print(next(fib(8)))

注意复制语句：

a, b = b, a + b

相当于：

t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

但不必显式写出临时变量t就可以赋值。

还可通过yield实现在单线程的情况下实现并发运算的效果。（转自金角大王_Alex,博客）

__author__ = 'Alex Li'

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))

def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("alex")

三、迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

可以使用isinstance()判断一个对象是否是Iterable对象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

生成器都是可迭代对象，但列表、字典、集合虽然是可迭代对象，但不是迭代器。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

小结：

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

# 完全等价于

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break