脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - python迭代器与生成器详解

python迭代器与生成器详解

2020-08-15 15:31shomy Python

迭代器和生成器都是Python中特有的概念，迭代器可以看作是一个特殊的对象，每次调用该对象时会返回自身的下一个元素，从实现上来看，一个可迭代的对象必须是定义了__iter__()方法的对象，而一个迭代器必须是定义了__iter__()方法

例子

老规矩，先上一个代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
def add(s, x):
 return s + x
 
def gen():
 for i in range(4):
  yield i
 
base = gen()
for n in [1, 10]:
 base = (add(i, n) for i in base)
 
print list(base)

这个东西输出可以脑补一下， 结果是[20,21,22,23], 而不是[10, 11, 12, 13]。 当时纠结了半天，一直没搞懂，后来齐老师稍微指点了一下， 突然想明白了--真够笨的，唉。。好了--正好趁机会稍微小结一下python里面的生成器。

迭代器(iterator)

要说生成器，必须首先说迭代器
区分iterable,iterator与itertion
讲到迭代器，就需要区别几个概念:iterable,iterator,itertion, 看着都差不多，其实不然。下面区分一下。

itertion: 就是迭代,一个接一个(one after another),是一个通用的概念，比如一个循环遍历某个数组。
iterable: 这个是可迭代对象,属于python的名词，范围也很广，可重复迭代，满足如下其中之一的都是iterable:
可以for循环: for i in iterable
可以按index索引的对象，也就是定义了__getitem__方法，比如list,str;
定义了__iter__方法。可以随意返回。
可以调用iter(obj)的对象，并且返回一个iterator
iterator: 迭代器对象,也属于python的名词，只能迭代一次。需要满足如下的迭代器协议
定义了__iter__方法，但是必须返回自身
定义了next方法,在python3.x是__next__。用来返回下一个值，并且当没有数据了，抛出StopIteration
可以保持当前的状态
首先str和list是iterable 但不是iterator:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
In [3]: s = 'hi'
 
In [4]: s.__getitem__
Out[4]: <method-wrapper '__getitem__' of str object at 0x7f9457eed580>
 
In [5]: s.next # 没有next方法
---------------------------------------------------------------------------
AttributeError       Traceback (most recent call last)
<ipython-input-5-136d3c11be25> in <module>()
----> 1 s.next
 
AttributeError: 'str' object has no attribute 'next'
 
In [6]: l = [1,2] # 同理
 
In [7]: l.__iter__
Out[7]: <method-wrapper '__iter__' of list object at 0x7f945328c320>
 
In [8]: l.next
---------------------------------------------------------------------------
AttributeError       Traceback (most recent call last)
<ipython-input-8-c6f8fb94c4cd> in <module>()
----> 1 l.next
 
AttributeError: 'list' object has no attribute 'next'
In [9]: iter(s) is s #iter() 没有返回本身
Out[9]: False
In [10]: iter(l) is l #同理
Out[10]: False

但是对于iterator则不一样如下, 另外iterable可以支持多次迭代，而iterator在多次next之后，再次调用就会抛异常,只可以迭代一次。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
In [13]: si = iter(s)
 
In [14]: si
Out[14]: <iterator at 0x7f9453279dd0>
 
In [15]: si.__iter__ # 有__iter__
Out[15]: <method-wrapper '__iter__' of iterator object at 0x7f9453279dd0>
 
In [16]: si.next #拥有next
Out[16]: <method-wrapper 'next' of iterator object at 0x7f9453279dd0>
 
In [20]: si.__iter__() is si #__iter__返回自己
Out[20]: True

这样，由这几个例子可以解释清楚这几个概念的区别。

自定义iterator 与数据分离

说到这里，迭代器对象基本出来了。下面大致说一下，如何让自定义的类的对象成为迭代器对象，其实就是定义__iter__和next方法:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
In [1]: %paste
class DataIter(object):
 
 def __init__(self, *args):
  self.data = list(args)
  self.ind = 0
 
 def __iter__(self): #返回自身
  return self
 
 def next(self): #　返回数据
  if self.ind == len(self.data):
   raise StopIteration
  else:
   data = self.data[self.ind]
   self.ind += 1
   return data
## -- End pasted text --
 
In [9]: d = DataIter(1,2)
 
In [10]: for x in d: #　开始迭代
 ....:  print x
 ....:
1
2
 
In [13]: d.next() #　只能迭代一次,再次使用则会抛异常
---------------------------------------------------------------------------
StopIteration        Traceback (most recent call last)
----> 1 d.next()
<ipython-input-1-c44abc1904d8> in next(self)
  10  def next(self):
  11   if self.ind == len(self.data):
---> 12    raise StopIteration
  13   else:
  14    data = self.data[self.ind]

从next函数中只能向前取数据,一次取一个可以看出来，不过不能重复取数据，那这个可不可以解决呢？

我们知道iterator只能迭代一次，但是iterable对象则没有这个限制，因此我们可以把iterator从数据中分离出来，分别定义一个iterable与iterator如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Data(object): # 只是iterable:可迭代对象而不iterator:迭代器
 
 def __init__(self, *args):
  self.data = list(args)
 
 def __iter__(self): # 并没有返回自身
  return DataIterator(self)
 
 
class DataIterator(object): # iterator: 迭代器
 
 def __init__(self, data):
  self.data = data.data
  self.ind = 0
 
 def __iter__(self):
  return self
 
 def next(self):
  if self.ind == len(self.data):
   raise StopIteration
  else:
   data = self.data[self.ind]
   self.ind += 1
   return data
 
if __name__ == '__main__':
 d = Data(1, 2, 3)
 for x in d:
  print x,
 for x in d:
  print x,

输出就是：

1,2,3
1,2,3
可以看出来数据可以复用，因为每次都返回一个DataIterator，但是数据却可以这样使用，这种实现方式很常见，比如xrange的实现便是这种数据与迭代分离的形式，但是很节省内存，如下：

?
1
2
3
4
5
In [8]: sys.getsizeof(range(1000000))
Out[8]: 8000072
 
In [9]: sys.getsizeof(xrange(1000000))
Out[9]: 40

另外有个小tips， 就是为什么可以使用for 迭代迭代器对象，原因就是for替我们做了next的活，以及接收StopIteration的处理。

迭代器大概就记录到这里了，下面开始一个特殊的更加优雅的迭代器: 生成器

生成器(generator)

首先需要明确的就是生成器也是iterator迭代器，因为它遵循了迭代器协议.

两种创建方式

包含yield的函数

生成器函数跟普通函数只有一点不一样，就是把 return 换成yield,其中yield是一个语法糖，内部实现了迭代器协议，同时保持状态可以挂起。如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def gen():
 print 'begin: generator'
 i = 0
 while True:
  print 'before return ', i
  yield i
  i += 1
  print 'after return ', i
 
a = gen()
 
In [10]: a #只是返回一个对象
Out[10]: <generator object gen at 0x7f40c33adfa0>
 
In [11]: a.next() #开始执行
begin: generator
before return 0
Out[11]: 0
 
In [12]: a.next()
after return 1
before return 1
Out[12]: 1

首先看到while True 不必惊慌，它只会一个一个的执行～
看结果可以看出一点东西:

调用gen()并没有真实执行函数，而是只是返回了一个生成器对象
执行第一次a.next()时，才真正执行函数，执行到yield一个返回值，然后就会挂起，保持当前的名字空间等状态。然后等待下一次的调用,从yield的下一行继续执行。
还有一种情况也会执行生成器函数，就是当检索生成器的元素时，如list(generator), 说白了就是当需要数据的时候，才会执行。

?
1
2
3
4
5
6
7
8
9
10
In [15]: def func():
 ....:  print 'begin'
 ....:  for i in range(4):
 ....:   yield i
 
In [16]: a = func()
 
In [17]: list(a) #检索数据，开始执行
begin
Out[17]: [0, 1, 2, 3]

yield还有其他高级应用，后面再慢慢学习。

生成器表达式

列表生成器十分方便：如下,求10以内的奇数:
[i  for i in range(10) if i % 2]

同样在python 2.4也引入了生成器表达式，而且形式非常类似，就是把[]换成了().

?
1
2
3
4
5
6
7
In [18]: a = ( i for i in range(4))
 
In [19]: a
Out[19]: <generator object <genexpr> at 0x7f40c2cfe410>
 
In [20]: a.next()
Out[20]: 0

可以看出生成器表达式创建了一个生成器，而且生有个特点就是惰性计算, 只有在被检索时候，才会被赋值。
之前有篇文章:python 默认参数问题及一个应用,最后有一个例子:

?
1
2
3
def multipliers():
 return (lambda x : i * x for i in range(4)) #修改成生成器
print [m(2) for m in multipliers()]

这个就是说，只有在执行m(2)的时候，生成器表达式里面的for才会开始从0循环，然后接着才是i * x,因此不存在那篇文章中的问题。

惰性计算这个特点很有用，上述就是一个应用，2gua这样说的:

性计算想像成水龙头，需要的时候打开，接完水了关掉，这时候数据流就暂停了，再需要的时候再打开水龙头，这时候数据仍是接着输出，不需要从头开始循环
其实本质跟迭代器差不多,不一次性把数据都那过来，需要的时候，才拿。

回到例子

看到这里，开始的例子应该大概可以有点清晰了，核心语句就是:

?
1
2
for n in [1, 10]:
 base = (add(i, n) for i in base)

在执行list(base)的时候，开始检索，然后生成器开始运算了。关键是，这个循环次数是2,也就是说，有两次生成器表达式的过程。必须牢牢把握住这一点。

生成器返回去开始运算，n = 10而不是1没问题吧，这个在上面提到的文章中已经提到了，就是add(i, n)绑定的是n这个变量，而不是它当时的数值。

然后首先是第一次生成器表达式的执行过程:base = (10 + 0, 10 + 1, 10 + 2, 10 +3),这是第一次循环的结果(形象表示，其实已经计算出来了(10,11,12,3))，然后第二次，base = (10 + 10, 11 + 10, 12 + 10, 13 + 10) ,终于得到结果了[20, 21, 22, 23].

具体执行过程可以在pythontutor上手动看看执行过程。

小结

概括
主要介绍了大概这样几点：

1.iterable,iterator与itertion的概念
2.迭代器协议
     自定义可迭代对象与迭代器分离，保证数据复用
3.生成器: 特殊的迭代器,内部实现了迭代器协议

其实这一块， 那几个概念搞清楚， ,这个很关键， 搞懂了后面就水到渠成了。而且对之前的知识也有很多加深。
比如常见list就是iterator与iteable分离实现的,本身是可迭代对象，但不是迭代器， 类似与xrange,但是又不同。
越来越明白，看源码的重要性了。 有地方写的不合适的， 请指正。

参考

http://www.shutupandship.com/2012/01/understanding-python-iterables-and.html
http://www.learningpython.com/2009/02/23/iterators-iterables-and-generators-oh-my/
http://stackoverflow.com/questions/9884132/what-exactly-are-pythons-iterator-iterable-and-iteration-protocols
http://python.jobbole.com/81881/

  • Python
  • 生成器
  • 迭代器

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 办公工具 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图