从入门到高级详解Python中reduce()函数的使用

from functools import reduce

# 问题：计算 [1, 2, 3, 4, 5] 的累加和
numbers = [1, 2, 3, 4, 5]

# reduce的累积过程：
# 第1步：1 + 2 = 3
# 第2步：3 + 3 = 6
# 第3步：6 + 4 = 10
# 第4步：10 + 5 = 15
# 结果：15

result = reduce(lambda a, b: a + b, numbers)
print(result)  # 15

# 等价于：
# ((((1 + 2) + 3) + 4) + 5) = 15

from functools import reduce

# reduce(function, iterable[, initializer])
# function: 二元函数，接收两个参数(累积值, 下一个元素)，返回新的累积值
# iterable: 可迭代对象
# initializer: 可选，初始累积值

# 工作原理图解：
# 没有initializer时：
#   累积值 = 第一个元素
#   for 每个剩余元素:
#       累积值 = function(累积值, 当前元素)
#   return 累积值

# 有initializer时：
#   累积值 = initializer
#   for 每个元素:
#       累积值 = function(累积值, 当前元素)
#   return 累积值

# ⌨️ 逐步查看reduce的过程
numbers = [1, 2, 3, 4, 5]

def add_and_show(a, b):
    """加法并显示中间过程"""
    result = a + b
    print(f"  {a} + {b} = {result}")
    return result

print("reduce过程：")
total = reduce(add_and_show, numbers)
print(f"最终结果: {total}")
# 输出：
# reduce过程：
#   1 + 2 = 3
#   3 + 3 = 6
#   6 + 4 = 10
#   10 + 5 = 15
# 最终结果: 15

# 💡 initializer可以改变reduce的行为

numbers = [1, 2, 3, 4, 5]

# 没有initializer——从第一个元素开始
result1 = reduce(lambda a, b: a + b, numbers)
print(result1)  # 15

# 有initializer=0——从0开始
result2 = reduce(lambda a, b: a + b, numbers, 0)
print(result2)  # 15（结果相同）

# 有initializer=10——从10开始
result3 = reduce(lambda a, b: a + b, numbers, 10)
print(result3)  # 25 = 10 + (1+2+3+4+5)

# ⚠️ initializer很关键！空序列的情况
empty_list = []

# 没有initializer——报错！
# reduce(lambda a, b: a + b, empty_list)
# TypeError: reduce() of empty iterable with no initial value

# 有initializer——安全返回
result4 = reduce(lambda a, b: a + b, empty_list, 0)
print(result4)  # 0

# 💡 始终提供initializer是个好习惯——让代码更安全

from functools import reduce
import operator

numbers = [1, 2, 3, 4, 5]

# 累加求和
total = reduce(operator.add, numbers)
print(f"求和: {total}")  # 15

# 累乘求积
product = reduce(operator.mul, numbers)
print(f"求积: {product}")  # 120（5的阶乘）

# 找最大值
maximum = reduce(lambda a, b: a if a > b else b, numbers)
print(f"最大值: {maximum}")  # 5

# 找最小值
minimum = reduce(lambda a, b: a if a < b else b, numbers)
print(f"最小值: {minimum}")  # 1

# 字符串拼接
words = ["Python", "是", "一门", "优雅的", "语言"]
sentence = reduce(lambda a, b: a + b, words)
print(sentence)  # Python是一门优雅的语言

# 使用空格分隔的拼接
sentence2 = reduce(lambda a, b: f"{a} {b}", words)
print(sentence2)  # Python 是 一门 优雅的 语言

from functools import reduce
import operator

# 阶乘 n! = 1 × 2 × 3 × ... × n
def factorial(n):
    """计算n的阶乘"""
    if n < 0:
        raise ValueError("阶乘只对非负整数定义")
    if n == 0:
        return 1
    return reduce(operator.mul, range(1, n + 1))

for n in range(11):
    print(f"{n}! = {factorial(n)}")
# 0! = 1
# 1! = 1
# 2! = 2
# ...
# 10! = 3628800

# 最大公约数（GCD）
import math
def gcd_of_list(numbers):
    """计算列表中所有数的最大公约数"""
    if not numbers:
        raise ValueError("列表不能为空")
    return reduce(math.gcd, numbers)

print(gcd_of_list([48, 64, 96]))    # 16
print(gcd_of_list([100, 75, 25]))   # 25
print(gcd_of_list([17, 31]))        # 1（互质）

# 最小公倍数（LCM）
def lcm_of_list(numbers):
    """计算列表中所有数的最小公倍数"""
    if not numbers:
        raise ValueError("列表不能为空")
    return reduce(math.lcm, numbers)  # Python 3.9+

print(lcm_of_list([4, 6, 8]))   # 24

from functools import reduce

# 💡 reduce可以模拟map
def my_map(func, iterable):
    """用reduce实现map"""
    return reduce(
        lambda acc, item: acc + [func(item)],
        iterable,
        []  # 初始值：空列表
    )

result = my_map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(result)  # [1, 4, 9, 16, 25]

# 💡 reduce可以模拟filter
def my_filter(func, iterable):
    """用reduce实现filter"""
    return reduce(
        lambda acc, item: acc + [item] if func(item) else acc,
        iterable,
        []
    )

result = my_filter(lambda x: x % 2 == 0, range(1, 11))
print(result)  # [2, 4, 6, 8, 10]

# ⚠️ 但实际开发中不要这样用——直接用map()和filter()或列表推导式
# 这只是用来帮助理解reduce的能力

from functools import reduce

# 定义一系列数据处理函数
def remove_none(data):
    """移除None值"""
    return [x for x in data if x is not None]

def convert_to_int(data):
    """转为整数"""
    return [int(x) for x in data]

def filter_positive(data):
    """只保留正数"""
    return [x for x in data if x > 0]

def multiply_by(data, factor):
    """乘以因子"""
    return [x * factor for x in data]

# 用reduce链式应用这些处理
pipeline = [
    remove_none,
    convert_to_int,
    filter_positive,
    lambda data: multiply_by(data, 2),
]

raw_data = ["1", None, "3", "-2", "5", None, "0", "8"]
result = reduce(lambda data, step: step(data), pipeline, raw_data)
print(result)  # [2, 6, 10, 16]

# 解释：data经过pipeline的每一层转换
# raw_data = ["1", None, "3", "-2", "5", None, "0", "8"]
# → remove_none: ["1", "3", "-2", "5", "0", "8"]
# → convert_to_int: [1, 3, -2, 5, 0, 8]
# → filter_positive: [1, 3, 5, 8]
# → multiply_by(×2): [2, 6, 10, 16]

from functools import reduce

# 合并多个字典（后面的覆盖前面的）
dicts = [
    {"host": "localhost", "port": 8080},
    {"port": 9090, "debug": True},           # port覆盖前面的
    {"timeout": 30, "retries": 3},
]

merged = reduce(lambda a, b: {**a, **b}, dicts)
print(merged)
# {'host': 'localhost', 'port': 9090, 'debug': True, 'timeout': 30, 'retries': 3}

# 深度合并（嵌套字典也合并）
configs = [
    {"database": {"host": "localhost", "port": 5432}, "debug": False},
    {"database": {"port": 5433, "name": "mydb"}, "cache": True},
    {"debug": True, "timeout": 30},
]

def deep_merge(a, b):
    """深度合并两个字典"""
    result = dict(a)
    for key, value in b.items():
        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
            result[key] = deep_merge(result[key], value)
        else:
            result[key] = value
    return result

final_config = reduce(deep_merge, configs, {})
print(final_config)
# {'database': {'host': 'localhost', 'port': 5433, 'name': 'mydb'},
#  'debug': True, 'cache': True, 'timeout': 30}

from functools import reduce
import operator

# reduce vs 内置函数（能用内置就用内置）
numbers = [1, 2, 3, 4, 5]

# reduce求和
total1 = reduce(operator.add, numbers)  # 15
# 内置sum()求和——更好
total2 = sum(numbers)  # 15

# reduce求积
product1 = reduce(operator.mul, numbers)  # 120
# Python 3.8+ math.prod()——更好
import math
product2 = math.prod(numbers)  # 120

# reduce找最值
max1 = reduce(lambda a, b: a if a > b else b, numbers)  # 5
max2 = max(numbers)  # 5 —— 更好

# reduce拼接字符串
words = ["a", "b", "c"]
concat1 = reduce(lambda a, b: a + b, words)  # "abc"
concat2 = "".join(words)  # "abc" —— 更好

# 💡 经验法则：
# - 有内置函数 → 用内置函数
# - 简单聚合 → 用内置函数或for循环
# - 复杂聚合逻辑 → reduce()
# - reduce让代码变难读 → 用for循环重写