阅读 350

Python迭代器和生成器详解

概述

在使用Python的过程中,经常会和列表/元组/字典(list/tuple/dict)、容器(container)、可迭代对象(iterable)、迭代器(iterator)、生成器(generator)等这些名词打交道,众多的概念掺杂到一起难免会让人一头雾水,这里我们用一张图来展现它们之间的关系。

image

今天我们主要讲解迭代器(iterator)和生成器(generator),在这之前我们先来看下容器(container)和可迭代对象(iterable)。

那么什么是容器呢?

容器是一种把多个元素组织在一起的数据结构,容器中的元素可以逐个迭代获取,可以用 in,not in 关键字判断元素是否包含在容器中。通常这类数据结构把所有的元素存储在内存中(也有一些特例,并不是所有的元素都放在内存,比如迭代器和生成器对象),我们常用的 string、set、list、tuple、dict 都属于容器对象。

# string
>>> 'h' in 'hello'
True
>>> 'z' in 'hello'
False
>>> 'z' not in 'hello'
True

# list
>>> 1 in [1, 2, 3]
True
>>> 5 in [1, 2, 3]
False
>>> 5 not in [1, 2, 3]
True

# set
>>> 1 in {1, 2, 3}
True
>>> 5 in {1, 2, 3}
False
>>> 5 not in {1, 2, 3}
True

# tuple
>>> 1 in (1, 2, 3)
True
>>> 5 in (1, 2, 3)
False
>>> 5 not in (1, 2, 3)
True

# dict
>>> 1 in {1:'one', 2:'two', 3:'three'}
True
>>> 5 in {1:'one', 2:'two', 3:'three'}
False
>>> 5 not in {1:'one', 2:'two', 3:'three'}
True
复制代码

尽管大多数容器都提供了某种方式获取其中的每一个元素,但这并不是容器本身提供的能力,而是可迭代对象赋予了容器这种能力,当然并不是所有容器都是可迭代的。

那什么是可迭代对象呢?

可以返回一个迭代器的对象都可以称之为可迭代对象,我们来看一个例子:

>>> x = [1, 2, 3]
>>> a = iter(x)
>>> b = iter(x)
>>> next(a)
1
>>> next(a)
2
>>> next(b)
1
>>> type(x)
<class 'list'>
>>> type(a)
<class 'list_iterator'>
>>> type(b)
<class 'list_iterator'>
复制代码

这里的 x 是一个可迭代对象,可迭代对象和容器一样是一种通俗的叫法,并不是指某种具体的数据类型,list 是可迭代对象,dict 也是可迭代对象。a 和 b 是两个独立的迭代器,迭代器内部有一个状态,该状态用于记录当前迭代所在的位置,以方便下次迭代时获取正确的元素。迭代器有一种具体的迭代器类型,比如 list_iteratorset_iterator。可迭代对象实现了 __iter__() 方法,该方法返回一个迭代器对象。

当运行代码:

x = [1, 2, 3]
for ele in x:
    ...
复制代码

实际执行情况是: image

在循环遍历自定义容器对象时,会使用python内置函数iter()调用遍历对象的__iter__()获得一个迭代器,之后再循环对这个迭代器使用next()调用迭代器对象的__next__()__iter__()只会被调用一次,而__next__()会被调用 n 次。

Iterator(迭代器)

迭代器是一个带状态的对象,它能在你调用next()方法时返回容器中的下一个值,任何实现了__iter__()__next__()(Python2.x中实现next())方法的对象都是迭代器,__iter__()返回迭代器自身,__next__()返回容器中的下一个值,如果容器中没有更多元素了,则抛出StopIteration异常。

迭代器与列表的区别在于,构建迭代器的时候,不像列表把所有元素一次性加载到内存,而是以一种延迟计算(lazy evaluation)方式返回元素,这正是它的优点。比如列表中含有一千万个整数,需要占超过100M的内存,而迭代器只需要几十个字节的空间。因为它并没有把所有元素装载到内存中,而是等到调用next()方法的时候才返回该元素(按需调用 call by need 的方式,本质上 for 循环就是不断地调用迭代器的next()方法)。

itertools模块里的函数返回的都是迭代器对象。为了更直观的感受迭代器内部的执行过程,我们自定义一个迭代器,以斐波那契数列为例:

#-*- coding:utf8 -*-
class Fib(object):
    def __init__(self, max=0):
        super(Fib, self).__init__()
        self.prev = 0
        self.curr = 1
        self.max = max
        
    def __iter__(self):
        return self

    def __next__(self):
        if self.max > 0:
            self.max -= 1
            # 当前要返回的元素的值
            value = self.curr
            # 下一个要返回的元素的值
            self.curr += self.prev
            # 设置下一个元素的上一个元素的值
            self.prev = value
            return value
        else:
            raise StopIteration
    
    # 兼容Python2.x
    def next(self):
        return self.__next__()

if __name__ == '__main__':
    fib = Fib(10)
    # 调用next()的过程
    for n in fib:
        print(n)
    # raise StopIteration
    print(next(fib))
复制代码

斐波那契数列指的是 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 ... 这样一个数列,这个数列从第三项开始,每一项都等于前两项之和。

Generator(生成器)

了解了迭代器之后,我们来看下生成器,普通函数用return返回一个值,还有一种函数用yield返回值,这种函数叫生成器函数。函数被调用时会返回一个生成器对象。生成器其实是一种特殊的迭代器,不过这种迭代器更加优雅,它不需要像普通迭代器一样实现__iter__()__next__()方法了,只需要一个yield关键字。生成器一定是迭代器(反之不成立),因此任何生成器也是一种懒加载的模式生成值。下面来用生成器来实现斐波那契数列的例子:

#-*- coding:utf8 -*-
def fib(max):
    prev, curr = 0, 1
    while max > 0:
        max -= 1
        yield curr
        prev, curr = curr, prev + curr
        
if __name__ == '__main__':
    fib = fib(6)
    # 调用next()的过程
    for n in fib:
        print(n)
    # raise StopIteration
    print(next(fib))
复制代码

上面是生成器函数,再来看下生成器的表达式,生成器表达式是列表推导式的生成器版本,看起来像列表推导式,但是它返回的是一个生成器对象而不是列表对象。

>>> x = (x*x for x in range(10))
>>> type(x)
<class 'generator'>
>>> y = [x*x for x in range(10)]
>>> type(y)
<class 'list'>
复制代码

我们再看看一个例子:

#-*- coding:utf8 -*-
import time

def func(n):
    for i in range(0, n):
        # yield相当于return,下一次循环从yield的下一行开始
        arg = yield i
        print('func', arg)

if __name__ == '__main__':
    f = func(6)
    while True:
        print('main-next:', next(f))
        print('main-send:', f.send(100))
        time.sleep(1)
复制代码

运行结果为:

main-next: 0
func 100
main-send: 1
func None
main-next: 2
func 100
main-send: 3
func None
main-next: 4
func 100
main-send: 5
func None
Traceback (most recent call last):
  File "demo.py", line 13, in <module>
    print('main-next:', next(f))
StopIteration
复制代码

yield就是return返回一个值,并且记住这个返回的位置,下次迭代就从这个位置后(下一行)开始。next方法和send方法都可以返回下一个元素,区别在于send可以传递参数给yield表达式,这时传递的参数会作为yield表达式的值,而yield的参数是返回给调用者的值。

总结

  1. 可迭代对象(Iterable)是实现了__iter__()方法的对象,通过调用iter()方法可以获得一个迭代器(Iterator)。
  2. 迭代器(Iterator)是实现了__iter__()方法和__next()__方法的对象。
  3. for...in...的迭代实际是将可迭代对象转换成迭代器,再重复调用next()方法实现的。
  4. 生成器(Generator)是一个特殊的迭代器,它的实现更简单优雅。
  5. yield是生成器实现__next__()方法的关键。它作为生成器执行的暂停恢复点,可以对yield表达式进行赋值,也可以将yield表达式的值返回。
文章分类
后端
文章标签