在python中将整数列表的子集相乘

假设我有一个10个整数的列表，我想要前5个整数相乘的结果。有没有一种类似蟒蛇的方法？Python似乎非常适合列表：）

很多方法。这里有一个：

>>> a = range(1,10)
>>> reduce(lambda x,y: x*y, a[:5])
120

使用reduce： e、 g

>>> reduce(lambda x,y:x*y, range(1,5))
24

reduce（）

函数将给定函数（此处为乘法）应用于列表的前两项，从而将它们减少为一项。这样做直到列表中只有一项。此项作为结果返回。此符号源自函数式语言

在列表中迭代： e、 g,

---

这是在列表的所有项上聚合某些函数的最常用方法；这与Java或C的实现方式类似。

当有很多方法可以实现某项功能时，我会根据可读性或速度等标准来决定使用哪种代码。这里有一些代码表明

use\u loop

和

use\u reduce

在速度方面大致相同（至少对于测试的值是如此！）

import operator
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]

print reduce(operator.mul, [v for (k, v,) in enumerate(l) if k < 5])
>> 120

以下是计时结果：

% python -mtimeit -s"import test" "test.use_loop(test.a,50)"
10000 loops, best of 3: 16.1 usec per loop
% python -mtimeit -s"import test" "test.use_reduce(test.a,50)"
100000 loops, best of 3: 16.3 usec per loop
% python -mtimeit -s"import test" "test.use_islice_loop(test.a,50)"
10000 loops, best of 3: 19.6 usec per loop
% python -mtimeit -s"import test" "test.use_islice_reduce(test.a,50)"
10000 loops, best of 3: 19.2 usec per loop
% python -mtimeit -s"import test" "test.use_reduce_lambda(test.a,50)"
10000 loops, best of 3: 32.1 usec per loop

至少对于测试的

a

（1000）和

n

（50）的值，

itertools.islice

似乎对性能没有帮助

use\u reduce\u lambda

的速度明显慢于它的近亲

use\u reduce

，后者使用

operator.mul

。然而，导入操作员所需的时间不包括在测试中

由于

use\u loop

和

use\u reduce

似乎同样快，我建议使用

reduce

，因为它的短小、惯用的代码对于大多数python程序员来说应该是可读的。然而，在品味方面，我认为过于固执己见是不值得的。选择你最喜欢的，保持一致

---

PS.从Python 3+开始，

reduce

不再是一个内置函数，而是可以通过

functools访问。reduce

这是一个简单的函数，可以实现您想要的功能

def multiply(args):
    x= 1
    for arg in args:
       x*= arg
    return x

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]

multiply(l)
>>>362880
multiply(l[:5])
>>>120

---

为什么不减少（operator.mul，l[：5]）？？人们确实喜欢enumerate（）。是的。我在你发表评论时编辑了它。仍然习惯于“一切都是可以切片的”。愚蠢的PHP。

reduce（operator.mul，itertools.islice（l，5））

避免复制可能对足够大的切片有影响的列表。您还可以尝试使用

itertools.islice（a，n）

而不是

a[：n]

？对于n=50，似乎需要相同的时间，但当n大得多时，这将有助于看到这一点。

import operator
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]

print reduce(operator.mul, [v for (k, v,) in enumerate(l) if k < 5])
>> 120

print reduce(operator.mul, l[:5])
>> 120

import operator
import itertools

a=range(1,1000)
def use_loop(a,n):
    result=1
    for num in a[:n]:
        result*=num
    return result

def use_reduce(a,n):
    return reduce(operator.mul, a[:n])

def use_reduce_lambda(a,n):
    return reduce(lambda x,y: x*y, a[:n])

def use_islice_loop(a,n):
    result=1
    for num in itertools.islice(a,n):
        result*=num
    return result

def use_islice_reduce(a,n):
    return reduce(operator.mul, itertools.islice(a,n))

if __name__=='__main__':
    n=50
    print(use_loop(a,n))
    print(use_reduce(a,n))
    print(use_reduce_lambda(a,n))    
    print(use_islice_loop(a,n))
    print(use_islice_reduce(a,n))    

% python -mtimeit -s"import test" "test.use_loop(test.a,50)"
10000 loops, best of 3: 16.1 usec per loop
% python -mtimeit -s"import test" "test.use_reduce(test.a,50)"
100000 loops, best of 3: 16.3 usec per loop
% python -mtimeit -s"import test" "test.use_islice_loop(test.a,50)"
10000 loops, best of 3: 19.6 usec per loop
% python -mtimeit -s"import test" "test.use_islice_reduce(test.a,50)"
10000 loops, best of 3: 19.2 usec per loop
% python -mtimeit -s"import test" "test.use_reduce_lambda(test.a,50)"
10000 loops, best of 3: 32.1 usec per loop

def multiply(args):
    x= 1
    for arg in args:
       x*= arg
    return x

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]

multiply(l)
>>>362880
multiply(l[:5])
>>>120