时间戳

首页 > 技术文章 > 11. 迭代器与生成器

11. 迭代器与生成器

superpoint 2021-07-20 00:35 原文

迭代器、可迭代对象与生成器

​ 迭代器即用来迭代取值的工具，而迭代是重复反馈过程的活动，其目的通常是为了逼近所需的目标或结果，每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代（所以循环和迭代是有本质区别的）

可迭代对象

​ 从语法形式上讲，内置有__iter__方法的对象都是可迭代对象，前面提到的数据类型诸如字符串、列表、元组、字典、集合、打开的文件都是可迭代对象

a={'name':'egon'}.__iter__
b={7,8,9}.__iter__
print(a,b)

迭代器对象

​ 调用obj.iter()方法返回的结果就是一个迭代器对象(Iterator)。迭代器对象是内置有iter和next方法的对象，打开的文件本身就是一个迭代器对象，执行迭代器对象.iter()方法得到的仍然是迭代器本身，而执行迭代器.next()方法就会计算出迭代器中的下一个值。 迭代器是Python提供的一种统一的、不依赖于索引的迭代取值方式，只要存在多个“值”，无论序列类型还是非序列类型都可以按照迭代器的方式取值

s={1,2,3} # 可迭代对象s
i=iter(s)  # 本质就是在调用i=s.__iter__(),返回s的迭代器对象i，
next(i)  # 本质就是在调用i.__next__() 返回1
next(i)  # 返回2
next(i)  # 返回3
next(i)  # 抛出StopIteration的异常，代表无值可取，迭代结束

for循环原理

​ while循环模拟迭代取值

goods=['mac','lenovo','acer','dell','sony']
i=iter(goods) # 转换成迭代器对象，节省内存空间
while True:
    try:
        print(next(i))
    except StopIteration: # 出现异常，终止循环
        break

​ for循环又称为迭代循环，in后可以跟任意可迭代对象，执行的时候会自动将in后面的可迭代对象转化成迭代器，缩减了代码

goods=['mac','lenovo','acer','dell','sony']
for item in goods:   
    print(item)

​ for 循环在工作时，首先会调用可迭代对象内置的iter方法，转化成一个迭代器对象，然后再调用该迭代器对象的next方法将取到的值赋给item，执行循环体完成一次循环，周而复始，直到捕捉StopIteration异常，结束迭代

​ 为什么优先使用迭代器呢，因为他省空间，下面详细介绍迭代器优缺点

迭代器的优缺点

优点：

  1. 为序列和非序列类型提供了一种统一的迭代取值方式
  2. 节省内存
  3. 惰性机制：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。

缺点：

  1. 除非取尽，否则无法获取迭代器的长度
  2. 只能取下一个值，不能回到开始，更像是‘一次性的’，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用next；若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象，如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值（不能回头取值）

生成器与yield

​ 生成器本质上也是一个迭代器

​ 在函数体中用yield关键字代替return关键字，得到的就是生成器

def my_range(start,stop,step=1):
    print('start...')
    while start < stop:
        yield start
        start+=step
    print('end...')

g=my_range(0,3)
g  # <generator object my_range at 0x104105678>

​ 生成器内置有__iter__和__next__方法，iter方法说明他也是一个迭代器，next方法用来取值

g.__iter__
# <method-wrapper '__iter__' of generator object at 0x1037d2af0>
g.__next__
# <method-wrapper '__next__' of generator object at 0x1037d2af0>

因而我们可以用next(生成器)触发生成器所对应函数的执行，

next(g) # 触发函数执行直到遇到yield则停止,将yield后的值返回，并在当前位置挂起函数
# start...
# 0
next(g) # 再次调用next(g)，函数从上次暂停的位置继续执行，直到重新遇到yield...
# 1
next(g) 
# 2
next(g) # 触发函数执行没有遇到yield则无值返回，抛出StopIteration异常，结束迭代
# end...

生成器对象也可以使用for循环迭代，如下：

def condown():
    yield 3
    yield 2
    yield 1
for i in countdown(3):
    print(i)
'''
3
2
1
'''

​ 有了yield关键字，我们就有了一种自定义迭代器的实现方式。yield可以用于返回值，但不同于return，函数一旦遇到return就结束了，而yield可以保存函数的运行状态挂起函数，用来返回多次值

yield from 可迭代对象

能够将可迭代对象中的元素依次返回给yield，是yield多个值的简便写法

yield表达式应用：函数挂起

在函数内可以采用表达式形式的yield

# next只能获取yield生成的值，但是不能传递值
def eater():
    print('eat')
    while True:
        food=yield
        print('get the food: %s' %food)

可以拿到函数的生成器对象持续为函数体send值，如下

g=eater() # 得到生成器对象
g
# <generator object eater at 0x101b6e2b0>
next(e) # 需要先”初始化”一次，让函数挂起在food=yield，等待调用g.send()方法为其传值
# eat
g.send('包子')
# get the food: 包子
g.send('鸡腿')
# get the food: 鸡腿

​ 针对表达式形式的yield，生成器对象必须事先被初始化一次，让函数挂起在food=yield的位置，等待调用g.send()方法为函数体传值，g.send(None)等同于next(g)

send和next()区别:

  • 相同点：

    send 和 next()都可以让生成器对应的yield向下执行一次

    都可以获取到yield生成的值

  • 不同点：

    第一次获取yield值只能用next不能用send（可以用send(None)）

    send可以给上一个yield置传递值，也就是说，send谁yield的就是谁

我们可以编写装饰器来完成为所有表达式形式yield对应生成器的初始化操作，如下

def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper

@init
def eater():
    print('Ready to eat')
    while True:
        food=yield
        print('get the food: %s, and start to eat' %food)

​ 表达式形式的yield也可以用于返回多次值，即变量名=yield 值的形式，如下

def eater():
    print('Ready to eat')
    food_list=[]
    while True:
        food=yield food_list
        food_list.append(food)

e=eater()
next(e)

'''
Ready to eat
[]
'''
e.send('蒸羊羔')
# ['蒸羊羔']
e.send('蒸熊掌')
# ['蒸羊羔', '蒸熊掌']
e.send('蒸鹿尾儿')
# ['蒸羊羔', '蒸熊掌', '蒸鹿尾儿']

列表生成式

也是一种简化代码的方法，用来快速生成列表

egg_list=[]
for i in range(10):
    egg_list.append('鸡蛋%s' %i)
# 简化：列表生成式
egg_list=['鸡蛋%s' %i for i in range(10)]

字典生成式

{x:None for x in 'abc'}
# 结果是{'a':None,'b':None,'c':None}

集合生成式

{i for i in range(10)}
# 结果是{1,2,3,4,5,6,7,8,9}

生成器表达式

​ 实际上按照上面的逻辑，下面应该是元组生成式，但是实际上没有元组表达式，元组表达式就是生成器

​ 创建一个生成器对象有两种方式，一种是调用带yield关键字的函数（上面已经介绍过了），另一种就是生成器表达式，与列表生成式的语法格式相同，只需要将[]换成()

[x*x for x in range(3)]
# [0, 1, 4]
g=(x*x for x in range(3))
g
# <generator object <genexpr> at 0x101be0ba0>

对比列表生成式，生成器表达式的优点自然是节省内存（一次只产生一个值在内存中）

next(g)
# 0
next(g)
# 1
next(g)
# 4
next(g) 
# 抛出异常StopIteration

如果我们要读取一个大文件的字节数，应该基于生成器表达式的方式完成（尤其是读取文件的时候，文件大小通常不可知，选择生成器比较好，因为文件太大的话，会直接将内存撑爆）

# 统计文件中的字节数
with open('db.txt','rb') as f:
    nums=(len(line) for line in f)
    total_size=sum(nums) # 依次执行next(nums)，然后累加到一起得到结果

# 打印名字中含有两个'e'的名字
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
         ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
# li = [name for i in names for name in i if name.count('e') == 2]
# print(li)
# 需要注意的是顺序，这里如果将for name in i放在前面会直接报错，这个也好理解，因为代码实际上是左到右顺序执行的，所以要先拿到里面的列表，在进一步拿里面的元素

推荐阅读