迭代器与Lambda组合性对比：模块化、调试及灵活性分析

问题描述 #

我难以理解“良好”函数组合性的概念。假设采用以下两种方式删除特定扩展名的文件，请问在模块化和调试便捷性方面，哪种方式更受青睐？若存在优劣差异，请举例说明哪种方式在灵活性上存在客观劣势。

使用Lambda函数的实现 #

from typing import List, Callable
import os

def traverse_tree(
        temp_storage: Local, extensions: List[str], is_raw: bool, operation: Callable
):
    for folder_path, subfolders, filenames in os.walk(temp_storage.root_path(is_raw)):
        for filename in filenames:
            base, ext = os.path.splitext(filename)
            if ext in extensions:
                file_path = os.path.join(folder_path, filename)
                operation(file_path)

def clear_temp(
        temp_storage, extensions: List[str], is_raw
):
    traverse_tree(temp_storage=temp_storage, extensions=extensions, is_raw=True, operation=lambda x: os.remove(x))

使用迭代器的实现 #

from typing import List
import os

def traverse_tree(
        temp_storage, extensions: List[str], is_raw
):
    for folder_path, subfolders, filenames in os.walk(temp_storage.root_path(is_raw)):
        for filename in filenames:
            base, ext = os.path.split(filename)
            if ext in extensions:
                file_path = os.path.join(folder_path, filename)
                yield file_path


def clear_temp(
        temp_storage: Local, extensions: List[str], is_raw: bool
):
    for path in traverse_tree(temp_storage, extensions, is_raw):
        os.remove(path)

模块化与调试便捷性对比 #

迭代器的实现方式在这两方面更受青睐，原因如下：

• 模块化：迭代器版本的traverse_tree只负责生成符合条件的文件路径，职责单一。它不需要关心拿到路径后要执行什么操作，这种分离让函数的复用性极强——比如你可以用它统计文件大小、复制文件，完全不用修改遍历逻辑。反观Lambda版本的traverse_tree，把遍历和执行操作绑定在一起，虽然支持传入不同的operation，但核心逻辑里直接嵌入了调用操作的步骤，耦合度更高。
• 调试便捷性：迭代器版本可以轻松插入调试逻辑。比如想验证哪些文件会被处理，直接在clear_temp的循环里加print(path)；或者单独调用traverse_tree，遍历输出所有路径，快速验证筛选逻辑是否正确。而Lambda版本要调试，要么修改traverse_tree里的operation调用逻辑（污染原函数），要么给Lambda额外加调试代码（写法臃肿），操作成本高得多。

灵活性的客观劣势举例 #

Lambda版本的实现存在明显的灵活性局限：

1. 无法中途跳过或中断操作：假设需要删除前检查文件大小，超过100MB的就跳过。迭代器版本可以直接在循环里加判断：

   def clear_temp(temp_storage: Local, extensions: List[str], is_raw: bool):
       for path in traverse_tree(temp_storage, extensions, is_raw):
           if os.path.getsize(path) > 100*1024*1024:
               continue
           os.remove(path)
   

   但Lambda版本要实现这个逻辑，要么把判断塞进Lambda（代码臃肿），要么重新写一个带判断的Callable传入，而且traverse_tree本身无法控制是否跳过某个文件，只能被动执行传入的操作。
2. 无法批量处理结果：如果需要把所有符合条件的文件路径收集起来做批量压缩、移动，迭代器版本直接转成列表list(traverse_tree(...))就能用。Lambda版本则必须修改traverse_tree逻辑，或者在传入的operation里额外维护一个列表，操作非常别扭。
3. 难以组合多个操作：比如想先打印文件路径再删除，迭代器版本可以在循环里依次执行：

   for path in traverse_tree(...):
       print(f"Deleting {path}")
       os.remove(path)
   

   而Lambda版本要么写一个包含两个操作的Callable，要么调用两次traverse_tree（遍历两次目录，效率低），灵活性远不如迭代器版本。

内容的提问来源于stack exchange，提问作者newbnoob