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

巴特西