列表生成式,迭代器&生成器
列表生成式
列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],我要求你把列表里的每个值加1,你怎么实现?你可能会想到2种方式
普通青年版
>>> a [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> b = [] >>> for i in a:b.append(i+1) ... >>> b [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> a = b >>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
原值修改
a = [1,3,4,6,7,7,8,9,11] for index,i in enumerate(a): a[index] +=1 print(a)
文艺青年
>>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> a = map(lambda x:x+1, a) >>> a <map object at 0x101d2c630> >>> for i in a:print(i) ... 2 3 4 5 6 7 8 9 10 11
还有一种叫做列表生成式
>>> a = [i+1 for i in range(10)] >>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
生成器
通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。
要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]
改成()
,就创建了一个generator:
>>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x1022ef630>
建L
和g
的区别仅在于最外层的[]
和()
,L
是一个list,而g
是一个generator。
我们可以直接打印出list的每一个元素,但我们怎么打印出generator的每一个元素呢?
如果要一个一个打印出来,可以通过next()
函数获得generator的下一个返回值:
>>> next(g) 0 >>> next(g) 1 >>> next(g) 4 >>> next(g) 9 >>> next(g) 16 >>> next(g) 25 >>> next(g) 36 >>> next(g) 49 >>> next(g) 64 >>> next(g) 81 >>> next(g) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
我们讲过,generator保存的是算法,每次调用next(g)
,就计算出g
的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration
的错误。
当然,上面这种不断调用next(g)
实在是太变态了,正确的方法是使用for
循环,因为generator也是可迭代对象:
>>> g = (x * x for x in range(10)) >>> for n in g: ... print(n) ... 0 1 4 9 16 25 36 49 64 81
所以,我们创建了一个generator后,基本上永远不会调用next()
,而是通过for
循环来迭代它,并且不需要关心StopIteration
的错误。
generator非常强大。如果推算的算法比较复杂,用类似列表生成式的for
循环无法实现的时候,还可以用函数来实现。
比如,著名的斐波拉契数列(Fibonacci),除第一个和第二个数外,任意一个数都可由前两个数相加得到:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契数列用列表生成式写不出来,但是,用函数把它打印出来却很容易:
1
2
3
4
5
6
7
|
def fib( max ): n, a, b = 0 , 0 , 1 while n < max : print (b) a, b = b, a + b n = n + 1 return 'done' |
注意,赋值语句:
1
|
a, b = b, a + b |
相当于:
1
2
3
|
t = (b, a + b) # t是一个tuple a = t[ 0 ] b = t[ 1 ] |
但不必显式写出临时变量t就可以赋值。
上面的函数可以输出斐波那契数列的前N个数:
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> fib( 10 ) 1 1 2 3 5 8 13 21 34 55 done |
仔细观察,可以看出,fib
函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任意的元素,这种逻辑其实非常类似generator。
也就是说,上面的函数和generator仅一步之遥。要把fib
函数变成generator,只需要把print(b)
改为yield b
就可以了:
def fib(max): n,a,b = 0,0,1 while n < max: #print(b) yield b a,b = b,a+b n += 1 return 'done'
这就是定义generator的另一种方法。如果一个函数定义中包含yield
关键字,那么这个函数就不再是一个普通函数,而是一个generator:
>>> f = fib(6) >>> f <generator object fib at 0x104feaaa0>
这里,最难理解的就是generator和函数的执行流程不一样。函数是顺序执行,遇到return
语句或者最后一行函数语句就返回。而变成generator的函数,在每次调用next()
的时候执行,遇到yield
语句返回(会把yield后的内容输出后保存断点返回),再次执行时从上次返回的yield
语句处继续执行。
data = fib(10) print(data) print(data.__next__()) print(data.__next__()) print("干点别的事") print(data.__next__()) print(data.__next__()) print(data.__next__()) print(data.__next__()) print(data.__next__()) #输出 <generator object fib at 0x101be02b0> 1 1 干点别的事 2 3 5 8 13
在上面fib
的例子,我们在循环过程中不断调用yield
,就会不断中断。当然要给循环设置一个条件来退出循环,不然就会产生一个无限数列出来。
同样的,把函数改成generator后,我们基本上从来不会用next()
来获取下一个返回值,而是直接使用for
循环来迭代:
>>> for n in fib(6): ... print(n) ... 1 1 2 3 5 8
但是用for
循环调用generator时,发现拿不到generator的return
语句的返回值。如果想要拿到返回值,必须捕获StopIteration
错误,返回值包含在StopIteration
的value
中:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
>>> g = fib( 6 ) >>> while True : ... try : ... x = next (g) ... print ( 'g:' , x) ... except StopIteration as e: ... print ( 'Generator return value:' , e.value) ... break ... g: 1 g: 1 g: 2 g: 3 g: 5 g: 8 Generator return value: done |
PEP 342 添加了 .throw(...) 和 .close() 方法(前者的作用是让调用方抛出异常,在生成器中处理;后者的作用是终止生成器)
关于如何捕获错误,后面的错误处理还会详细讲解。
还可通过yield实现在单线程的情况下实现并发运算的效果
#_*_coding:utf-8_*_ __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")
关于yield的别的解析部分:
(1)yield后面可以加多个数值(可以是任意类型),但返回的值是元组类型的。
def get(): m = 0 n = 2 l = ['s',1,3] k = {1:1,2:2} p = ('2','s','t') while True: m += 1 yield m yield m ,n ,l ,k ,p it = get() print(next(it)) #1 print(next(it)) #(1, 2, ['s', 1, 3], {1: 1, 2: 2}, ('2', 's', 't')) print(next(it)) #2 print(type(next(it))) #<class 'tuple'>
如果再加一句:
print(type(next(it))) #<class 'int'> #返回的是整形
所以返回值的类型,应该是当前调用时,yield 返回值的类型。
(2)关于原函数的return部分return的东西变成了StopIteration异常的值。
在一个 generator function 中,如果没有 return,则默认执行至函数完毕,如果在执行过程中 return,则直接抛出 StopIteration 终止迭代。
def fib(max): #10 n, a, b = 0, 0, 1 while n < max: #n<10 #print(b) yield b a, b = b, a + b n = n + 1 return '---done---' #f= fib(10) g = fib(6) while True: try: x = next(g) print('g:', x) except StopIteration as e: print('Generator return value:', e.value) break g: 1 g: 1 g: 2 g: 3 g: 5 g: 8 Generator return value: ---done---
def gen(max): b = 123 a = 0 while a < max: a += 1 yield a return 'done' return 'done---' g = gen(5) print(next(g)) # 这里在yield断点那,还没执行return next(g) # 返回断点,执行return,抛出异常 1 # next()的返回值:yield后面跟的参数 Traceback (most recent call last): File "H:/python/workspace/day04/generator.py", line 17, in <module> next(g) StopIteration: done # 异常的值为return 后的值
(3)yield 可以还能够接受参数
send()和next()的区别就在于send可传递参数给yield表达式,这时候传递的参数就会作为yield表达式的值,所以也可以认为next()等同于send(None)。
send()和next()都有返回值,他们的返回值是当前迭代遇到的yield的时候,yield后面表达式的值,其实就是当前迭代yield后面的参数。
def f(maxx): n, a, b = 0, 1, 1 while n < maxx: # print(b) y = yield b a, b = b, a + b n += 1 print(y) return 'error_name' # 原函数的return变成了迭代完报出错误的值(value) fi = f(6) # 将一个函数变成生成器,并赋值给fi,每次迭代的值都是yield右边的值 print(fi.__next__()) # 运行一次生成器,到yield处中断,运行下面的程序 print(fi.send('Done')) # 回到第一次运行的生成器的yield中断处,并把Done赋予yield,然后执行下面的程序,到yield再次停止 fi.send('Done') # 如果这句换成print(fi.send('Done')),则会输出3 print(fi.send('Done')) # next和send的返回值都是fi迭代器本次的值 1 Done 2 Done Done 5
(4)调用一次next是从上次yield到下一次yield结束,并不一定是只走一遍生成器中的循环
def fun(num): i = 1 while i < num: if (i % 2): yield i i += 1 f = fun(15) print(next(f)) print(next(f)) # 每一次next不定只走一遍fun的循环,这里走了两次 print(f.__next__()) for i in f: # for循环迭代生成器同理 print(i) 1 3 5 7 9 11 13
迭代器
我们已经知道,可以直接作用于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
。
可以使用isinstance()
判断一个对象是否是Iterator
对象:
>>> from collections import Iterator >>> isinstance((x for x in range(10)), Iterator) True >>> isinstance([], Iterator) False >>> isinstance({}, Iterator) False >>> isinstance('abc', Iterator) False
生成器都是Iterator
对象,但list
、dict
、str
虽然是Iterable
,却不是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是永远不可能存储全体自然数的。
通过__iter__/__next__得到一些类(容器)中迭代器的理解
Python的迭代器协议需要 __iter__() 方法返回一个实现了 __next__() 方法的迭代器对象。 如果你只是迭代遍历其他容器的内容,你无须担心底层是怎样实现的。你所要做的只是传递迭代请求既可。
class squares: def __init__(self, start, stop): self.flag = start - 1 self.value = self.flag self.stop = stop def __iter__(self): self.value = self.flag return self # 返回一个实现了__next__()方法的迭代器对象 def __next__(self): if self.value == self.stop: raise StopIteration self.value += 1 return self.value a = squares(1,5) b = squares(1,5) s = 0 while s<=41: for i in a: # 这里会调用__iter__()然后返回得到一个迭代器对象,然后一直调用__next__()直到报StopIteration后,循环没有结束的话重新调用__iter__()返回迭代器对象,然后next s= s + i print(s) 1 3 6 10 15 # 16 18 21 25 30 # 31 33 36 40 45
到时迭代器停止工作,实现了三圈循环。
可以得出:
迭代器走完一轮,抛出异常后,再次调用会先进行__iter__(),再进行__next__()。
class Node: def __init__(self, value): self._value = value self._children = [] def __repr__(self): return 'Node({!r})'.format(self._value) def add_child(self, node): self._children.append(node) def __iter__(self): return iter(self._children) # Example if __name__ == '__main__': root = Node(0) child1 = Node(1) child2 = Node(2) root.add_child(child1) root.add_child(child2) # Outputs Node(1), Node(2) for ch in root: # root会先调用__iter__()然后得到了一个可迭代对象 print(ch)
迭代器要注意一点,迭代器只能单次循环
上图可见,for循环只能输出一次,第二次什么也不能输出,因为迭代器是一个单向的容器,走到尾部之后,不会自动再回到开始位置。
生成器不保留前面的数,只能next取下一个,所以遍历一遍完了就没了
关于range和xrange :
在python2中,有range和xrange之分,range是把数生成列表形式,xrange吧数生成迭代器形式,在python3中,只有range,py3中的range就是py2中的xrange,生成迭代器形式
小结
凡是可作用于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