与函数式编程中的“折叠”函数等效的“pythonic”是什么？

Question

在 Haskell 中实现以下目标的最惯用方法是什么：

foldl (+) 0 [1,2,3,4,5]
--> 15

或者它在 Ruby 中的等价物：

[1,2,3,4,5].inject(0) {|m,x| m + x}
#> 15

显然，Python 提供了 reduce 函数，它是 fold 的一个实现，与上面完全相同，但是，我被告知“pythonic”的编程方式是避免 lambda 术语和高阶函数，在可能的情况下更喜欢列表理解。因此，在 Python 中是否有一种折叠列表或类似列表的结构的首选方法，它不是 reduce 函数，还是 reduce 是实现此目的的惯用方式？

Answer 1

对数组求和的 Pythonic 方法是使用 sum。出于其他目的，您有时可以使用reduce（来自functools 模块）和operator 模块的某种组合，例如：

def product(xs):
    return reduce(operator.mul, xs, 1)

请注意，reduce 实际上是 foldl，在 Haskell 术语中。没有特殊的语法来执行折叠，没有内置的foldr，实际上将reduce 与非关联运算符一起使用被认为是不好的风格。

使用高阶函数是相当 Pythonic 的；它很好地利用了 Python 的一切都是对象的原则，包括函数和类。你说得对，一些 Python 爱好者不赞成 lambda，但主要是因为当它们变得复杂时，它们往往不太可读。

Answer 2

从Python 3.8 开始，并引入assignment expressions (PEP 572)（:= 运算符），它提供了命名表达式结果的可能性，我们可以使用列表推导来复制其他语言所说的 fold/foldleft/减少操作：

给定一个列表、一个归约函数和一个累加器：

items = [1, 2, 3, 4, 5]
f = lambda acc, x: acc * x
accumulator = 1

我们可以将items 与f 折叠以获得结果accumulation：

[accumulator := f(accumulator, x) for x in items]
# accumulator = 120

---

或以压缩形式：

acc = 1; [acc := acc * x for x in [1, 2, 3, 4, 5]]
# acc = 120

---

请注意，这实际上也是一个“scanleft”操作，因为列表推导的结果代表了每一步累积的状态：

acc = 1
scanned = [acc := acc * x for x in [1, 2, 3, 4, 5]]
# scanned = [1, 2, 6, 24, 120]
# acc = 120

Answer 3

哈斯克尔

foldl (+) 0 [1,2,3,4,5]

Python

reduce(lambda a,b: a+b, [1,2,3,4,5], 0)

显然，这是一个简单的例子来说明一个观点。在 Python 中，您只需使用 sum([1,2,3,4,5])，甚至 Haskell 纯粹主义者通常更喜欢 sum [1,2,3,4,5]。

对于没有明显便利功能的非平凡场景，惯用的pythonic方法是显式写出for循环并使用可变变量赋值，而不是使用reduce或fold。

这根本不是函数式风格，而是“pythonic”方式。 Python 不是为功能纯粹主义者设计的。了解 Python 如何支持流控制的异常以了解非功能性惯用 Python 的表现。

Answer 4

在 Python 3 中，reduce 已被删除：Release notes。不过你可以使用functools module

import operator, functools
def product(xs):
    return functools.reduce(operator.mul, xs, 1)

另一方面，文档表达了对for-loop 而非reduce 的偏好，因此：

def product(xs):
    result = 1
    for i in xs:
        result *= i
    return result

Answer 5

不是真正回答这个问题，而是 foldl 和 foldr 的单行：

a = [8,3,4]

## Foldl
reduce(lambda x,y: x**y, a)
#68719476736

## Foldr
reduce(lambda x,y: y**x, a[::-1])
#14134776518227074636666380005943348126619871175004951664972849610340958208L

Answer 6

你也可以重新发明轮子：

def fold(f, l, a):
    """
    f: the function to apply
    l: the list to fold
    a: the accumulator, who is also the 'zero' on the first call
    """ 
    return a if(len(l) == 0) else fold(f, l[1:], f(a, l[0]))

print "Sum:", fold(lambda x, y : x+y, [1,2,3,4,5], 0)

print "Any:", fold(lambda x, y : x or y, [False, True, False], False)

print "All:", fold(lambda x, y : x and y, [False, True, False], True)

# Prove that result can be of a different type of the list's elements
print "Count(x==True):", 
print fold(lambda x, y : x+1 if(y) else x, [False, True, True], 0)

Answer 7

这个（减少）问题的实际答案是：只需使用循环！

initial_value = 0
for x in the_list:
    initial_value += x #or any function.

这将比 reduce 更快，并且 PyPy 之类的东西可以优化这样的循环。

顺便说一句，求和的情况应该用sum函数解决

Answer 8

我相信这个问题的一些受访者忽略了 fold 函数作为抽象工具的更广泛含义。是的，sum 可以对整数列表做同样的事情，但这是一个小例子。 fold 更通用。当您拥有一系列不同形状的数据结构并希望清晰地表达聚合时，它很有用。因此，不必每次都使用聚合变量构建for 循环并手动重新计算它，fold 函数（或reduce 似乎对应的 Python 版本）允许程序员表达意图通过简单地提供两件事来更清楚地了解聚合：

• 聚合的默认起始值​​或“种子”值。
• 一个函数，它获取聚合的当前值（以“种子”开头）和列表中的下一个元素，并返回下一个聚合值。