使用reduce缩短for循环

Question

From an array Ns , I'd like to derive an array multipliers as follows:

Ns = [3, 3, 6, 3]

multipliers = [0]*len(Ns)
multipliers[0] = 1
for n in range(1,len(Ns)):
    multipliers[n] = multipliers[n-1] * Ns[n-1]

The resulting array multipliers is [1, 3, 9, 54] . My gut feeling is that it should be possible to make this code more succinct using reduce or another built-in function, but I don't yet see how. Any ideas?

Answer 1

You could use itertools.accumulate with a custom accumulation function (Python 3 only, if you want to use Python 2 you could install fn.py library (or similar) or backport the function using the implementation provided in the docs) :

In [10]: from itertools import accumulate

In [11]: import operator

In [12]: list(accumulate([3, 3, 6, 3], func=operator.mul))
Out[12]: [3, 9, 54, 162]

And then just fix the first and the last elements:

In [13]: l = list(accumulate([3, 3, 6, 3], func=operator.mul))

In [14]: [1] + l[:-1]
Out[14]: [1, 3, 9, 54]

Answer 2

You can simulate the behavior of accumulate (see @soon's answer) in Python 2 with reduce . You have to manage the list by yourself.

from functools import reduce
Ns = [3, 3, 6, 3]
multipliers = reduce(lambda l, x: l + [l[-1] * x], Ns[:-1], [1])

Answer 3

reduce give you just the final result of the reducing process, so if you want all the intermediate values you can use list comprehension as followed:

>>> [reduce(lambda x,y:x*y, Ns[:i], 1) for i in range(len(Ns))]
[1, 3, 9, 54]

but that isn't efficient since it reducing again and again for each sublist.

Answer 4

As my comment and other answers mention, this is easy in Python 3, using itertools.accumulate . However, from your previous questions it appears that you're using Python 2.

In Python, it's almost always better to iterate directly over a list rather than using indices. Your code could be rewritten like this. (I've changed your list name to ns to comply with the PEP 8 style guide ).

ns = [3, 3, 6, 3]
multipliers = []
last = 1
for u in ns:
    multipliers.append(last)
    last *= u
print multipliers

output

[1, 3, 9, 54]

Note that this code does an extra multiplication at the end, the result of which doesn't get appended to multipliers . Here's an alternative that's a little more compact. Instead of using the last variable it looks up the last element in multipliers , which is slightly less efficient, and while it doesn't do that extra multiplication it does need to create a new list when it slices ns .

ns = [3, 3, 6, 3]
multipliers = [1]
for u in ns[:-1]:
    multipliers.append(u * multipliers[-1])
print multipliers