跳至主要内容

Python 生成器:提升性能并简化代码

了解 Python 生成器,优化内存占用并简化工作流。构建高效的真实数据流水线,提升代码性能。
· 10分钟 阅读

使用 AI 探索

想象一下,您在做一个数据科学项目,需要处理的数据集大到一旦载入内存就会让电脑崩溃。或者,您要处理一个无限序列,比如实时数据流,根本不可能同时把所有内容都存下来。这类挑战常常让数据科学家一边端起咖啡,一边按下重启键。

本文将介绍 Python 生成器,以及如何用它们来简化代码。这个概念需要一些练习。如果您是 Python 新手,阅读过程中有些迷糊,建议先学习我们的 Introduction to Python 课程打下扎实基础。

什么是 Python 生成器?

本质上,Python 生成器是一种特殊的函数或紧凑的表达式,可以以惰性方式产生一系列值。把生成器想象成工厂里的传送带:与其把所有产品堆在一起占满空间,不如在物品顺着传送带来到面前时逐个处理。这样既节省内存,又自然契合 Python 的 iterator 协议——这也是 for 循环、推导式等众多内置工具的基础。

生成器的“魔法”来自 yield 关键字。与一次性返回单个值并退出函数的 return 不同,yield 会产出一个值、暂停函数执行并保存其状态。下次调用生成器时,它会从上次暂停处继续。

例如,逐行读取一个超大的日志文件时,生成器可以在读取的同时逐行处理,而无需把整个文件加载到内存中。这种“惰性求值”让生成器区别于传统函数,也使其成为对性能敏感任务的常用工具。

一个基础的 Python 生成器示例

我们先练习一下以熟悉这个概念。下面是一个生成前 n 个整数的生成器函数。

def generate_integers(n):
    for i in range(n):
        yield i  # Pauses here and returns i

# Using the generator
for num in generate_integers(5):
    print(num)
0
1
2
3
4

我做了一张可视化图,帮助您理解底层发生了什么:

Python generator functions flowchart

Python 生成器的语法与模式

实现生成器有多种方式,其中两种主要方式是:生成器函数和生成器表达式。

生成器函数

生成器函数的定义类似普通函数,但使用 yield 而非 return。调用它时,会返回一个可迭代的生成器对象。

def count_up_to(n):
    count = 1
    while count <= n:
        yield count
        count += 1

# Using the generator
counter = count_up_to(5)
for num in counter:
    print(num)
1
2
3
4
5

从上面的例子可以看到,当调用 count_up_to 时,它返回一个生成器对象。每次 for 循环请求一个值,函数就运行到 yield 为止,产出当前的 count 值,并在各次迭代之间保存状态,以便精确地从上次停下的地方继续。

生成器表达式

生成器表达式是一种创建生成器的简洁方式。它类似列表推导式,但使用圆括号而不是方括号。

# List comprehension (eager evaluation)
squares_list = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

# Generator expression (lazy evaluation)
squares_gen = (x**2 for x in range(5))

# Using the generator
for square in squares_gen:
    print(square)
0
1
4
9
16

那么,列表推导式与生成器表达式有什么区别?列表推导式会在内存中创建整个列表,而生成器表达式则是一次产生一个值,从而节省内存。如果您不熟悉列表推导式,可以阅读我们的 Python 列表推导式教程。

Python 生成器 vs. 迭代器

传统迭代器需要定义包含 __iter__() 和 __next__() 方法的类,样板代码多、状态管理也要手动处理;而生成器函数通过自动保存状态、免去这些方法,简化了实现——例如一个简单的函数就能按顺序 yield 出每个数的平方,直到 n。

为什么要使用 Python 生成器

在解释什么是 Python 生成器时,我们已经顺带提到了它们的用途。本节将更详细地展开。生成器并非华而不实的特性,确实能解决实际问题。

内存效率

与同时把所有元素存入内存的列表或数组不同,生成器按需产出值,因此一次只会在内存中保留一个元素。

例如,考虑 Python 2 中 range() 与 xrange() 的差异:

  • range() 会在内存中创建列表,对大范围数值而言不太友好。

  • xrange() 的行为类似生成器,惰性地产生值。

由于 xrange() 的行为更实用,如今在 Python 3 中,range() 也采取了类似生成器的行为,避免了同时存储所有值带来的内存开销。

为展示这一点,我们比较一下生成 1000 万个数字时的内存占用:

import sys

# Using a list
numbers_list = [x for x in range(10_000_000)]
print(f"Memory used by list: {sys.getsizeof(numbers_list) / 1_000_000:.2f} MB")

# Using a generator
numbers_gen = (x for x in range(10_000_000))
print(f"Memory used by generator: {sys.getsizeof(numbers_gen)} bytes")
Memory used by list: 89.48 MB
Memory used by the generator: 112 bytes

可以看到,与列表相比,生成器几乎不占用内存,这种差异非常显著。

性能改进

得益于惰性求值,只有在需要时才计算值。这意味着无需等待整个序列生成完毕,您就能立即开始处理数据。

比如,计算前 100 万个数的平方和:

# Using a list (eager evaluation)
sum_of_squares_list = sum([x**2 for x in range(1_000_000)])

# Using a generator (lazy evaluation)
sum_of_squares_gen = sum(x**2 for x in range(1_000_000))

两种方法结果相同,但生成器版本避免了创建一个巨大的列表,因此通常能更快得到结果。

简洁与可读性

生成器通过消除样板代码,简化了迭代器的实现。比较一下基于类的迭代器与生成器函数:

这是基于类的迭代器:

class SquaresIterator:
    def __init__(self, n):
        self.n = n
        self.current = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.current >= self.n:
            raise StopIteration
        result = self.current ** 2
        self.current += 1
        return result

# Usage
squares = SquaresIterator(5)
for square in squares:
    print(square)

这是生成器函数:

def squares_generator(n):
    for i in range(n):
        yield i ** 2

# Usage
squares = squares_generator(5)
for square in squares:
    print(square)

生成器版本更短、更易读,也无需样板代码。这正体现了 Python 的理念:简单更好。

处理无限序列

最后要说的是,生成器非常适合表示无限序列——这是列表无法做到的。例如,考虑斐波那契数列:

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Usage
fib = fibonacci()
for _ in range(10):
    print(next(fib))
0
1
1
2
3
5
8
13
21
34

这个生成器可以无限地产生斐波那契数而不耗尽内存。其他示例还包括处理实时数据流或时间序列数据。

进阶的 Python 生成器概念

接下来看看更难一些的概念。本节将介绍如何组合生成器,以及如何使用 .send()、.throw() 和 .close() 等特殊方法。

将生成器串联在一起

生成器可以组合使用。通过把多个生成器串起来,您可以模块化地转换、过滤和处理数据。

比如,您有一个无限整数序列,想把每个数平方,并滤掉奇数结果:

def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1
def square_numbers(sequence):
    for num in sequence:
        yield num ** 2
def filter_evens(sequence):
    for num in sequence:
        if num % 2 == 0:
            yield num

# Compose the generators
numbers = infinite_sequence()
squared = square_numbers(numbers)
evens = filter_evens(squared)

# Print the first 10 even squares
for _ in range(10):
    print(next(evens))
0
4
16
36
64
100
144
196
256
324

流程是:infinite_sequence 不断产生数字,square_numbers 对每个数字求平方,filter_evens 再过滤掉奇数,只保留偶数平方。 我们的 Associate Python Developer 职业路径会深入讲解这类内容,展示如何使用生成器以及迭代器和列表推导式构建并调试复杂的数据处理流水线。

生成器的特殊方法

生成器带有一些高级方法,支持双向通信与可控的终止。

send()

.send() 方法允许将值传回生成器,使其成为协程。这对于创建交互式或有状态的生成器很有用。

def accumulator():
    total = 0
    while True:
        value = yield total
        if value is not None:
            total += value

# Using the generator
acc = accumulator()
next(acc)  # Start the generator
print(acc.send(10))  # Output: 10
print(acc.send(5))   # Output: 15
print(acc.send(20))  # Output: 35

其工作方式如下:

  • 通过 next(acc) 启动生成器。

  • 每次调用 .send(value) 都会把一个值发送进生成器,该值赋给 yield 表达式中的 value。

  • 生成器更新其状态(total),并产出新的结果。

throw()

.throw() 方法允许您在生成器内部抛出异常,这有助于错误处理或传达特定信号。

def resilient_generator():
    try:
        for i in range(5):
            yield i
    except ValueError:
        yield "Error occurred!"

# Using the generator
gen = resilient_generator()
print(next(gen))  # Output: 0
print(next(gen))  # Output: 1
print(gen.throw(ValueError))  # Output: "Error occurred!"

其工作方式如下:

  • 生成器正常运行,直到调用 .throw()。

  • 异常在生成器内部被抛出,并可用 try-except 块进行处理。

close()

.close() 方法通过抛出 GeneratorExit 异常来停止生成器。它适用于清理资源或终止无限生成器。

def infinite_counter():
    count = 0
    try:
        while True:
            yield count
            count += 1
    except GeneratorExit:
        print("Generator closed!")

# Using the generator
counter = infinite_counter()

print(next(counter))  # Output: 0
print(next(counter))  # Output: 1
counter.close()       # Output: "Generator closed!"

其工作方式如下:

  • 生成器正常运行,直到调用 .close()。

  • GeneratorExit 异常被抛出,允许生成器在终止前进行清理或记录信息。

数据科学中的实际应用

希望您已经体会到生成器的用处。本节我将突出一些使用场景,帮助您想象在日常工作中如何发挥它们的作用。

处理大型数据集

数据科学中最常见的挑战之一,是数据集过大而无法装入内存。生成器提供了逐行处理这类数据的方法。

设想您有一个 10 GB 的 CSV 销售数据文件,需要筛选某个地区的记录。可以用生成器流水线来实现:

import csv
def read_large_csv(file_path):
    """ Generator to read a large CSV file line by line."""
    with open(file_path, mode="r") as file:
        reader = csv.DictReader(file)
        for row in reader:
            yield row

def filter_by_region(data, region):
    """ Generator to filter rows by a specific region."""
    for row in data:
        if row["Region"] == region:
            yield row

# Generator pipeline
file_path = "sales_data.csv"
region = "North America"
data = read_large_csv(file_path)
filtered_data = filter_by_region(data, region)

# Process the filtered data
for record in filtered_data:
    print(record)

其过程如下:

  1. read_large_csv 按行读取文件,逐行以字典形式产出。

  2. filter_by_region 按指定地区过滤行。

  3. 流水线以增量方式处理数据,避免内存溢出。

这种方法适用于 ETL 流程,在分析前需要对数据进行清洗与转换。您可以在我们的 ETL and ELT in Python 课程中看到类似实践。

流式处理与流水线

数据有时以持续流的形式到达,比如传感器数据、直播源或社交媒体。

假设您在处理每秒产出一次温度读数的物联网设备,想要计算最近 10 次读数的滑动平均:

def sensor_data_stream():
    """Simulate an infinite stream of sensor data."""
    import random
    while True:
        yield random.uniform(0, 100)  # Simulate sensor data

def sliding_window_average(stream, window_size):
    """ Calculate the average over a sliding window of readings."""
    window = []
    for value in stream:
        window.append(value)
        if len(window) > window_size:
            window.pop(0)
        if len(window) == window_size:
            yield sum(window) / window_size

# Generator pipeline
sensor_stream = sensor_data_stream()
averages = sliding_window_average(sensor_stream, window_size=10)

# Print the average every second
for avg in averages:
    print(f"Average temperature: {avg:.2f}")

解释如下:

  1. sensor_data_stream 模拟一个无限的传感器读数流。

  2. sliding_window_average 维护最近 10 次读数的滑动窗口,并产出其平均值。

  3. 该流水线实时处理数据,适用于监控与分析。

其他使用场景

当数据规模不可预知或数据源源不断(甚至无限)时,生成器同样适用。

网页抓取

抓取网站时,往往不知道需要处理多少页或多少条目。用生成器可以从容应对这种不确定性:

def scrape_website(url):
    """ Generator to scrape a website page by page."""
    while url:
        # Simulate fetching and parsing a page
        print(f"Scraping {url}")
        data = f"Data from {url}"
        yield data
        url = get_next_page(url)  # Hypothetical function to get the next page

# Usage
scraper = scrape_website("https://example.com/page1")
for data in scraper:
    print(data)

仿真任务

在仿真(如蒙特卡罗方法)或游戏开发中,生成器可以表示无限或动态序列:

def monte_carlo_simulation():
    """ Generator to simulate random events for Monte Carlo analysis."""
    import random
    while True:
        yield random.random()

# Usage
simulation = monte_carlo_simulation()
for _ in range(10):
    print(next(simulation))

内存与速度基准

由于其工作方式,生成器在内存效率至关重要的场景中表现出色,但(可能会让您意外的是)它们并不总是最快的选择。我们将与列表对比,看看它们的权衡。

前文我们展示过在内存方面生成器优于列表——当时比较了生成 1000 万个数字的内存占用。现在我们来做速度对比:

import time

# List comprehension
start_time = time.time()
sum([x**2 for x in range(1_000_000)])
print(f"List comprehension time: {time.time() - start_time:.4f} seconds")

# Generator expression
start_time = time.time()
sum(x**2 for x in range(1_000_000))
print(f"Generator expression time: {time.time() - start_time:.4f} seconds")
List comprehension time: 0.1234 seconds
Generator expression time: 0.1456 seconds

尽管生成器节省内存,但在这个例子中它反而比列表更慢,因为对于较小数据集,暂停与恢复执行的开销更明显。

对于小数据集,性能差异可以忽略不计;但在大数据集上,生成器的内存优势往往胜过这点速度损失。

常见问题与陷阱

最后,我们来看看一些常见错误或问题:

生成器会被耗尽

生成器一旦耗尽就无法复用;若要再次迭代,必须重新创建。

gen = (x for x in range(5))
print(list(gen))  # Output: [0, 1, 2, 3, 4]
print(list(gen))  # Output: [] (the generator is exhausted)

惰性求值有时会“埋雷”

由于生成器按需产生值,错误或副作用可能要到实际迭代时才会暴露。

生成器也可能被滥用

对于小数据集或简单任务而言,生成器的开销可能不值得节省的内存。例如在需要多次迭代时,将数据实体化可能更合适。

# Generator expression
gen = (x**2 for x in range(10))

# Materialize into a list
squares = list(gen)

# Reuse the list
print(sum(squares))  # Output: 285
print(max(squares))  # Output: 81

何时选择使用生成器

回顾一下,给出一些非常通用的使用建议。以下情况建议使用生成器:

  • 大型数据集:当数据集过大无法装入内存时,使用生成器。
  • 无限序列:用于表示无限序列,如实时数据流或仿真。
  • 流水线:使用生成器构建模块化的数据处理流水线,逐步转换与过滤数据。

何时应当将数据实体化(转换为列表)

  • 小型数据集:如果内存不是问题且需要快速访问所有元素,请用列表而非生成器。
  • 多次迭代:如果需要对相同数据迭代多次,别用生成器;应将其实体化为列表,避免重复创建生成器。

总结与要点

本文展示了生成器如何帮助您解决数据科学中的实际问题:从处理大型数据集到构建实时数据流水线。请持续练习。掌握生成器的最佳方式就是在您的工作中使用它们。可以先尝试用生成器表达式替换列表推导式,或将某个循环重构为生成器函数。

在掌握基础之后,您可以进一步探索基于生成器概念的更高级主题:

  • 协程:使用 .send() 与 .throw() 创建可接收并处理数据的生成器,实现双向通信。

  • 异步编程:将生成器与 Python 的 asyncio 库结合,构建高效的非阻塞应用。

  • 并发:学习如何用生成器实现协作式多任务与轻量级并发。

持续学习,成为专家。参加我们的 Python Developer 职业路径或 Python Programming 技能路径。点击下方链接开始学习。

Oluseye Jeremiah

作者

Oluseye Jeremiah

专注于人工智能、机器学习与数据科学的技术写作者,擅长将复杂概念讲解得清晰易懂。

关于 Python 生成器的常见问答

什么是 Python 生成器?

Python 生成器是一类特殊函数,使用 yield 关键字返回一个迭代器,按次序逐个产生值,避免一次性存储整个序列,从而节省内存。

我应该在何时使用生成器而不是列表推导式?

当内存效率关键、需要处理大型或无限序列时,应使用生成器;而当您需要一个可重复访问或随机索引的完整列表时,列表推导式更合适。

生成器如何提升性能?

通过一次只产出一个值(惰性求值),生成器按需计算,减少内存占用;与在内存中构建完整数据结构相比,这常常能加快处理速度。

我可以多次迭代同一个生成器吗?

不可以。生成器在一次完整迭代后就会被耗尽。若需再次迭代,必须创建一个新的生成器实例。

生成器有哪些实际用例?

生成器适用于处理大型数据集、实时数据流、构建高效流水线,以及在算法或仿真任务中处理如无限序列等场景。

主题