使用迭代器和生成器

数据科学经常涉及处理那些庞大到无法轻松载入内存的数据集。一次性加载整个数据集可能效率低下，甚至不可能实现。Python 提供了强大的结构，称为迭代器和生成器，以优雅地处理这类情况，从而按顺序处理数据，而无需预先存储所有内容。这种方法对于编写可扩展且内存效率高的数据分析和机器学习 (machine learning)管道代码非常重要。

了解迭代器

本质上，迭代器是一个表示数据流的对象。它允许你逐个遍历一系列项。Python 中迭代的机制受迭代器协议控制，该协议要求对象实现两个特定方法：

1. __iter__(): 此方法返回迭代器对象本身。当你开始迭代一个对象时（例如，在 for 循环的开头），就会调用此方法。
2. __next__(): 此方法返回序列中的下一个项。当没有更多项时，它会引发 StopIteration 异常。

许多内置的 Python 对象，如列表、元组、字典和字符串，都是可迭代的。这意味着它们有一个返回迭代器的 __iter__() 方法。你可以使用内置的 iter() 函数从可迭代对象获取迭代器，并使用 next() 函数检索下一个项。

让我们通过一个简单的列表来看看它的实际作用：

my_list = [10, 20, 30]

# 从列表中获取一个迭代器对象
my_iterator = iter(my_list)

# 检查类型
print(type(my_iterator))
# 输出: <class 'list_iterator'>

# 使用 next() 逐个检索项
print(next(my_iterator)) # 输出: 10
print(next(my_iterator)) # 输出: 20
print(next(my_iterator)) # 输出: 30

# 尝试获取另一个项会引发 StopIteration
try:
    print(next(my_iterator))
except StopIteration:
    print("没有更多项了！")
# 输出: 没有更多项了！

你很少需要像这样直接调用 iter() 和 next()。Python 的 for 循环会在幕后自动处理这个过程。当你编写：

for item in my_list:
    print(item)

Python 首先调用 iter(my_list) 来获取一个迭代器。然后，在每次迭代中，它对迭代器调用 next() 以获取下一个项并将其赋值给 item。当 next() 引发 StopIteration 时，循环会自动停止。这使得迭代清晰直观。

介绍生成器：创建迭代器的一种更简单的方法

虽然你可以通过定义一个带有 __iter__ 和 __next__ 方法的类来创建自定义迭代器，但 Python 提供了一种更方便的方式：生成器。

生成器是一种特殊的函数，它返回一个迭代器。生成器函数不使用 return 返回值并退出，而是使用 yield 关键字。当生成器函数遇到 yield 时，它会在此处暂停执行，将生成的值返回给调用者，并保存其局部状态。下次调用迭代器的 next() 方法时，函数会从 yield 语句之后恢复执行，一直持续到遇到另一个 yield、完成或遇到 return 语句（这会隐式引发 StopIteration）。

考虑这个简单的生成器函数：

def count_up_to(n):
    """生成从 1 到 n 的数字。"""
    i = 1
    while i <= n:
        yield i # 在这里暂停，返回 i，并等待
        i += 1 # 在下次调用 next() 时从这里恢复
    print("生成器已完成。") # 这行在最后一个 yield 之后运行

# 创建一个生成器对象（调用函数本身并不会立即执行它）
counter_gen = count_up_to(3)

print(type(counter_gen))
# 输出: <class 'generator'>

# 使用 next() 迭代
print(next(counter_gen)) # 输出: 1
print(next(counter_gen)) # 输出: 2
print(next(counter_gen)) # 输出: 3

# 下次调用会引发 StopIteration
try:
    next(counter_gen)
except StopIteration:
    print("按预期捕获到 StopIteration。")
# 输出: 生成器已完成。
# 输出: 按预期捕获到 StopIteration。

# 你也可以直接使用 for 循环
print("\n使用 for 循环：")
for number in count_up_to(4):
    print(number)
# 输出:
# 使用 for 循环：
# 1
# 2
# 3
# 4
# 生成器已完成。

请注意，“Generator finished.”消息只会在循环（或手动 next() 调用）用尽所有生成的值之后才会出现。

为什么在数据科学中使用生成器？

生成器在数据科学和机器学习 (machine learning)中特别有用，原因如下：

1. 内存效率： 这是最重要的优势。生成器一次只产生一个项，并且仅在请求时产生（惰性评估）。它们不会将整个序列存储在内存中。想象一下处理一个几 GB 大小的日志文件。使用生成器逐行读取它是可行的，而将整个文件加载到列表中则很可能会导致程序崩溃。

   # 示例：逐行处理可能很大的文件
   def read_large_file(filepath):
       """逐行读取文件的生成器。"""
       try:
           with open(filepath, 'r') as f:
               for line in f:
                   yield line.strip() # 一次处理/生成一行
       except FileNotFoundError:
           print(f"错误: 未在 {filepath} 找到文件")
   
   # 用法：
   # for log_entry in read_large_file('huge_log_file.txt'):
   #     if 'ERROR' in log_entry:
   #         print(f"找到错误: {log_entry}")
   # 这会在不将整个文件加载到内存中的情况下处理文件。
   

2. 惰性评估： 计算仅在需要值时执行。如果你为一个可能无限长或非常长的序列创建生成器，你只需为实际使用的项支付计算成本。

3. 可组合性： 生成器可以串联起来，以创建高效的数据处理管道。一个生成器的输出可以作为下一个生成器的输入，数据以每次一个项的方式流经管道。

   def get_lines(filepath):
       """从文件中生成行。"""
       with open(filepath, 'r') as f:
           for line in f:
               yield line
   
   def extract_values(lines, column_index):
       """从特定列生成值（假设为 CSV）。"""
       for line in lines:
           parts = line.strip().split(',')
           if len(parts) > column_index:
               yield parts[column_index]
   
   def convert_to_float(values):
       """生成浮点数转换，跳过错误。"""
       for value in values:
           try:
               yield float(value)
           except ValueError:
               continue # 跳过非浮点数值
   
   # 示例管道（假设 'data.csv' 存在）
   # file_path = 'data.csv'
   # lines_gen = get_lines(file_path)
   # values_gen = extract_values(lines_gen, 2) # 获取第3列
   # floats_gen = convert_to_float(values_gen)
   
   # 现在你可以逐个处理浮点数
   # total = 0
   # count = 0
   # for val in floats_gen:
   #     total += val
   #     count += 1
   # if count > 0:
   #     print(f"第2列的平均值: {total / count}")
   

生成器表达式

正如在上一节关于推导式中简要提及的，Python 提供了一种简洁的语法来即时创建简单的生成器：生成器表达式。它们看起来非常像列表推导式，但使用圆括号 () 而不是方括号 []。

# 列表推导式（在内存中创建完整列表）
squares_list = [x * x for x in range(10)]
print(squares_list)
# 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(type(squares_list))
# 输出: <class 'list'>

# 生成器表达式（创建一个生成器对象）
squares_gen = (x * x for x in range(10))
print(squares_gen)
# 输出: <generator object <genexpr> at 0x...>（地址可能不同）
print(type(squares_gen))
# 输出: <class 'generator'>

# 你需要迭代才能获取值
print(list(squares_gen)) # 转换为列表以查看值
# 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 注意：一旦迭代，生成器就会被耗尽
print(list(squares_gen))
# 输出: []

当你需要一个迭代器立即使用（例如在 for 循环中或传递给 sum() 等函数），并且逻辑足够简单以适应单个表达式时，生成器表达式非常有用。它们提供与生成器函数相同的内存优势。

# 在不创建中间列表的情况下求平方和
total_sum_of_squares = sum(x * x for x in range(1000000))
print(f"高效计算的总和: {total_sum_of_squares}")

通过理解并运用迭代器和生成器，你可以编写高效处理数据流和大型序列的 Python 代码，这是为机器学习 (machine learning)模型准备和处理数据时的一项重要能力。它们通过将数据生成逻辑与数据消费逻辑分离，从而促进更简洁的代码。