python中“生成器”“迭代器”“闭包”“装饰器”的深入理解

Posted 2020-10-14 天意凉

一、生成器

1、什么是生成器？

在python中，一边循环一边计算的机制，称为生成器：generator.

2、生成器有什么优点？

　　1、节约内存。python在使用生成器时对延迟操作提供了支持。所谓延迟，是指在需要的时候才产生结果，而不是立即产生结果。这样在需要的时候才去调用结果，而不是将结果提前存储起来要节约内存。比如用列表的形式存放较大数据将会占用不少内存。这是生成器的主要好处。比如大数据中，使用生成器来调取数据结果而不是列表来处理数据，因为这样可以节约内存。

　　2、迭代到下一次的调用时，所使用的参数都是第一次所保留下的。

3、在python中创建生成器

在python中，有两种创建生成器的方式：

　　1、生成器表达式

类似与列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表。

使用列表推导，将会一次返回所有结果：

1 li=[i**2 for i in range(5)]
2 print(li)
3 
4 [0, 1, 4, 9, 16]
5 [Finished in 0.3s]

将列表推导的中括号，替换成圆括号，就是一个生成器表达式：

1 li=(i**2 for i in range(5))
2 print(li)
3 for x in range(5):
4     print(next(li))

输出结果为：

1 <generator object <genexpr> at 0x0000000001E18938>
2 0
3 1
4 4
5 9
6 16
7 [Finished in 0.3s]

注意：创建完成生成器后，可以使用next()来调用生成器的数据结果，每调用一次返回一个值，直到调用结束。调用结束后li中为空的，不在有任何值。要想使用它，只能重新创建新的生成器。(生成器表达式的第四行代码也可以改成：print(x).)

　　2、生成器函数

常规函数定义，但是使用yield语句而不是return语句返回结果。yield语句每次返回一个结果，但每个结果中间，挂起函数的状态，以便下次从它离开的地方继续执行。

我们下面来看一个例子。下面为一个可以无穷生产奇数的生成器函数。

 1 def odd():
 2     n=1
 3     while True:
 4         yield n
 5         n+=2
 6 odd_num=odd()
 7 count=0
 8 for o in odd_num:
 9     if count >=5:
10         break
11     print(o)
12     count += 1

输出结果为：

1 1
2 3
3 5
4 7
5 9
6 [Finished in 0.3s]

上面的函数中，yield是必备的，当一个普通函数中包含yield时，系统会默认为是一个generator。

再举一个例子。使用生成器函数来生成斐波纳契数列。

 1 def fib(times):
 2     n = 0
 3     a,b = 0,1
 4     while n < times:
 5         yield b
 6         a,b = b,a + b
 7         n += 1
 8     return "done"
 9 f = fib(5)
10 for x in f:
11     print(x)

输出结果为：

1 1
2 1
3 2
4 3
5 5
6 [Finished in 0.3s]

生成器的两种方法：__next__() 和 send() 方法。

其中，__next__() 方法和next的作用是一样的。如下所示。

 1 def fib(times):
 2     n=0
 3     a,b=0,1
 4     while n < times:
 5         yield b
 6         a,b=b,a+b
 7         n+=1
 8 f = fib(5)
 9 for i in range(5):
10     print(f.__next__())

输出结果为：

1 1
2 1
3 2
4 3
5 5
6 [Finished in 0.3s]

从上面的程序中可以看出，f._next_() 和 next(f) 是作用是一样的。

下面再来看看send() 方法的使用。

 1 def fib(times):
 2     n = 0
 3     a,b = 0,1
 4     while n < times:
 5         temp = yield b 
 6         print(temp)
 7         a,b = b,a+b
 8         n += 1
 9 f = fib(5)
10 print(f.__next__())
11 print(f.send("haha"))
12 print(f.send("wangji"))

输出结果为：

1 1
2 haha
3 1
4 wangji
5 2
6 [Finished in 0.3s]

从上面代码可以看出：使用send()时，必须在yield前面加上一个变量，并打印这个变量。在调用send()方法时其前面需要至少使用一次next()或__next__()方法，因为生成器不可以在使用之前导入任何非None参数。由此可以知道，send()是用来向生成器中导入参数并返回该参数的，与该参数一起返回的还有生成器中原先保存的数据。

4、再看生成器

前面已经对生成器有了感性的认识，我们以生成器函数为例，再来深入探讨一下python的生成器：

　　1、语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值。

　　2、自动实现迭代器协议：对于生成器，python会自动实现迭代器协议，以便应用到迭代北京中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常

　　3、状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，以便以后从它离开的地方继续执行

5、示例

我们再来看两个生成器的例子，以便大家更好的理解生成器的作用。

首先，生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。

大家可以在自己的电脑上试试下面两个表达式，并且观察内存占用情况。对于前一个表达式，我在自己的电脑上进行测试，还没有看到最终结果电脑就已经卡死，对于后一个表达式，几乎没有什么内存占用。

1 a=sum([i for i in range(1000000000)])
2 print(a)
3 
4 b=sum(i for i in range(1000000000))
5 print(b)

除了延迟计算，生成器还能有效提高代码可读性。例如，现在有一个需求，求一段文字中，每个单词出现的位置。

不使用生成器的情况：

1 def index_words(text):
2     result = []
3     if text:
4         result.append(0)
5     for index,letter in enumerate(text,1):
6         if letter == " ":
7             result.append(index)
8     return result

使用生成器的情况：

1 def index_word(text):
2     if text:
3         yield 0
4     for index,letter in enumerate(text,1):
5         if letter == " ":
6             yield index

这里，至少有两个充分的理由说明，使用生成器比不使用生成器代码更加清晰：

　　1、使用生成器以后，代码行数更少。大家要记住，如果想把代码写的Pythonic，在保证代码可读性的前提下，代码行数越少越好。

　　2、不使用生成器的时候，对于每次结果，我们首先看到的是result.append(index)，其次，才是index。也就是说，我们每次看到的是一个列表的append操作，只是append的是我们想要的结果。使用生成器的时候，直接yield  index，少了列表append操作的干扰，我们一眼就能够看出，代码是要返回Index。

这个例子充分说明了，合理使用生成器，能够有效提高代码可读性。只要大家完全接受了生成器的概念，理解了yield语句和return语句一样，也是返回一个值。那么，就能够理解为什么使用生成器比不使用生成器要好，能够理解使用生成器真的可以让代码变得清晰易懂。

6、使用生成器的注意事项

相信通过这篇文章，大家已经能够理解生成器的作用和好处了。但是，还没有结束，使用生成器，也有一点注意事项。

我们直接来看例子，假设文件中保存了省份的人口总数，现在，需要求每个省份的人口占全国总人口的比例。显然，我们需要先求出全国的总人口，然后在遍历每个省份的人口，用每个省的人口数除以总人口数，就得到了每个省份的人口占全国人口的比例。

如下所示：

 1 def get_province_population(filename):
 2     with open(filename) as f:
 3         for line in f:
 4             yield int(line)
 5 
 6 gen=get_province_population("data.txt")
 7 all_population = sum(gen)
 8 #print all_population
 9 for population in gen:
10     print(population/all population)

执行上面的这段代码将不会有任何输出，这是因为，生成器只能遍历一次。在我们执行sum语句的时候，就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不会有任何输出。

因此，生成器的唯一注意事项就是：生成器只能遍历一次。

7、总结

本文深入浅出地介绍了Python中，一个容易被大家忽略的重要特性，即Python的生成器。在实际工作中，充分利用Python生成器，不但能够减少内存使用，还能够提高代码可读性。掌握生成器也是Python高手的标配。希望本文能够帮助大家理解Python的生成器。

 

二、迭代器

迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历位置的对象。迭代器只能往前不能后退。

1、什么是可迭代对象（Iterable）

　　—  集合数据类型，如 list 、tuple、dict、set、str 等

　　—  生成器和带yield 的generator function

2、如何判断对象可迭代？

　　—  from collections import Iterable

　　—  isinstance([ ],Iterable)

　　　　　　　　　　　　　　图2-1　命令行窗口下的操作图

　　如上，命令行模式下，先导入Iterable模块，然后输入isinstance([ ],Iterable),括号中前面为待判断的对象，结果以布尔类型结束（True或False），列表是可迭代对象，因此返回True。注意：整数是不可迭代对象。

3、什么是迭代器呢？

迭代器是可以被next() 函数调用并不断返回下一个值的对象称为迭代器。因此生成器是迭代器的子类，但是注意集合类型的可迭代对象不是迭代器。

　　—  from collections import Iterator

　　—  isinstance((x for x in range(10)),Iterator)

　　这两行代码是用来判断是否为迭代器的，返回True或False。

iter()函数：将可迭代对象转换成迭代器。

　　　　　　　　　　　　　　　　图2-2　迭代器的判断

三、闭包

1、什么是闭包？

内部函数对外部函数作用域里变量的引用（非全局变量），则称内部函数为闭包。

闭包三要素：

　　　　　　1、嵌套函数　

　　　　　　2、变量的引用

　　　　　　3、返回内部函数

举例如下：

 1 #定义一个嵌套函数（要素1）
 2 def test(num):
 3     def test_in(num_in):
 4         #内部函数引用外部函数的变量(非全局变量)（要素2）
 5         print("sum = %s"%(num + num_in))
 6         #返回的结果可以被打印出来
 7         return num,num_in
 8     #返回内部的函数（要素3）
 9     return test_in
10 #这里的rtn就是test_in
11 rtn = test(10)
12 print(rtn)
13 #内部函数test_in传参
14 print(rtn(20))

输出结果为：

1 <function test.<locals>.test_in at 0x000000000220E378>
2 sum = 30
3 (10, 20)
4 [Finished in 0.3s]

定义闭包时，必须满足上面三个要素。

2、闭包的应用

1 #求一元一次方程的值，输入x，求y
2 def fun(a,b):     #其中a,b是固定的
3     def fun_in(x):
4         return a*x+b
5     return fun_in
6 f = fun(3,5)
7 print(f(1))    #每次输入不同的x值即可求出对应的y值
8 print(f(3))

输出结果为：

1 8
2 14
3 [Finished in 0.3s]

上面的函数中，利用闭包来求一元一次方程的值，更方便，直接输入x的值即可求出对应的y的值。因为这利用了闭包可以记住外部函数的参数的特性。

四、装饰器

1、什么是装饰器（decorator）？

装饰器其实就是一个闭包，把一个函数当作参数然后返回一个替代版函数。

装饰器有2个特性：
　　1、可以把被装饰的函数替换成其他函数

　　2、可以在加载模块时候立即执行

举例如下：

　　A、装饰器对无参数函数进行装饰：

 1 #装饰器本质就是一个闭包，
 2 #将函数当成参数传进去
 3 def deco(fun):
 4     def inner():
 5         print("你想进行的操作1")
 6         print("你想进行的操作2")
 7         fun()
 8     return inner
 9 #@deco是一个“语法糖”
10 @deco
11 def test():
12     print("test函数的操作")
13 #这个test已经被装饰了，不是原来的test
14 test()
15 #14行的test()等同于如下操作：
16 #rtn = deco(test)
17 #rtn()

输出结果为：

1 你想进行的操作1
2 你想进行的操作2
3 test函数的操作
4 [Finished in 0.3s]

2、装饰器的功能有：

　　　　　　　　1、引入日志

　　　　　　　　2、函数执行时间统计

　　　　　　　　3、执行函数前预备处理

　　　　　　　　4、执行函数后清理功能

　　　　　　　　5、权限z校验等场景

　　　　　　　　6、缓存

3、装饰器的分类

装饰器可分为对有无参数函数进行装饰的装饰器和对有无返回值函数进行装饰的装饰器，组合起来一共有4种。即：装饰器对无参数无返回值的函数进行装饰，装饰器对无参数有返回值的函数进行装饰，装饰器对有参数无返回值的函数进行装饰，装饰器对有参数有返回值的函数进行装饰。 

下面举一个装饰器实际应用的例子。

　　A、装饰器对无参数函数进行装饰

 1 #定义函数：完成包裹数据
 2 def makeBold(fn):
 3     def wrapped():
 4         return "<b>" + fn() + "</b>"
 5     return wrapped
 6 
 7 #定义函数：完成包裹数据
 8 def makeItalic(fn):
 9     def wrapped():
10         return "<i>" + fn() + "</i>"
11     return wrapped
12 
13 @makeBold
14 def test1():
15     return "hello world - 1"
16 
17 @makeItalic
18 def test2():
19     return "hello world - 2"
20 
21 @makeBold
22 @makeItalic
23 def test3():
24     return "hello world - 3"
25 
26 print(test1())
27 print(test2())
28 print(test3())

输出结果为：

1 <b>hello world - 1</b>
2 <i>hello world - 2</i>
3 <b><i>hello world - 3</i></b>
4 [Finished in 0.3s]

上面这个例子是做网页的时候对字体进行设置，对test1()进行加粗，对test2()斜体处理，对test3()先斜体在加粗。注意：对一个函数可以同时使用多个装饰器，装饰顺序由内而外。

　　B、装饰器对有参数函数进行装饰

 1 #定义一个装饰器
 2 def deco(func):
 3     def wrapper(a,b):    #内部函数的参数必须和被装饰的函数保持一致
 4         print("添加的功能")
 5         func(a,b)
 6 
 7     return wrapper
 8 
 9 @deco
10 #有参数的函数
11 def sum(a,b):
12     print(a+b)
13 
14 sum(10,20)

输出结果为：

1 添加的功能
2 30
3 [Finished in 0.3s]

当装饰器装饰有参数的函数时，装饰器内部的函数也必须带有和其相同的参数，因为被装饰的参数会被当成参数传进装饰器的内部函数中，如果两者的参数不一致，会报错。

C、装饰器对不定长参数函数进行装饰

 1 from time import ctime,sleep
 2 #定义一个装饰器，装饰不定长参数函数
 3 def deco(func):
 4     def wrapper(*args,**kwargs):
 5         print("%s called at the %s"%(func.__name__,ctime()))
 6         func(*args,**kwargs)
 7     return wrapper
 8 
 9 @deco
10 def test1(a,b,c):
11     print(a+b+c)
12 
13 @deco
14 def test2(a,b):
15     print(a+b)
16 
17 test1(10,20,30)
18 sleep(2)
19 test1(30,40,50)
20 
21 sleep(1)
22 test2(10,20)

输出结果为：

1 test1 called at the Fri Nov 10 19:08:03 2017
2 60
3 test1 called at the Fri Nov 10 19:08:05 2017
4 120
5 test2 called at the Fri Nov 10 19:08:06 2017
6 30
7 [Finished in 3.3s]

 D、装饰器对有返回值的函数进行装饰

 1 from time import ctime,sleep
 2 #定义一个装饰器，装饰不定长参数函数
 3 def deco(func):
 4     def wrapper(*args,**kwargs):
 5         print("%s called at the %s"%(func.__name__,ctime()))
 6         return func(*args,**kwargs)
 7     return wrapper
 8 #上面的装饰器是一个万能的装饰器，因为它可以装饰任意一种函数
 9 #包括有无参数函数和有无返回值函数
10 
11 @deco
12 def test():
13     return "---ha--ha---"
14 
15 t = test()
16 print(t)

输出结果为：

1 test called at the Fri Nov 10 19:19:20 2017
2 ---ha--ha---
3 [Finished in 0.3s]

上面的装饰器是一个万能的装饰器，因为其可以用来装饰任何函数，包括有无参数函数和有无返回值函数。