一、装饰器

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

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

理解装饰器的三要素：

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

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 timedef foo():    start = time.time()    print('foo...')    time.sleep(2)    end = time.time()    print(end - start)foo()

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

import timedef 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 timedef 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 timedef 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_timedef add(*a):    num = 0    for i in a:        num = num +i    print(num)add(2, 2, 3, 4, 7)

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

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

import timedef 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 = bprint(a)a = [1, 2, 3, 4, 5, 6, 7, 8, 9]for index,i in enumerate(a):    a[index] +=1print(a)

列表生成式方法：

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

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

def add(n):    return n + 1s = [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)0149162536496481

 所以，我们创建了生成器，就永远不会调用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 + 1g = 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是一个tuplea = t[0]b = t[1]

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

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

__author__ = 'Alex Li'import timedef 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