刘硕的技术查阅手册

Python 全栈开发学习笔记

0%

迭代器和生成器

发表于 更新于 分类于
迭代器就是用来将可迭代对象的值一个一个取出来的工具。迭代器除了节省内存之外，似乎没有什么好处，但是广泛应用于 Python 编程过程中，就是因为它能大量节省内存空间。生成器的本质就是一个迭代器，只不过通常是由程序员自己编写实现。

迭代器

迭代器就是用来将可迭代对象的值一个一个取出来的工具。

我们学过的可迭代的数据类型有：字符串、列表、字典、元组、集合

不可迭代的数据类型有：整型、布尔值

Python 中规定，只要是具有 __iter__() 方法就是可迭代对象：

1
2
3
4
5
str.__iter__()
list.__iter__()
tuple.__iter__()
dict.__iter__()
set.__iter__()

可迭代对象可以通过 for 循环获取每一个元素，且可以重复取值：

1
2
3
4
5
s = 'alex'
for i in s:
    print(i)
for j in s:
    print(j)

输出的结果为：

1
2
3
4
5
6
7
8
a
l
e
x
a
l
e
x

我们可以使用可迭代对象的 .__iter__() 方法，将其转化为迭代器。可以通过 .__next__() 方法获取下一位的值：

1
2
3
4
5
6
7
8
lst = [1, 2, 3, 4, 5]
l = lst.__iter__()    # 生成一个迭代器对象
print(l)
print(l.__next__())    # 获取下一位元素
print(l.__next__())
print(l.__next__())
print(l.__next__())
print(l.__next__())

输出的结果为：

1
2
3
4
5
6
<list_iterator object at 0x0000026525B9B588>
1
2
3
4
5

需要注意的是，迭代器中有多少个元素，就只能使用多少次 .__next__() 方法，如果使用次数超过元素个数，就会报错：

1
2
3
File "C:/Users/Sure/PyProject/week03/day11/exercise.py", line 59, in <module>
    print(l.__next__())
StopIteration

在 Python 中，有 .__iter__() 和 .__next__() 方法的就是一个迭代器。

不难看出，文件句柄也是一个迭代器：

1
2
3
f = open('user_info', 'a', encoding='utf-8')
f.__iter__()
f.__next__()

这里说一句，当我们使用 id 函数获取到的内存地址，并不是数据真正存放的位置，只是一串供我们参考的数字而已，不可当真。

需要注意的是，当对同一个可迭代对象多次使用 .__iter__() 方法创建迭代器的时候，我们是创建了多个生成器，这些生成器之间不会相互影响：

1
2
3
4
5
6
7
8
9
10
lst = [1, 2, 3, 4, 5]
l1 = lst.__iter__()    # 这是一个迭代器1
l2 = lst.__iter__()    # 这是一个迭代器2
l3 = lst.__iter__()    # 这是一个迭代器3
print(l1.__next__())
print(l2.__next__())
print(l3.__next__())
print(l2.__next__())
print(l3.__next__())
print(l3.__next__())

输出的结果为：

1
2
3
4
5
6
1
1
1
2
2
3

本质上来讲，for 循环的底层，就是将可迭代对象转换为生成器，通过循环迭代，获取每一个元素的：

1
2
3
4
5
6
7
s = 'alex'
s1 = s.__iter__()
while True:
    try:    # 尝试运行一下缩进体中的代码
        print(s1.__next__())
    except StopIteration:
        break

输出的结果为：

1
2
3
4
a
l
e
x

除了使用可迭代对象的 .__iter__() 和 .__next__() 方法创建和操作迭代器，我们还可以使用 Python 的内置函数，iter() 和 next() 来实现同样地功能：

1
2
3
4
5
lst = [1, 2, 3, 4, 5]
l = iter(lst)
print(next(l))
print(next(l))
print(next(l))

输出结果为：

1
2
3
1
2
3

需要注意的是，在 Python 2 中，创建和使用迭代器时只能使用内置函数 iter() 和 next()，迭代器的 .__iter__() 和 .__next__() 方法不可用；在 Python 3 中，既可以使用内置函数 iter() 和 next()，也可以使用 .__iter__() 和 .__next__() 方法创建和使用迭代器。但是推荐使用兼容性更高的内置函数 iter() 和 next()。

可迭代对象与迭代器的比较：

  • 可迭代对象：str list tuple …

    • 具有 .__iter__() 方法的就是一个可迭代对象
    • 优点：
      1. 使用灵活（每个可迭代对象都有自己的方法）
      2. 能够直接且直观地查看元素个数
    • 缺点：
      • 占内存
    • 应用：当内存空间大，数据量比较少的情况，建议使用可迭代对象

  • 迭代器：文件句柄就是一个迭代器

    • 具有 .__iter__() 和 .__next__() 方法的，就是一个迭代器
    • 优点：
      • 节省内存
    • 缺点：
      1. 只能一个方向执行
      2. 一次性的
      3. 不能灵活操作，不能直接且直观查看元素个数
    • 应用：当内存小，数据量大的情况，建议使用迭代器

迭代器除了节省内存之外，似乎没有什么好处，但是广泛应用于 Python 编程过程中，就是因为它能大量节省内存空间。在编程过程中，我们常常会进行空间和时间的抉择：

  • 时间换空间：迭代器，生成器，用大量的时间来节省空间的使用
  • 空间换时间：可迭代对象，使用大量的空间来节省时间

迭代器同样具有 .__iter__() 方法，因此也是一个可迭代对象，可以直接被for循环：

1
2
3
4
lst = [1, 2, 3, 4]
l = iter(lst)
for i in l:    # for循环可以直接循环迭代器
    print(i)

生成器

生成器的本质就是一个迭代器。

生成器和迭代器的最大区别为：

  • 迭代器：比如文件句柄，是通过数据转换，由 Python 自带提供的
  • 生成器：程序员自己编写实现

生成器的目的为：不再通过数据转换实现迭代器，而是通过代码编写实现。

生成器的定义方式有两种：

  1. 基于函数实现生成器
  2. 使用表达式实现生成器

我们可以通过这个方式来定义和使用一个函数：

1
2
3
4
def func():
    print(1)
    return 5
print(func())

输出的结果为：

1
2
1
5

如果我们把函数中的return替换成yield，就创建了一个生成器：

1
2
3
4
def func():
    print(1)
    yield 5    # 函数体中存在yield就是定义了一个生成器
print(func())    # 创建一个生成器对象

输出的结果为：

1
<generator object func at 0x000001D59DAA2EB8>

func 函数调用时，会生成一个生成器对象，print 打印出来的就是这个生成器对象的内存地址。

生成器的特点是：惰性机制，也就是只有使用 next 方法调用生成器时，才会开始执行生成器的代码。即便是在创建生成器对象时，也不会运行生成器中的内容。

yield 和 return 的部分功能很像

我们可以设定多个 yield，每次使用 next 函数，就会运行到下一个 yield，直至最后：

1
2
3
4
5
6
7
8
def func():
    yield 1
    yield 2
    yield 3
g = func()
print(next(g))
print(next(g))
print(next(g))

输出的结果为：

1
2
3
1
2
3

同迭代器类似，也可以创建多个生成器对象，这些生成器对象彼此独立，互不干扰：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def func():
    yield 1
    yield 2
    yield 3
g1 = func()
g2 = func()
g3 = func()
print(g1, g2, g3)
print(next(g1))
print(next(g2))
print(next(g3))
print(next(g2))
print(next(g3))
print(next(g3))

输出的结果为：

1
2
3
4
5
6
7
<generator object func at 0x0000026AC9932EB8> <generator object func at 0x0000026AC9932F10> <generator object func at 0x0000026AC9932F68>
1
1
1
2
2
3

三个生成器的内存地址各不相同，使用 next 方法也是互不影响。

如果 yield 后面什么也不写，默认返回的值为 None：

1
2
3
4
5
def func():
    yield
print(func().__next__())

输出的结果为： None

同 return 类似，yield 后面也可以接任意数据类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def func():
    yield [1, 2, 3, 4, 5]
print(func().__next__(), type(next(func())))

def foo():
    yield {'key': 1}
print(next(foo()), type(next(foo())))

def f():
    def f1():
        print(123)
    yield f1
print(next(f()), type(next(f())))

def f2():
    yield 1, 2, 3, 4, 5
print(next(f2()), type(next(f2())))

输出的结果为：

1
2
3
4
[1, 2, 3, 4, 5] <class 'list'>
{'key': 1} <class 'dict'>
<function f.<locals>.f1 at 0x0000022675D8DBF8> <class 'function'>
(1, 2, 3, 4, 5) <class 'tuple'>

生成器的好处同迭代器一样，也是可以节省大量的内存空间。

除了 yield 方法，我们还可以使用 yield from 方法来逐个返回可迭代对象中的元素：

1
2
3
4
5
6
7
8
def func():
    yield from [1, 2, 3, 4, 5]    # 将列表中的元素逐个返回
g = func()
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))

输出的结果为：

1
2
3
4
5
1
2
3
4
5

如果两个yield from同时存在，会先将前面的可迭代对象逐个返回之后，再返回后面的可迭代对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def func():
    yield from [55, 44, 66, 77, 88]
    yield from [1, 2, 3, 4, 5]
g = func()
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))

输出结果为：

1
2
3
4
5
6
7
8
9
10
55
44
66
77
88
1
2
3
4
5

迭代器和生成器总结

生成器一定是一个迭代器，但是迭代器不一定是一个生成器；

迭代器一定是一个可迭代对象，但是可迭代对象不一定是一个迭代器。

生成器的本质是一个迭代器，迭代器的本质是一个可迭代对象。

迭代器和生成器的优点：

  • 节省空间

迭代器和生成器的缺点：

  1. 不能直接使用元素
  2. 不能直观查看元素个数
  3. 使用不灵活
  4. 稍微消耗时间
  5. 操作是一次性的，不可逆的

当数据量特别巨大时，要记得使用生成器

区分迭代器和生成器：

1
2
3
4
5
6
7
8
lst = [1, 2, 3]
l = lst.__iter__()

def func():
    yield 1
g = func()

print(l, g)

输出的结果为：

1
<list_iterator object at 0x0000021C1E7BB5C0> <generator object func at 0x0000021C1E722EB8>
  1. 将对象直接用 print 函数打印出来，查看内存地址。如果显示的是 iterator，就是迭代器；如果是 generator，就是生成器（主推荐的）；
  2. 查看是否可用 .send() 方法，如果可用，则是生成器，不可用则是迭代器。

yield 的特点：

  1. yield 能返回多个数据，以元组的形式存储
  2. yield 能返回各种数据类型（Python 中的任意对象）
  3. yield 能够写入多个并且都可以执行
  4. yield 能够记录执行的位置
  5. yield 后面不写内容，默认返回 None
  6. yield 都是将数据一次性返回

yield from 的特点：

  • 将可迭代对象逐个返回

可迭代对象、迭代器和生成器的比较：

  • 可迭代对象：具有 .__iter__() 方法的就是可迭代对象
  • 迭代器：具有 .__iter__() 和 .__next__() 方法的就是一个迭代器
  • 生成器：基于函数创建的生成器，函数体中必须存在 yield