Python 的 reduce()：从函数式到 Pythonic 风格

所需的参数：function和iterable

Python 的第一个参数reduce()是一个双参数函数，方便地称为function. 此函数将应用于迭代中的项目以累积计算最终值。

尽管官方文档将 的第一个参数reduce()称为“具有两个参数的函数”，但您可以传递任何 Python 可调用对象，reduce()只要该可调用对象接受两个参数即可。可调用对象包括类、实现称为 的特殊方法的__call__()实例、实例方法、类方法、静态方法和函数。

iterable顾名思义，第二个必需参数将接受任何 Python 可迭代对象。这包括列表、元组、range对象、生成器、迭代器、集合、字典键和值，以及您可以迭代的任何其他 Python 对象。

要了解如何reduce()工作，你会写，计算两者之和功能的数字和打印相当于数学运算到屏幕上。这是代码：

>>> def my_add(a, b):
...     result = a + b
...     print(f"{a} + {b} = {result}")
...     return result

此函数计算aand的总和，b使用f-string打印带有操作的消息，并返回计算结果。这是它的工作原理：

>>> my_add(5, 5)
5 + 5 = 10
10

my_add()是一个双参数函数，因此您可以将它reduce()与可迭代对象一起传递给 Python ，以计算可迭代对象中各项的累积总和。查看以下使用数字列表的代码：

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce(my_add, numbers)
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

当您调用reduce()、传递my_add()和numbers作为参数时，您会得到一个输出，其中显示了reduce()为得出最终结果而执行的所有操作10。在这种情况下，操作等效于((((0 + 1) + 2) + 3) + 4) = 10。

上例中的 调用reduce()适用my_add()于numbers(0和1) 中的前两项，并1作为结果获取。然后reduce()调用my_add()using1和numbers（即2）中的下一项作为参数，得到3结果。重复该过程，直到numbers用完项目并reduce()返回 的最终结果10。

使用 Python 减少可迭代对象 reduce()

到目前为止，您已经了解了 Python 的reduce()工作原理以及如何使用它来减少使用用户定义函数的可迭代对象。您还了解了每个参数的含义reduce()以及它们的工作原理。

在本节中，您将了解一些常见用例reduce()以及如何使用该函数解决它们。您还将了解一些可替代的 Python 工具，您可以使用它们reduce()来使您的代码更加 Python 化、高效和可读。

>>> numbers = [1, 2, 3, 4]
>>> total = 0
>>> for num in numbers:
...     total += num
...
>>> total
10

>>> def my_add(a, b):
...     return a + b
...

>>> my_add(1, 2)
3

>>> from functools import reduce

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

>>> reduce(my_add, numbers)
10

>>> from functools import reduce

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

>>> reduce(lambda a, b: a + b, numbers)
10

>>> from operator import add
>>> from functools import reduce

>>> add(1, 2)
3

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

>>> reduce(add, numbers)
10

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

>>> sum(numbers)
10

寻找最小值和最大值

在可迭代对象中找到最小值和最大值的问题也是一个归约问题，您可以使用 Python 的reduce(). 这个想法是比较迭代中的项目以找到最小值或最大值。

假设您有数字列表[3, 5, 2, 4, 7, 1]。在此列表中，最小值为1，最大值为7。要查找这些值，您可以使用 Pythonfor循环。查看以下代码：

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

>>> # Minimum
>>> min_value, *rest = numbers
>>> for num in rest:
...     if num < min_value:
...         min_value = num
...
>>> min_value
1

>>> # Maximum
>>> max_value, *rest = numbers
>>> for num in rest:
...     if num > max_value:
...         max_value = num
...
>>> max_value
7

两个循环都迭代 in 中的项目rest并根据连续比较的结果更新min_value或的值max_value。请注意，最初min_value并max_value保持数字3，它是 中的第一个值numbers。该变量rest将剩余的值保存在numbers. 换句话说，rest = [5, 2, 4, 7, 1]。

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

>>> min_value, *rest = numbers
>>> min_value
3
>>> rest
[5, 2, 4, 7, 1]

>>> max_value, *rest = numbers
>>> max_value
3
>>> rest
[5, 2, 4, 7, 1]

现在，考虑如何使用 Python 的reduce(). 同样，您可以lambda根据需要使用用户定义的函数或函数。

以下代码实现了一个使用两个不同用户定义函数的解决方案。第一个函数将接受两个参数a和b，并返回它们的最小值。第二个函数将使用类似的过程，但它会返回最大值。

以下是函数以及如何将它们与 Pythonreduce()一起使用以查找可迭代对象中的最小值和最大值：

>>> from functools import reduce

>>> # Minimum
>>> def my_min_func(a, b):
...     return a if a < b else b
...

>>> # Maximum
>>> def my_max_func(a, b):
...     return a if a > b else b
...

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

>>> reduce(my_min_func, numbers)
1

>>> reduce(my_max_func, numbers)
7

当您reduce()使用my_min_func()和运行时my_max_func()，您将numbers分别获得 中的最小值和最大值。reduce()迭代 的项numbers，按累积对比较它们，最后返回最小值或最大值。

您还可以使用lambda函数来解决最小值和最大值问题。看看下面的例子：

>>> from functools import reduce

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

>>> # Minimum
>>> reduce(lambda a, b: a if a < b else b, numbers)
1

>>> # Maximum
>>> reduce(lambda a, b: a if a > b else b, numbers)
7

这一次，您使用两个lambda函数来确定 ifa小于或大于b。在这种情况下，Pythonreduce()将lambda函数应用于 中的每个值numbers，并将其与先前计算的结果进行比较。在过程结束时，您将获得最小值或最大值。

最小和最大问题在编程中非常普遍，以至于 Python 添加了内置函数来执行这些缩减。这些函数被方便地称为min()and max()，您无需导入任何内容即可使用它们。以下是它们的工作原理：

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

>>> min(numbers)
1

>>> max(numbers)
7

当您使用min()andmax()查找可迭代对象中的最小和最大项时，与使用 Python 的reduce(). 此外，由于min()和max()是高度优化的 C 函数，您也可以说您的代码将更加高效。

所以，在 Python 中解决这个问题时，最好使用min()andmax()而不是reduce().

检查所有值是否为真

该全真用例Python的中reduce()涉及找出在是否所有的项目迭代是真实的。要解决这个问题，您可以reduce()与用户定义的函数或lambda函数一起使用。

您将首先编写一个for循环来确定迭代中的所有项目是否都为真。这是代码：

>>> def check_all_true(iterable):
...     for item in iterable:
...         if not item:
...             return False
...     return True
...

>>> check_all_true([1, 1, 1, 1, 1])
True

>>> check_all_true([1, 1, 1, 1, 0])
False

>>> check_all_true([])
True

如果 中的所有值iterable都为真，则check_all_true()返回True。否则，它返回False。它还返回True空的可迭代对象。check_all_true()实施短路评估。这意味着该函数会在不处理 中的其余项的情况下，在发现错误值时立即返回iterable。

要使用 Python 的 解决这个问题reduce()，您需要编写一个函数，该函数接受两个参数并True在两个参数都为真时返回。如果一个或两个参数为假，则函数将返回False。这是代码：

>>> def both_true(a, b):
...     return bool(a and b)
...

>>> both_true(1, 1)
True

>>> both_true(1, 0)
False

>>> both_true(0, 0)
False

这个函数有两个参数，a和b。然后您使用and运算符来测试两个参数是否都为真。True如果两个参数都为真，则返回值。否则，它将是False。

在 Python 中，以下对象被认为是 false：

• 像None和这样的常数False
• 数值类型与零值一样0，0.0，0j，Decimal(0)，和Fraction(0, 1)
• 空序列和收藏喜欢""，()，[]，{}，set()，和range(0)
• 实现物体__bool__()与返回值False或__len__()与返回值0

任何其他对象都将被视为真实。

您需要使用bool()将 的返回值and转换为True或False。如果您不使用bool()，那么您的函数将不会按预期运行，因为and返回表达式中的对象之一而不是Trueor False。查看以下示例：

>>> a = 0
>>> b = 1
>>> a and b
0

>>> a = 1
>>> b = 2
>>> a and b
2

and如果为假，则返回表达式中的第一个值。否则，无论其真值如何，它都会返回表达式中的最后一个值。这就是为什么你需要bool()在这种情况下使用。bool()返回由计算布尔表达式或对象产生的布尔值（True或False）。使用bool()以下方法查看示例：

>>> a = 0
>>> b = 1
>>> bool(a and b)
False

>>> a = 1
>>> b = 2
>>> bool(a and b)
True

bool()将始终返回True或False在评估手头的表达式或对象之后返回。

您可以通过both_true()toreduce()检查迭代的所有项目是否为真。这是它的工作原理：

>>> from functools import reduce

>>> reduce(both_true, [1, 1, 1, 1, 1])
True

>>> reduce(both_true, [1, 1, 1, 1, 0])
False

>>> reduce(both_true, [], True)
True

如果您将both_true()参数作为参数传递给reduce()，那么您将得到True可迭代对象中的所有项目是否为真。否则，你会得到False.

在第三个示例中，您传递True给initializerofreduce()以获得与 a 相同的行为check_all_true()并避免 a TypeError。

您还可以使用lambda函数来解决reduce(). 这里有些例子：

>>> from functools import reduce

>>> reduce(lambda a, b: bool(a and b), [0, 0, 1, 0, 0])
False

>>> reduce(lambda a, b: bool(a and b), [1, 1, 1, 2, 1])
True

>>> reduce(lambda a, b: bool(a and b), [], True)
True

此lambda函数与both_true()返回值非常相似并使用相同的表达式。True如果两个参数都为真，则返回。否则，它返回False。

请注意，与 不同check_all_true()，当您用于reduce()解决全真用例时，没有短路评估，因为reduce()在遍历整个可迭代对象之前不会返回。这会给您的代码增加额外的处理时间。

例如，假设您有一个列表lst = [1, 0, 2, 0, 0, 1]，您需要检查其中的所有项目lst是否为真。在这种情况下，check_all_true()将在其循环处理第一对项目（1和0）后立即结束，因为它0为假。您不需要继续迭代，因为您手头的问题已经有了答案。

另一方面，reduce()解决方案在处理完lst. 那是五次迭代之后。现在想象一下，如果您正在处理一个大型可迭代对象，这会对您的代码性能产生什么影响！

幸运的是，Python 提供了正确的工具，可以以 Python 风格、可读且高效的方式解决全真问题：内置函数all()。

您可以使用all(iterable)来检查中的所有项目iterable是否为真。以下是all()工作原理：

>>> all([1, 1, 1, 1, 1])
True

>>> all([1, 1, 1, 0, 1])
False

>>> all([])
True

all()循环遍历迭代中的项目，检查每个项目的真值。如果all()发现错误的项目，则返回False。否则，它返回True。如果您all()使用空的可迭代对象调用，那么您会得到，True因为空的可迭代对象中没有错误的项目。

all()是针对性能进行了优化的 C 函数。此功能也使用短路评估来实现。因此，如果您正在处理 Python 中的全真问题，那么您应该考虑使用all()而不是reduce().

比较reduce()和accumulate()

一个Python函数调用accumulate()中的生活itertools和行为方式类似reduce()。accumulate(iterable[, func])接受一个必需的参数 ，iterable它可以是任何 Python 可迭代的。可选的第二个参数func需要是一个函数（或一个可调用对象），它接受两个参数并返回一个值。

accumulate()返回一个迭代器。此迭代器中的每一项都将是func执行计算的累积结果。默认计算是总和。如果您不向 提供函数accumulate()，则结果迭代器中的每一项都将是前iterable一项加上手头项的累加和。

查看以下示例：

>>> from itertools import accumulate
>>> from operator import add
>>> from functools import reduce

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

>>> list(accumulate(numbers))
[1, 3, 6, 10]

>>> reduce(add, numbers)
10

请注意，结果迭代器中的最后一个值与reduce()返回的值相同。这是这两个函数之间的主要相似之处。

如果，另一方面，您提供的两个参数的函数（或可调用）到func的参数accumulate()中所产生的，那么项目的迭代器将累加结果的计算由执行func。这是一个使用的示例operator.mul()：

>>> from itertools import accumulate
>>> from operator import mul
>>> from functools import reduce

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

>>> list(accumulate(numbers, mul))
[1, 2, 6, 24]

>>> reduce(mul, numbers)
24

在此示例中，您可以再次看到 的返回值中的最后一项accumulate()等于 返回的值reduce()。

考虑性能和可读性

Python 的reduce()性能可能非常糟糕，因为它通过多次调用函数来工作。这会使您的代码变慢且效率低下。使用reduce()时，用复杂的用户定义的函数或使用但也容易影响你的代码的可读性lambda功能。

在本教程中，您已经了解到 Python 提供了一堆可以优雅地替换 的工具，reduce()至少对于它的主要用例是这样。到目前为止，以下是您阅读的主要内容：

1. reduce()尽可能使用专用函数来解决 Python 的用例。sum(), all(), any(), max(), min(), len(), math.prod(), 等函数将使您的代码更快、更易读、更易于维护和Pythonic。

2. 避免复杂的用户定义的函数使用时reduce()。这些类型的函数会使您的代码难以阅读和理解。您可以改用显式且可读的for循环。

3. lambda使用时避免复杂的函数reduce()。它们还可能使您的代码不可读和令人困惑。

第二点和第三点是圭多自己在说以下内容时的担忧：

所以现在reduce()。这实际上是我一直最讨厌的一个，因为除了几个涉及+or 的例子*，几乎每次我看到一个reduce()带有非平凡函数参数的调用时，我都需要拿起笔和纸来绘制实际被喂食的内容在我理解应该做什么之前进入该功能reduce()。所以在我看来， 的适用性reduce()几乎仅限于关联运算符，在所有其他情况下，最好明确写出累加循环。（来源）

接下来的两节将帮助您在代码中实现这一一般建议。他们还提供了一些额外的建议，可以帮助您reduce()在真正需要使用 Python 时有效地使用它。

>>> from functools import reduce
>>> from timeit import timeit

>>> # Using a user-defined function
>>> def add(a, b):
...     return a + b
...
>>> use_add = "functools.reduce(add, range(100))"
>>> timeit(use_add, "import functools", globals={"add": add})
13.443158069014316

>>> # Using a lambda expression
>>> use_lambda = "functools.reduce(lambda x, y: x + y, range(100))"
>>> timeit(use_lambda, "import functools")
11.998800784000196

>>> # Using operator.add()
>>> use_operator_add = "functools.reduce(operator.add, range(100))"
>>> timeit(use_operator_add, "import functools, operator")
5.183870767941698

>>> # Using sum()
>>> timeit("sum(range(100))", globals={"sum": sum})
1.1643308430211619

结论

Pythonreduce()允许您使用 Python 可调用对象和lambda函数对可迭代对象执行归约操作。reduce()将函数应用于迭代中的项目并将它们减少到单个累积值。

在本教程中，您学习了：

• 什么是缩减或折叠，以及何时可能有用
• 如何使用 Pythonreduce()解决常见的归约问题，例如数字求和或乘法
• 您可以使用哪些Pythonic 工具来有效地替换reduce()您的代码

有了这些知识，在解决 Python 中的归约问题时，您将能够决定哪些工具最适合您的编码需求。

多年来，reduce()已被更多 Pythonic 工具所取代，例如sum()、min()、max() all()、any()等。然而，reduce()仍然存在并且仍然在函数式程序员中流行。如果您对使用reduce()Python 或其任何替代方案有任何疑问或想法，请务必在下面的评论中发布它们。