python生成器和装饰器_Python学习生成器迭代器与装饰器

目录

一. 列表生成式

现在有个列表 a &＃61; [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] , 我想将列表的每个元素都加1, 如何做?

1 a &＃61; [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]2 b &＃61;[]3 for i ina:4 b.append(i&＃43;1)5 a &＃61; b

入门级别

入门级别的方法, 达到了效果, 但有个弊端, 如果我一个列表非常大, 那么使用这种方法在处理过程中我需要双倍的内存来存储数据.

1 a &＃61; [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]2

3 for i inrange(len(a)):4 a[i] &＃43;&＃61; 1

5

6 #或者使用 内置函数enumerate

7 for i, v inenumerate(a):8 a[i] &＃43;&＃61; 1

小成级别

小成级别的方法, 比起入门级别的好处在于他是原值修改, 不用增加内存的存储空间. 那还有什么别的办法么? 有人可能会说用内置函数map&＃43;lambda提高一下逼格.

1 a &＃61; [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]2 print(list(map(lambda x:x&＃43;1, a)))

大成级别

大成级别的方法, 看起来高大上很多. 但其实还有一种办法, 比它还要高逼格. 那就是列表生成式.

1 a &＃61; [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]2 b &＃61; [x &＃43; 1 for x in a]

羽化级别

它将 for 循环的每个元素赋值给前面定义的变量, 最终生成结果添加到列表中.

for循环后面还可以加上if判断, 这样我们就可以筛选出仅偶数的平方:

1 l &＃61; [x * x for x in range(1, 11) if x % 2 &＃61;&＃61;0]2 print(l)3 #执行结果

4 [4, 16, 36, 64, 100]

注: 不支持else子句

还可以使用两层循环, 可以生成全排列:

1 print([m &＃43; n for m in &＃39;ABC&＃39; for n in &＃39;XYZ&＃39;])2 #执行结果

3 [&＃39;AX&＃39;, &＃39;AY&＃39;, &＃39;AZ&＃39;, &＃39;BX&＃39;, &＃39;BY&＃39;, &＃39;BZ&＃39;, &＃39;CX&＃39;, &＃39;CY&＃39;, &＃39;CZ&＃39;]

三层和三层以上的循环就很少用到了。

运用列表生成式&＃xff0c;可以写出非常简洁的代码。例如&＃xff0c;列出当前目录下的所有文件和目录名&＃xff0c;可以通过一行代码实现&＃xff1a;

1 importos2 files &＃61; [d for d in os.listdir(&＃39;.&＃39;)] #os.listdir可以列出文件和目录

3 #执行结果

4 [&＃39;.emacs.d&＃39;, &＃39;.ssh&＃39;, &＃39;.Trash&＃39;, &＃39;Adlm&＃39;, &＃39;Applications&＃39;, &＃39;Desktop&＃39;, &＃39;Documents&＃39;, &＃39;Downloads&＃39;, &＃39;Library&＃39;, &＃39;Movies&＃39;, &＃39;Music&＃39;, &＃39;Pictures&＃39;, &＃39;Public&＃39;, &＃39;VirtualBox VMs&＃39;, &＃39;Workspace&＃39;, &＃39;XCode&＃39;]

for循环其实可以同时使用两个甚至多个变量&＃xff0c;比如dict的iteritems()可以同时迭代key和value&＃xff1a;

1 d &＃61; {&＃39;x&＃39;: &＃39;A&＃39;, &＃39;y&＃39;: &＃39;B&＃39;, &＃39;z&＃39;: &＃39;C&＃39;}2 print([k &＃43; &＃39;&＃61;&＃39; &＃43; v for k, v ind.iteritems()])3 #执行结果

4 [&＃39;y&＃61;B&＃39;, &＃39;x&＃61;A&＃39;, &＃39;z&＃61;C&＃39;]

现在有一个列表 L &＃61; [&＃39;Hello&＃39;, &＃39;World&＃39;, 18, &＃39;Apple&＃39;, None] , 需要把列表中字符串改成全部为小写字母,  str.lower() 方法可以将字符串变成小写.

你会发现, L 列表中除了str类型还存在int和None两种类型, 要知道int与None是没有 lower() 方法的. 思考一下应该如何才能写出来呢.

1 L &＃61; [&＃39;Hello&＃39;, &＃39;World&＃39;, 18, &＃39;Apple&＃39;, None]2 L &＃61; [s.lower() if isinstance(s, str) else s for s in L] #isinstance(s, str) 判断 s 是否为 str 类型, 是则返回 True , 反之返回 False

3 print(L)4 #执行结果

5 [&＃39;hello&＃39;, &＃39;world&＃39;, 18, &＃39;apple&＃39;, None]

三元运算

二. 生成器

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

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

要创建一个generator, 有很多种方法. 第一种方法很简单, 只要把一个列表生成式的[]改成(), 就创建了一个generator:

1 L &＃61; [x * x for x in range(10)]2 g &＃61; (x * x for x in range(10))3 print(L)4 print(g)5 #执行结果

6 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]7 at 0x104feab40>

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

我们可以直接打印出 list 的每一个元素, 但我们怎么打印出 generator 的每一个元素呢?

如果要一个一个打印出来, 可以通过 generator 的 next() 方法:

1 g &＃61; (x for x in range(3))2 print(next(g))3 print(next(g))4 print(next(g))5 print(next(g))6 #执行结果

7 08 1

9 2

10 Traceback (most recent call last):11 File "E:/OldPython16/blog/列表生成式.py", line 12, in

12 print(next(g))13 StopIteration

我们讲过, generator 保存的是算法, 每次调用 next() , 就计算出下一个元素的值, 直到计算到最后一个元素, 没有更多的元素时, 抛出 StopIteration 的错误.

当然, 上面这种不断调用 next() 方法实在是太变态了, 正确的方法是使用 for 循环, 因为 generator 也是可迭代对象:

1 g &＃61; (x * x for x in range(10))2 for n ing:3 printn4 #执行结果

5 06 1

7 4

8 9

9 16

10 25

11 36

12 49

13 64

14 81

所以, 我们创建了一个 generator 后, 基本上永远不会调用 next() 方法, 而是通过 for 循环来迭代它.

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

比如, 著名的斐波拉契数列(Fibonacci), 除第一个和第二个数外, 任意一个数都可由前两个数相加得到:

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

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

1 deffib(max):2 n, a, b &＃61; 0, 0, 1

3 while n <4 printb5 a b&＃61;"b," n&＃61;"n">

7 fib(6)8 #执行结果

9 1

10 1

11 2

12 3

13 5

14 8

仔细观察, 可以看出, fib函数实际上是定义了斐波拉契数列的推算规则, 可以从第一个元素开始, 推算出后续任意的元素, 这种逻辑其实非常类似 generator .

也就是说, 上面的函数和 generator 仅一步之遥. 要把fib函数变成 generator , 只需要把 print b 改为 yield b 就可以了.

这就是定义 generator 的另一种方法. 如果一个函数定义中包含 yield 关键字, 那么这个函数就不再是一个普通函数, 而是一个 generator :

1 deffib(max):2 n, a, b &＃61; 0, 0, 1

3 while n <4 yieldb5 a b&＃61;"b," n&＃61;"n">

7 print(fib(6))8 #执行结果

9

这里, 最难理解的就是 generator 和函数的执行流程不一样. 函数是顺序执行, 遇到return语句或者最后一行函数语句就返回. 而变成 generator 的函数, 在每次调用next()的时候执行, 遇到yield语句返回, 再次执行时从上次返回的yield语句处继续执行.

举个简单的例子, 定义一个 generator , 依次返回数字1, 3, 5:

1 defodd():2 print(&＃39;step 1&＃39;)3 yield 1

4 print(&＃39;step 2&＃39;)5 yield 3

6 print(&＃39;step 3&＃39;)7 yield 5

8

9 o &＃61;odd()10 print(next(o))11 print(next(o))12 print(next(o))13 print(next(o))14 #执行结果

15 step 1

16 1

17 step 2

18 3

19 step 3

20 5

21 Traceback (most recent call last):22 File "E:/OldPython16/blog/列表生成式.py", line 20, in

23 print(next(o))24 StopIteration

可以看到, odd不是普通函数, 而是 generator , 在执行过程中, 遇到 yield 就中断, 下次又继续执行. 执行3次 yield 后, 已经没有 yield 可以执行了, 所以, 第4次调用next()就报错.

回到fib的例子, 我们在循环过程中不断调用yield, 就会不断中断. 当然要给循环设置一个条件来退出循环, 不然就会产生一个无限数列出来.

同样的, 把函数改成 generator 后, 我们基本上从来不会用next()来调用它, 而是直接使用for循环来迭代

小结:

generator 是非常强大的工具, 在Python中, 可以简单地把列表生成式改成 generator , 也可以通过函数实现复杂逻辑的 generator .

要理解 generator 的工作原理, 它是在for循环的过程中不断计算出下一个元素, 并在适当的条件结束for循环. 对于函数改成的 generator 来说, 遇到return语句或者执行到函数体最后一行语句, 就是结束 generator 的指令, for循环随之结束.

三. 迭代器

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

一类是集合数据类型, 如list, tuple, dict, set, str等

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

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

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

1 >>> from collections importIterable2 >>>isinstance([], Iterable)3 True4 >>>isinstance({}, Iterable)5 True6 >>> isinstance(&＃39;abc&＃39;, Iterable)7 True8 >>> isinstance((x for x in range(10)), Iterable)9 True10 >>> isinstance(100, Iterable)11 False

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

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

可以使用isinstance()判断一个对象是否是Iterator对象:

1 >>> from collections importIterator2 >>> isinstance((x for x in range(10)), Iterator)3 True4 >>>isinstance([], Iterator)5 False6 >>>isinstance({}, Iterator)7 False8 >>> isinstance(&＃39;abc&＃39;, Iterator)9 False

生成器都是Iterator对象, 但list, dict, str虽然是Iterable, 却不是Iterator.

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

1 >>>isinstance(iter([]), Iterator)2 True3 >>> isinstance(iter(&＃39;abc&＃39;), Iterator)4 True

你可能会问, 为什么list, dict, str等数据类型不是Iterator?

这是因为Python的Iterator对象表示的是一个数据流, Iterator对象可以被next()函数调用并不断返回下一个数据, 直到没有数据时抛出StopIteration错误. 可以把这个数据流看做

是一个有序序列, 但我们却不能提前知道序列的长度, 只能不断通过next()函数实现按需计算下一个数据, 所以Iterator的计算是惰性的, 只有在需要返回下一个数据时它才会计算.

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

小结

凡是可作用于for循环的对象都是Iterable类型&＃xff1b;

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

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

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

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

3 #实际上完全等价于:

4

5 #首先获得Iterator对象:

6 it &＃61; iter([1, 2, 3, 4, 5])7

8 #循环:

9 whileTrue:10 try:11 #获得下一个值:

12 x &＃61;next(it)13 exceptStopIteration:14 #遇到StopIteration就退出循环

15 break

四. 无参装饰器

现在有个foo函数, 并没有什么实际作用, 只是打印了一句无聊的自我介绍.

1 deffoo():2 print("I am foo()")3

4 foo()5

6 #I am foo()

我想给 foo 这个函数增加一个功能, 来计算这个函数的运行时间. 我可以这样来做:

1 importtime2 deffoo():3 start_time &＃61;time.time()4 print("I am foo()")5 stop_time &＃61;time.time()6 print("Func yun time is: %s" % (stop_time -start_time))7

8 foo()9

10 #I am foo()

11 #Func yun time is: 0.0

嗯, 不错, 实现了需求. 打印出了函数的运行时间. 但我现在除了 foo 函数意外还有成百上千个类似的函数也要添加打印运行时间的功能.

还记得吗, 函数在Python中是一等公民, 那么我们可以考虑重新定义一个函数 runtime, 将foo的引用传递给他, 然后在 runtime 中调用 foo 并进行计时, 这样, 我们就达到了不改动 foo 定义的目的, 而且, 多少个函数, 我们都不用去修改函数内部代码了!

1 importtime2 defruntime(func):3 start_time &＃61;time.time()4 func()5 stop_time &＃61;time.time()6 print("Func yun time is: %s" % (stop_time -start_time))7

8 deffoo():9 print("I am foo()")10

11 runtime(foo)12

13 #I am foo()

14 #Func yun time is: 0.0

嗯不错, 这样有多少个函数都不用修改函数定义就能添加计算时间的功能到函数中了.

等等, 不对啊, 函数的定义确实没改, 但我的调用方式却从 foo() 改成了 runtime(foo)

这可麻烦了, 我根本不知道谁在哪里调用过我的函数, 这可怎么办呢.

既然如此, 我们就来想想办法不修改调用的代码; 如果不修改调用代码, 也就意味着调用foo()需要产生调用runtime(foo)的效果.

我们可以想到将runtime赋值给foo, 但是runtime似乎带有一个参数, 想办法把参数统一吧!

如果runtime(foo)不是直接产生调用效果, 而是返回一个与foo参数列表一致的函数的话, 就很好办了,

将runtime(foo)的返回值赋值给foo, 然后, 调用foo()的代码完全不用修改!

1 importtime2

3 #定义一个计时器, 传入一个函数, 并返回另一个附加了计时功能的函数

4 defruntime(func):5

6 #定义一个内嵌的包装函数, 给传入的函数加上计时功能的功能

7 defwrapper():8 start_time &＃61;time.time()9 func()10 stop_time &＃61;time.clock()11 print("Func yun time is: %s" % (stop_time -start_time))12

13 #将包装后的函数返回

14 returnwrapper15

16 deffoo():17 print("I am foo()")18

19 foo &＃61;runtime(foo)20

21 foo()22

23 #I am foo()

24 #Func yun time is: 0.0

这样, 一个简易的计时器就做好了&＃xff01;我们只需要在定义foo以后调用foo之前, 加上foo &＃61; timeit(foo), 就可以达到计时的目的, 这也就是装饰器的概念, 看起来像是foo被timeit装饰了. 在在这个例子中, 函数进入和退出时需要计时, 这被称为一个横切面(Aspect), 这种编程方式被称为面向切面的编程(Aspect-Oriented Programming). 与传统编程习惯的从上往下执行方式相比较而言, 像是在函数执行的流程中横向地插入了一段逻辑. 在特定的业务领域里, 能减少大量重复代码. 面向切面编程还有相当多的术语, 这里就不多做介绍, 感兴趣的话可以去找找相关的资料.

这个例子仅用于演示, 并没有考虑foo带有参数和有返回值的情况, 现在我们模拟一下带有参数和返回值的foo函数

1 importtime2

3 #定义一个计时器, 传入一个函数, 并返回另一个附加了计时功能的函数

4 defruntime(func):5

6 #定义一个内嵌的包装函数, 给传入的函数加上计时功能的功能

7 def wrapper(*args, **kwargs): #在这里接收foo()的参数, 这里写成不定长变参是为了让装饰器可以在任何数量的参数下都能正常工作

8 start_time &＃61;time.time()9 res &＃61; func(*args, **kwargs) #获取foo()函数的返回值

10 stop_time &＃61;time.clock()11 print("Func yun time is: %s" % (stop_time -start_time))12 return res #在内嵌函数将结果返回

13

14 #将包装后的函数返回

15 returnwrapper16

17 def foo(x, y, z): #为foo定义了三个参数

18 print("I am foo()")19 return x &＃43; y &＃43; z #并返回三个参数之和

20

21 foo &＃61;runtime(foo)22

23 res &＃61; foo(1, 5, 10)24 print(res)25

26 #I am foo()

27 #Func yun time is: 0.0

28 #16

嗯, 不错这下我们带有参数与返回值的函数也可以使用runtime函数来添加计时功能了.

唯一有点郁闷的是每次调用foo()函数之前, 需要运行foo &＃61; runtime(foo)这段代码,

其实, 在 python 在2.7版本后 添加了语法糖"&＃64;" 就是为了解决这个问题. 我们可以通过语法糖来代替foo &＃61; runtime(foo)

1 importtime2

3 #定义一个计时器, 传入一个函数, 并返回另一个附加了计时功能的函数

4 defruntime(func):5

6 #定义一个内嵌的包装函数, 给传入的函数加上计时功能的功能

7 def wrapper(*args, **kwargs): #在这里接收foo()的参数, 这里写成不定长变参是为了让装饰器可以在任何数量的参数下都能正常工作

8 start_time &＃61;time.time()9 res &＃61; func(*args, **kwargs) #获取foo()函数的返回值

10 stop_time &＃61;time.clock()11 print("Func yun time is: %s" % (stop_time -start_time))12 return res #在内嵌函数将结果返回

13

14 #将包装后的函数返回

15 returnwrapper16

17 &＃64;runtime18 def foo(x, y, z): #为foo定义了三个参数

19 print("I am foo()")20 return x &＃43; y &＃43; z #并返回三个参数之和

21

22 res &＃61; foo(1, 5, 10)23 print(res)24

25 #I am foo()

26 #Func yun time is: 0.0

27 #16

五. 有参装饰器

上面说完了无参装饰器, 这回我们来说一下有参装饰器.

现在有这样一个需求, 一个网站, 要访问主页的时候要先判断这个用户是否登录, 如果登录了才能访问, 否则 直接访问登录页面

1 #标识当前用户是否登录.

2 user_login_status &＃61;False3

4 #登录页面

5 deflogin():6 print("登录页")7

8 #检查登录的装饰器

9 deflogin_check(func):10 def inner(*args, **kwargs):11 ifuser_login_status:12 return func(*args, **kwargs)13 else:14 return login(*args, **kwargs)15 returninner16

17 #主页

18 &＃64;login_check19 defindex():20 print("这是主页")21

22 index()23 #当 user_login_status 为 False 时, 打印 登录页

24 #当 user_login_status 为 True 时, 打印 这是主页

嗯, 通过装饰器很容易就完成了这个需求.

新需求又来了. 只有通过微信登录的用户才可以访问主页. 代码如下:

1 #标识当前用户是否登录与登录类型

2 user_login_status &＃61;True3 user_login_type &＃61; "qq"

4

5 #登录页面

6 deflogin():7 print("登录页")8

9 #检查登录的装饰器

10 def login_check(login_type): #为装饰器函数加一次嵌套, 接受登录类型, 用于内部进行判断使用

11 defauth(func):12 def inner(*args, **kwargs):13 #这里如果用户登录了, 并且登录类型等于指定的登录类型才会执行被装饰的函数, 否则返回登录页面

14 if user_login_status and user_login_type &＃61;&＃61;login_type:15 return func(*args, **kwargs)16 else:17 return login(*args, **kwargs)18 returninner19 return auth #最外层函数, 直接返回auth的内存地址.

20

21 #主页

22 &＃64;login_check("qq")23 defindex():24 print("这是主页")25

26 index()27 #当 user_login_status 为 True 并且 user_login_type &＃61; "qq" 的时候 打印 "这是主页"

28 #其他情况下打印 "登录页"

这就是有参装饰器, 我们可以把 22行  &＃64;login_check("qq") 拆分成 &＃64; 与 login_check("qq") 来理解.

在运行代码的时候, 解释器会先执行 login_check("qq") , 它的返回值是 auth 函数的内存地址, 再把这个结果和前面的 &＃64; 结合起来, 结果是 &＃64;auth

所以  &＃64;login_check("qq") 等价于 &＃64;auth , 但区别在于, 现在的装饰器中被带入了一个 login_type 的参数, 可供装饰器中使用.

装饰器带类参数, 参考地址: http://blog.csdn.net/dreamcoding/article/details/8611578