如何基于DRY原则封装嵌套循环外层逻辑，适配可变内部操作？

当然可以！这正是高阶函数（或者说回调函数）的典型应用场景——把不变的外层循环组合逻辑封装成通用函数，把变化的内部操作作为参数传递进去，完美贴合DRY（Don't Repeat Yourself）原则。

先看你可能遇到的重复代码场景 #

假设你现在有两段逻辑，外层嵌套循环结构完全一致，但内部操作不同：

示例1：计算元素组合的和

list_a = [1, 2, 3]
list_b = [10, 20]
list_c = [100, 200]

sum_results = []
for a in list_a:
    for b in list_b:
        for c in list_c:
            # 内部操作：求和
            sum_results.append(a + b + c)
print(sum_results)  # [111, 211, 121, 221, 131, 231]

示例2：拼接元素组合的字符串

list_x = ["hello", "hi"]
list_y = ["world", "there"]
list_z = ["!", "?"]

str_results = []
for x in list_x:
    for y in list_y:
        for z in list_z:
            # 内部操作：字符串拼接
            str_results.append(f"{x} {y}{z}")
print(str_results)  # ["hello world!", "hello world?", "hello there!", ...]

两段代码的外层嵌套循环完全重复，只有内部的业务逻辑不同，这时候就可以把外层逻辑抽出来封装。

解决方案：封装通用循环函数，传入内部操作作为参数 #

我们可以写一个通用函数，负责处理嵌套循环的组合逻辑，然后把需要执行的内部操作以函数参数的形式传进去：

固定层数的嵌套循环封装（适合已知循环层数的场景）

def nested_loop_handler(lists, operation):
    """
    封装固定3层的嵌套循环逻辑
    :param lists: 要循环的列表集合，格式为 [列表1, 列表2, 列表3]
    :param operation: 内部操作函数，接收3个参数（对应每层循环的当前元素）
    :return: 所有操作结果的列表
    """
    results = []
    for item1 in lists[0]:
        for item2 in lists[1]:
            for item3 in lists[2]:
                # 执行传入的内部操作，并收集结果
                results.append(operation(item1, item2, item3))
    return results

然后调用这个函数来实现之前的两个功能：

# 实现求和功能
sum_results = nested_loop_handler(
    [list_a, list_b, list_c],
    lambda a, b, c: a + b + c  # 用lambda传递内部操作
)

# 实现字符串拼接功能
str_results = nested_loop_handler(
    [list_x, list_y, list_z],
    lambda x, y, z: f"{x} {y}{z}"
)

通用任意层数的嵌套循环封装（更灵活）

如果你的嵌套循环层数不固定，可以用itertools.product（Python）来生成所有元素的笛卡尔积，这样不管多少层列表都能处理：

import itertools

def generic_nested_loop(lists, operation):
    """
    封装任意层数的嵌套循环逻辑
    :param lists: 要循环的列表集合，格式为 [列表1, 列表2, ..., 列表n]
    :param operation: 内部操作函数，接收n个参数（对应每层循环的当前元素）
    :return: 所有操作结果的列表
    """
    results = []
    # itertools.product会生成所有列表元素的笛卡尔积，等价于多层嵌套循环
    for items in itertools.product(*lists):
        # 把笛卡尔积的元组拆成参数传给操作函数
        results.append(operation(*items))
    return results

调用示例（比如2层循环）：

list_1 = [1, 2]
list_2 = [3, 4]
# 实现元素相乘功能
multiply_results = generic_nested_loop(
    [list_1, list_2],
    lambda x, y: x * y
)
print(multiply_results)  # [3, 4, 6, 8]

核心思路总结 #

• 分离不变与可变：把重复的循环控制逻辑（不变部分）封装成通用函数，把变化的业务逻辑（内部操作）作为函数参数传递
• 函数式编程思想：利用高阶函数（接收函数作为参数的函数）来实现逻辑复用，让代码职责更清晰
• 兼容性：这种思路在几乎所有支持函数作为参数的编程语言中都适用（比如JavaScript的回调函数、Java的函数式接口等）

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