减少功能如何工作？

Question

据我了解，reduce 函数需要一个列表l 和一个函数f。然后，它在列表的前两个元素上调用函数f，然后用下一个列表元素和前一个结果重复调用函数f。

所以，我定义了以下函数：

以下函数计算阶乘。

def fact(n):
    if n == 0 or n == 1:
        return 1
    return fact(n-1) * n


def reduce_func(x,y):
    return fact(x) * fact(y)

lst = [1, 3, 1]
print reduce(reduce_func, lst)

现在，这不应该给我((1! * 3!) * 1!) = 6吗？但是，它却给出了720。为什么720？它似乎也采用了6 的阶乘。但是，我需要了解原因。

有人可以解释为什么会发生这种情况以及解决方法吗？

我基本上想计算列表中所有条目的阶乘乘积。 备份计划是运行一个循环并计算它。但是，我更喜欢使用 reduce。

Answer 1

其他答案很棒。我将简单地添加一个我觉得很好理解的图解示例reduce()：

>>> reduce(lambda x,y: x+y, [47,11,42,13])
113

将按如下方式计算：

(Source) (mirror)

Answer 2

理解 reduce() 的最简单方法是查看其纯 Python 等效代码：

def myreduce(func, iterable, start=None):
    it = iter(iterable)
    if start is None:
        try:
            start = next(it)
        except StopIteration:
            raise TypeError('reduce() of empty sequence with no initial value')
    accum_value = start
    for x in iterable:
        accum_value = func(accum_value, x)
    return accum_value

您可以看到只有 reduce_func() 将阶乘应用于最右边的参数才有意义：

def fact(n):
    if n == 0 or n == 1:
        return 1
    return fact(n-1) * n

def reduce_func(x,y):
    return x * fact(y)

lst = [1, 3, 1]
print reduce(reduce_func, lst)

通过这个小修改，代码会产生 6 如您所料:-)

Answer 3

您的函数在两个参数上调用fact()。您正在计算((1! * 3!)! * 1!)。解决方法是仅在第二个参数上调用它，并将初始值 1 传递给 reduce()。

Answer 4

来自Python reduce documentation，

reduce(function, sequence) 返回一个单个值，该值是通过对序列的前两项、结果和下一项调用 (binary) 函数构造的，以此类推。

所以，一步一步。它计算前两个元素reduce_func(1, 3) = 1! * 3! = 6 的reduce_func。然后，它计算结果的reduce_func 和下一项：reduce_func(6, 1) = 6! * 1! = 720。

您错过了，当第一个 reduce_func 调用的结果作为输入传递给第二个时，它在乘法之前被分解。

Answer 5

好的，明白了：

我需要先将数字映射到它们的阶乘，然后使用乘法运算符调用 reduce。

所以，这会起作用：

lst_fact = map(fact, lst)
reduce(operator.mul, lst_fact)

Answer 6

你也可以使用reduce来实现阶乘。

def factorial(n):
  return(reduce(lambda x,y:x*y,range(n+1)[1:]))

Answer 7

除了一些琐碎的例子，我发现reduce 实际上非常有用：

想象一个可迭代的有序int 值，通常包含一些连续值，我们希望将其“总结”为表示范围的元组列表。 （还要注意，这个可迭代对象可能是一个非常长的序列的生成器——另一个使用 reduce 的原因，而不是对内存中集合的某些操作）。

from functools import reduce

def rle(a, b):
    if a and a[-1][1] == b:
        return a[:-1] + [(a[-1][0], b + 1)]
    return a + [(b, b + 1)]

reduce(rle, [0, 1, 2, 5, 8, 9], [])
# [(0, 3), (5, 6), (8, 10)]

注意对reduce 使用正确的initial 值（此处为[]）。

也处理了特殊情况：

reduce(rle, [], [])
# []

reduce(rle, [0], [])
# [(0, 1)]

Answer 8

首先，您的reduce_func 没有折叠结构；它与您对折叠的描述不符（这是正确的）。

折叠的结构是：def foldl(func, start, iter): return func(start, foldl(func, next(iter), iter)

现在，您的 fact 函数不对两个元素进行操作 - 它只是计算阶乘。

因此，总而言之，您没有使用折叠，并且根据阶乘的定义，您不需要。

如果您确实想使用阶乘，请查看 y-combinator：http://mvanier.livejournal.com/2897.html

如果您想了解折叠，请查看我对这个问题的回答，该回答演示了它用于计算累积分数：creating cumulative percentage from a dictionary of data

Answer 9

reduce通过参数#2中迭代器提供的值依次执行参数#1中的函数

print '-------------- Example: Reduce(x + y) --------------'

def add(x,y): return x+y
x = 5
y = 10

import functools
tot = functools.reduce(add, range(5, 10))
print 'reduce('+str(x)+','+str(y)+')=' ,tot

def myreduce(a,b):
    tot = 0
    for i in range(a,b):
        tot = tot+i
        print i,tot
    print 'myreduce('+str(a)+','+str(b)+')=' ,tot

myreduce(x,y)

print '-------------- Example: Reduce(x * y) --------------'

def add(x,y): return x*y
x = 5
y = 10

import functools
tot = functools.reduce(add, range(5, 10))
print 'reduce('+str(x)+','+str(y)+')=' ,tot

def myreduce(a,b):
    tot = 1
    for i in range(a,b):
        tot = tot * i
        print i,tot
    print 'myreduce('+str(a)+','+str(b)+')=' ,tot

myreduce(x,y)