Day 8 · 迭代器与生成器

Week 2 · Day 8 / 56 · 预计 1.5-2 小时 · 返回大纲

一、为什么需要迭代器

你已经在用 for item in list、for key in dict、for line in file。这些对象都能被 for 循环遍历,背后是迭代器协议在驱动。

JavaScript
// for...of 依赖 Symbol.iterator
const arr = [1, 2, 3];
for (const item of arr) {
  console.log(item);
}

// 手动调用迭代器
const iter = arr[Symbol.iterator]();
iter.next(); // { value: 1, done: false }
iter.next(); // { value: 2, done: false }
iter.next(); // { value: 3, done: false }
iter.next(); // { value: undefined, done: true }
Python
# for 循环依赖 iter() 和 next()
arr = [1, 2, 3]
for item in arr:
    print(item)

# 手动调用迭代器
iter_obj = iter(arr)
next(iter_obj)  # 1
next(iter_obj)  # 2
next(iter_obj)  # 3
next(iter_obj)  # 抛出 StopIteration
💡 前端类比:Python 的 iter() ≈ JS 的 arr[Symbol.iterator](),Python 的 next() ≈ JS 的 iter.next()。

二、迭代器协议

2.1 可迭代 vs 迭代器

概念Python 名称要求例子
可迭代(Iterable)实现 __iter__()能被 iter() 调用list、dict、str、file
迭代器(Iterator)实现 __next__()能被 next() 调用iter(list)、生成器
# 验证
from collections.abc import Iterable, Iterator

lst = [1, 2, 3]
print(isinstance(lst, Iterable))   # True
print(isinstance(lst, Iterator))   # False

iter_lst = iter(lst)
print(isinstance(iter_lst, Iterable))   # True
print(isinstance(iter_lst, Iterator))   # True

2.2 for 循环的本质

# 你写的
for item in [1, 2, 3]:
    print(item)

# Python 实际执行的
iter_obj = iter([1, 2, 3])
while True:
    try:
        item = next(iter_obj)
    except StopIteration:
        break
    print(item)

三、自定义迭代器

实现 __iter__() 和 __next__() 两个方法,就能让自己的类可迭代。

class Countdown:
    """倒数迭代器:从 n 数到 1"""
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self  # 迭代器就是自己

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

# 使用
for num in Countdown(3):
    print(num)
# 输出:3 2 1
注意:手写迭代器很繁琐,每次都要维护状态(self.current),还要处理 StopIteration。所以 Python 提供了更优雅的方式——生成器。

四、生成器(Generator)

4.1 什么是生成器

生成器是一种简化版的迭代器,用 yield 关键字替代 __next__(),自动处理状态和异常。

JavaScript (Generator)
function* countdown(start) {
  while (start > 0) {
    yield start;
    start--;
  }
}

const gen = countdown(3);
gen.next(); // { value: 3, done: false }
gen.next(); // { value: 2, done: false }
gen.next(); // { value: 1, done: false }
gen.next(); // { value: undefined, done: true }
Python (Generator)
def countdown(start):
    while start > 0:
        yield start
        start -= 1

gen = countdown(3)
next(gen)  # 3
next(gen)  # 2
next(gen)  # 1
next(gen)  # 抛出 StopIteration

4.2 yield vs return

returnyield
作用返回结果,结束函数产出一个值,暂停函数
调用次数一次多次
返回类型普通函数生成器函数
状态不保留自动保留局部变量
# 普通函数:一次性返回所有
def get_squares_list(n):
    return [i**2 for i in range(n)]

# 生成器函数:逐个产出
def get_squares_gen(n):
    for i in range(n):
        yield i**2

# 对比
print(get_squares_list(5))  # [0, 1, 4, 9, 16],一次性占内存
print(get_squares_gen(5))  # <generator object>,惰性计算

五、生成器的优势

5.1 节省内存

# 场景:处理 1000 万行日志

# 列表:一次性加载,内存爆炸
logs = [line for line in open('big.log')]  # 1000 万行全在内存

# 生成器:逐行读取,内存恒定
def read_logs(file_path):
    with open(file_path) as f:
        for line in f:
            yield line.strip()

for line in read_logs('big.log'):  # 每次只读一行
    process(line)

5.2 无限序列

def infinite_counter():
    num = 0
    while True:
        yield num
        num += 1

# 不会卡死,因为是惰性的
gen = infinite_counter()
print(next(gen))  # 0
print(next(gen))  # 1
print(next(gen))  # 2
# ... 想用多少取多少

六、生成器表达式

类似列表推导式,但用 () 替代 [],返回生成器。

JavaScript
// 数组:一次性
const arr = Array.from({length: 5}, (_, i) => i**2);

// 没有生成器表达式,
// 要用 function* 或管道
Python
# 列表推导式:一次性
squares_list = [i**2 for i in range(5)]

# 生成器表达式:惰性
squares_gen = (i**2 for i in range(5))

print(sum(squares_gen))  # 0+1+4+9+16 = 30
# 对比内存占用
import sys

list_comp = [i for i in range(10000)]
gen_expr = (i for i in range(10000))

print(sys.getsizeof(list_comp))  # 87632 字节
print(sys.getsizeof(gen_expr))   # 192 字节

七、常用内置迭代器

函数作用例子
range(n)惰性生成数字序列range(10)
enumerate(iter)同时返回索引和值for i, v in enumerate(['a','b'])
zip(a, b)并行遍历多个序列for x, y in zip(list1, list2)
map(fn, iter)对每个元素应用函数map(str.upper, ['a','b'])
filter(fn, iter)过滤元素filter(lambda x: x>0, nums)
# enumerate:同时拿到索引和值
fruits = ['苹果', '香蕉', '橙子']
for i, fruit in enumerate(fruits):
    print(f'{i}: {fruit}')
# 0: 苹果
# 1: 香蕉
# 2: 橙子

# zip:并行遍历
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f'{name}: {age}岁')

八、练习

练习 1:斐波那契生成器

写一个生成器,产出斐波那契数列的前 n 项:0, 1, 1, 2, 3, 5, 8, ...

def fibonacci(n):
    a, b = 0, 1
    count = 0
    while count < n:
        yield a
        a, b = b, a + b
        count += 1

for num in fibonacci(8):
    print(num, end=' ')
# 0 1 1 2 3 5 8 13

练习 2:读取大文件

写一个生成器,逐行读取文件,只返回包含"ERROR"的行。

def read_errors(file_path):
    with open(file_path, encoding='utf-8') as f:
        for line in f:
            if 'ERROR' in line:
                yield line.strip()

for error in read_errors('app.log'):
    print(error)

练习 3:平移生成器

写一个生成器,每次产出当前元素和下一个元素(平移窗口大小 2)。

def pair_window(iterable):
    it = iter(iterable)
    prev = next(it)
    for curr in it:
        yield prev, curr
        prev = curr

for pair in pair_window([1, 2, 3, 4]):
    print(pair)
# (1, 2)
# (2, 3)
# (3, 4)

练习 4:生成分页器

写一个生成器,把一个大列表分成每页 size 个元素。

def paginate(items, page_size):
    for i in range(0, len(items), page_size):
        yield items[i:i + page_size]

users = list(range(1, 21))  # 20 个用户
for page_num, page in enumerate(paginate(users, 5), 1):
    print(f'第{page_num}页: {page}')
# 第1页: [1, 2, 3, 4, 5]
# 第2页: [6, 7, 8, 9, 10]
# ...

九、打卡验收

理解了迭代器协议,知道 iter() 和 next() 的关系
能区分可迭代(Iterable)和迭代器(Iterator)
理解了 for 循环的本质是不断调用 next() 直到 StopIteration
会用 yield 写生成器,理解了生成器和普通函数的区别
理解了生成器的惰性计算和内存优势
会写生成器表达式 (x for x in iter),知道和列表推导式的区别
会用 enumerate、zip、map、filter 等内置迭代器
完成了至少 2 个练习,代码能跑通
打卡方式: 全部勾选后,告诉我 "Day 8 打卡",并贴出你的代码,我帮你检查。
明天预告(Day 9): 装饰器(Decorator)——Python 最优雅的设计模式,给函数加功能不修改原代码。