Python迭代器与生成器-JXin的博客

迭代器(Iterator)

迭代器是实现了__iter__和__next__方法的对象

class MyIterator:

    def __iter__(self):
        """
        要求：必须返回迭代器
        99.999999%的情况下，返回迭代器自身
        """
        return self

    def __next__(self):
        """返回下一个值"""
        pass
      
obj = MyIterator()  # obj 是一个迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14

应用：无限序列

class FibonacciIterator:
    """无限斐波那契数列迭代器"""

    def __init__(self):
        self.a = 1
        self.b = 1

    def __iter__(self):
        return self

    def __next__(self):
        current = self.a
        self.a, self.b = self.b, self.a + self.b
        return current

# 使用示例
fib = FibonacciIterator()

print(next(fib))  # 输出: 1  等效于 fib.__next__()
print(next(fib))  # 输出: 1
print(next(fib))  # 输出: 2
print(next(fib))  # 输出: 3
print(next(fib))  # 输出: 5
print(next(fib))  # 输出: 8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

可迭代对象(Iterable)

可迭代协议规定，只要一个对象实现了 __iter__() 方法，且返回一个迭代器，则它就是可迭代对象

推理可知：迭代器一定是可迭代对象

python中的容器类型都是可迭代对象

my_list = [1, 2, 3]

# 调用 iter() 获取迭代器
iterator = iter(my_list)  # 等价于 my_list.__iter__()

print(type(iterator))     # <class 'list_iterator'>

# 使用 next() 逐个获取值
print(next(iterator))     # 1
print(next(iterator))     # 2
print(next(iterator))     # 3

# print(next(iterator))   # StopIteration! 没有更多元素了

1
2
3
4
5
6
7
8
9
10
11
12
13

示例：倒数对象

class Countdown:
    """可迭代对象：倒数"""

    def __init__(self, start):
        self.start = start

    def __iter__(self):
        """返回一个新的迭代器"""
        return CountdownIterator(self.start)

class CountdownIterator:
    """迭代器"""

    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < 0:
            raise StopIteration
        num = self.current
        self.current -= 1
        return num

cd = Countdown(5)

iterator = iter(cd)
print(next(iterator))  # 5
print(next(iterator))  # 4
print(next(iterator))  # 3
print(next(iterator))  # 2
print(next(iterator))  # 1
print(next(iterator))  # 0
# print(next(iterator))  # StopIteration!

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

消费者

1. `for`循环

# for 循环会自动调用 iter() 和 next()
for n in Countdown(3):
    print(n)  # 3 2 1 0

1
2
3

2. `list()`、`tuple()`、`set()` 等构造函数

print(list(Countdown(3)))  # [3, 2, 1, 0]
print(tuple(Countdown(3)))  # (3, 2, 1, 0)
print(set(Countdown(3)))  # {0, 1, 2, 3}

1
2
3

3. **`*` 解包操作符**

first, *rest = Countdown(3)
print(first)  # 3
print(rest)   # [2, 1, 0]

# 或用列表解包
values = [*Countdown(3)]
print(values)  # [3, 2, 1, 0]

1
2
3
4
5
6
7

4. `in` 成员判断

print(5 in Countdown(3))   # False
print(2 in Countdown(3))   # True

1
2

5. `sum()`、`max()`、`min()` 等内置函数

print(sum(Countdown(3)))  # 6
print(max(Countdown(3)))  # 3
print(min(Countdown(3)))  # 0

1
2
3

6. `zip()`、`map()`、`filter()` 等函数

# zip 合并多个可迭代对象
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name}: {age}")
# Alice: 25
# Bob: 30
# Charlie: 35

# map 对元素进行转换
squares = map(lambda x: x**2, Countdown(3))
print(list(squares))  # [9, 4, 1, 0]

# filter 过滤元素
evens = filter(lambda x: x % 2 == 0, Countdown(3))
print(list(evens))  # [2, 0]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7. `any()`、`all()`

numbers = Countdown(3)
print(any(numbers))  # True (至少一个为真)
print(all(numbers))  # False (是否所有都为真)

1
2
3

range函数

range() 是 Python 中最常用的可迭代对象之一，用于生成整数序列：

# range(stop): 0 到 stop-1
for i in range(5):
    print(i, end=" ")  # 0 1 2 3 4

# range(start, stop): start 到 stop-1
for i in range(2, 6):
    print(i, end=" ")  # 2 3 4 5

# range(start, stop, step): 指定步长
for i in range(0, 10, 2):
    print(i, end=" ")  # 0 2 4 6 8

# 负数步长（倒序）
for i in range(5, 0, -1):
    print(i, end=" ")  # 5 4 3 2 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

重要特性：

惰性计算：range 不会一次性生成所有数字，而是按需生成
支持索引和切片：与列表不同，range 支持随机访问

r = range(0, 100, 2)

print(len(r))      # 50
print(r[5])        # 10
print(r[0:5])      # range(0, 10, 2)
print(10 in r)     # True
print(11 in r)     # False

1
2
3
4
5
6
7

不是迭代器：range 是可迭代对象，但不是迭代器（可以重复使用）

r = range(3)

for i in r:
    print(i, end=" ")  # 0 1 2
print()

for i in r:
    print(i, end=" ")  # 0 1 2（可以再次遍历）

1
2
3
4
5
6
7
8

range 对象在内存中只存储 start、stop、step 三个值，无论范围多大都占用固定内存

推导式

推导式(Comprehension)是一种简洁的语法，用于从一个可迭代对象创建新的列表、字典或集合。

列表推导式

# 基本语法：[表达式 for 变量 in 可迭代对象]
squares = [x**2 for x in range(5)]
print(squares)  # [0, 1, 4, 9, 16]

# 带条件过滤：[表达式 for 变量 in 可迭代对象 if 条件]
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # [0, 2, 4, 6, 8]

# 带 if-else 条件
labels = ["偶数" if x % 2 == 0 else "奇数" for x in range(5)]
print(labels)  # ['偶数', '奇数', '偶数', '奇数', '偶数']

1
2
3
4
5
6
7
8
9
10
11

字典推导式

# 基本语法：{键表达式: 值表达式 for 变量 in 可迭代对象}
square_dict = {x: x**2 for x in range(5)}
print(square_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 带条件过滤
odd_squares = {x: x**2 for x in range(10) if x % 2 != 0}
print(odd_squares)  # {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

1
2
3
4
5
6
7

集合推导式

# 基本语法：{表达式 for 变量 in 可迭代对象}
square_set = {x**2 for x in range(10)}
print(square_set)  # {0, 1, 4, 81, 64, 9, 16, 49, 25, 36}

# 带条件过滤
evens = {x for x in range(20) if x % 2 == 0}
print(evens)  # {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}

1
2
3
4
5
6
7

嵌套推导式

# 嵌套列表推导式：将二维列表展平
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 等价于：
# flat = []
# for row in matrix:
#     for x in row:
#         flat.append(x)

# 嵌套条件
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 只保留偶数
result = [x for row in matrix for x in row if x % 2 == 0]
print(result)  # [2, 4, 6, 8]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

元组推导式

Python中没有元组推导式。

推导式 vs 循环

推导式通常比等效的 for 循环更快，也更简洁：

# 推导式（推荐）
squares = [x**2 for x in range(10)]

# 等效的循环写法
squares = []
for x in range(10):
    squares.append(x**2)

1
2
3
4
5
6
7

注意：当逻辑过于复杂时，使用普通循环会更清晰易读

生成器(Generator)

生成器函数

# Python识别到这个函数中包含yield的关键字，因此该函数是一个生成器函数。
def simple_generator():
    print("开始")
    yield 1
    print("继续")
    yield 2
    print("结束")
    yield 3

g = simple_generator() # 生成器函数返回的是生成器，生成器是一个迭代器。
print(next(g))  # 开始
                # 1
print(next(g))  # 继续
                # 2
print(next(g))  # 结束
                # 3
# print(next(g))  # StopIteration!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

可以利用生成器这种简易写法，快速完成迭代器的编写。

def countdown(start):
    """生成器函数"""
    while start >= 0:
        yield start
        start -= 1


# 调用生成器函数，返回生成器
cd = countdown(5)
print(type(cd))       # <class 'generator'>

for n in cd:
    print(n, end=" ")  # 5 4 3 2 1 0

1
2
3
4
5
6
7
8
9
10
11
12
13

生成器的特点：

惰性计算：只在需要时生成值，不占用大量内存
状态保存：每次 yield 后暂停，下次从暂停处继续
一次性：和迭代器一样，只能遍历一次

链式调用

def sub_generator():
    yield 1
    yield 2


def main_generator():
    yield "开始"
    for value in sub_generator():
        yield value
    yield "结束"


for value in main_generator():
    print(value)
# 开始
# 1
# 2
# 结束

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

可使用yield from 语法糖简化代码：

def main_generator():
    yield "开始"
    yield from sub_generator()  # 委托给子生成器
    yield "结束"

1
2
3
4

发送数据

当调用生成器的send函数的时候，可以向生成器发送数据，该数据会导致yield的表达式返回对应的值。

def calculator():
    total = 0
    while True:
        x = yield total  # yield 返回当前总数，并接收新值
        if x is None:
            break
        total += x

calc = calculator()
print(next(calc))      # 输出: 0 (启动)
print(calc.send(10))   # 输出: 10 (发送10，累加后返回)
print(calc.send(20))   # 输出: 30
print(calc.send(5))    # 输出: 35

1
2
3
4
5
6
7
8
9
10
11
12
13

生成器表达式

类似列表推导式，但使用圆括号，返回生成器：

# 生成器表达式 —— 惰性计算，节省内存
squares_gen = (x**2 for x in range(1000000))

print(type(squares_gen))   # <class 'generator'>

# 按需获取值
print(next(squares_gen))   # 0
print(next(squares_gen))   # 1
print(next(squares_gen))   # 4

1
2
3
4
5
6
7
8
9

itertools 简介

itertools 模块提供了许多高效的迭代器工具：

import itertools

# count(start, step)：无限计数
counter = itertools.count(10, 2)
print(next(counter))  # 10
print(next(counter))  # 12
print(next(counter))  # 14

# cycle(iterable)：无限循环
cy = itertools.cycle(["A", "B", "C"])
print(next(cy))  # A
print(next(cy))  # B
print(next(cy))  # C
print(next(cy))  # A（重新开始）

# repeat(value, times)：重复值
times_three = list(itertools.repeat("x", 3))
print(times_three)  # ['x', 'x', 'x']

# chain(*iterables)：连接多个可迭代对象
combined = list(itertools.chain([1, 2], [3, 4], [5, 6]))
print(combined)  # [1, 2, 3, 4, 5, 6]

# islice(iterable, start, stop, step)：切片（支持无限迭代器）
first_five = list(itertools.islice(itertools.count(), 5))
print(first_five)  # [0, 1, 2, 3, 4]

# permutations(iterable, r)：排列
perms = list(itertools.permutations([1, 2, 3], 2))
print(perms)  # [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

# combinations(iterable, r)：组合
combs = list(itertools.combinations([1, 2, 3, 4], 2))
print(combs)  # [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

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

作业

先使用费曼学习法，复述迭代器、可迭代对象、生成器的概念和关系

一、实现扁平化迭代器

编写一个生成器函数 flatten，将嵌套的列表扁平化：

def flatten(nested_list):
    # 你的代码
    pass

nested = [1, [2, [3, 4], 5], 6, [7, 8]]
print(list(flatten(nested)))
# [1, 2, 3, 4, 5, 6, 7, 8]

1
2
3
4
5
6
7

二、实现分页迭代器

编写一个生成器，模拟从数据库分页读取数据：

def paginated_query(total_items, page_size):
    """
    模拟分页查询
    total_items: 总数据量
    page_size: 每页大小
    每次 yield 返回一页数据（列表）
    """
    # 你的代码
    pass

for page in paginated_query(25, 10):
    print(page)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
# [20, 21, 22, 23, 24]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三、思考题

下面代码的输出是什么？为什么？

def generator():
    print("准备 yield 1")
    yield 1
    print("准备 yield 2")
    yield 2
    print("准备 yield 3")
    yield 3
    print("生成器结束")

g = generator()
print("生成器已创建")
print(next(g))
print("---")
print(next(g))
print("---")
g.close()
print("生成器已关闭")
print(next(g))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

作业答案

一、实现扁平化迭代器

def flatten(nested_list):
    for item in nested_list:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

nested = [1, [2, [3, 4], 5], 6, [7, 8]]
print(list(flatten(nested)))
# [1, 2, 3, 4, 5, 6, 7, 8]

1
2
3
4
5
6
7
8
9
10

二、实现分页迭代器

def paginated_query(total_items, page_size):
    """
    模拟分页查询
    total_items: 总数据量
    page_size: 每页大小
    每次 yield 返回一页数据（列表）
    """
    for start in range(0, total_items, page_size):
        end = min(start + page_size, total_items)
        yield list(range(start, end))

for page in paginated_query(25, 10):
    print(page)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
# [20, 21, 22, 23, 24]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

三、思考题

def generator():
    print("准备 yield 1")
    yield 1
    print("准备 yield 2")
    yield 2
    print("准备 yield 3")
    yield 3
    print("生成器结束")

g = generator()
print("生成器已创建")
print(next(g))
print("---")
print(next(g))
print("---")
g.close()
print("生成器已关闭")
print(next(g))

# 生成器已创建
# 准备 yield 1
# 1
# ---
# 准备 yield 2
# 2
# ---
# 生成器已关闭
# StopIteration 异常

# 原因：
# 1. `g = generator()` 只是创建生成器对象，不会执行函数体，因此先打印"生成器已创建"
# 2. `next(g)` 启动生成器，执行到第一个 yield，打印"准备 yield 1"并返回 1
# 3. 第二次 `next(g)` 从上次暂停处继续，打印"准备 yield 2"并返回 2
# 4. `g.close()` 关闭生成器，在暂停处抛出 GeneratorExit 异常，生成器终止
# 5. `print("生成器已关闭")` 正常执行
# 6. 再次 `next(g)` 时，由于生成器已关闭，会抛出 StopIteration 异常

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

Python迭代器与生成器

迭代器(Iterator)

应用：无限序列

可迭代对象(Iterable)

示例：倒数对象

消费者

1. for循环

2. list()、tuple()、set() 等构造函数

3. * 解包操作符

4. in 成员判断

5. sum()、max()、min() 等内置函数

6. zip()、map()、filter() 等函数

7. any()、all()

range函数

推导式

列表推导式

字典推导式

集合推导式

嵌套推导式

元组推导式

推导式 vs 循环

生成器(Generator)

生成器函数

链式调用

发送数据

生成器表达式

itertools 简介

作业

一、实现扁平化迭代器

二、实现分页迭代器

三、思考题

作业答案

一、实现扁平化迭代器

二、实现分页迭代器

三、思考题

1. `for`循环

2. `list()`、`tuple()`、`set()` 等构造函数

3. **`*` 解包操作符**

4. `in` 成员判断

5. `sum()`、`max()`、`min()` 等内置函数

6. `zip()`、`map()`、`filter()` 等函数

7. `any()`、`all()`