返回列表的产品

Question

是否有更简洁，高效或简单的pythonic方式来执行以下操作？

def product(list): 
    p = 1 
    for i in list: 
     p *= i 
    return p 

编辑：

其实我觉得这是略高于使用operator.mul快：

from operator import mul 
# from functools import reduce # python3 compatibility 

def with_lambda(list): 
    reduce(lambda x, y: x * y, list) 

def without_lambda(list): 
    reduce(mul, list) 

def forloop(list): 
    r = 1 
    for x in list: 
     r *= x 
    return r 

import timeit 

a = range(50) 
b = range(1,50)#no zero 
t = timeit.Timer("with_lambda(a)", "from __main__ import with_lambda,a") 
print("with lambda:", t.timeit()) 
t = timeit.Timer("without_lambda(a)", "from __main__ import without_lambda,a") 
print("without lambda:", t.timeit()) 
t = timeit.Timer("forloop(a)", "from __main__ import forloop,a") 
print("for loop:", t.timeit()) 

t = timeit.Timer("with_lambda(b)", "from __main__ import with_lambda,b") 
print("with lambda (no 0):", t.timeit()) 
t = timeit.Timer("without_lambda(b)", "from __main__ import without_lambda,b") 
print("without lambda (no 0):", t.timeit()) 
t = timeit.Timer("forloop(b)", "from __main__ import forloop,b") 
print("for loop (no 0):", t.timeit()) 

给我

('with lambda:', 17.755449056625366) 
('without lambda:', 8.2084708213806152) 
('for loop:', 7.4836349487304688) 
('with lambda (no 0):', 22.570688009262085) 
('without lambda (no 0):', 12.472226858139038) 
('for loop (no 0):', 11.04065990447998) 

Answer 1

不使用拉姆达：

from operator import mul 
reduce(mul, list, 1) 

它更好更快。与Python 2.7.5

from operator import mul 
import numpy as np 
import numexpr as ne 
# from functools import reduce # python3 compatibility 

a = range(1, 101) 
%timeit reduce(lambda x, y: x * y, a) # (1) 
%timeit reduce(mul, a)     # (2) 
%timeit np.prod(a)      # (3) 
%timeit ne.evaluate("prod(a)")   # (4) 

在以下配置：

a = range(1, 101) # A 
a = np.array(a) # B 
a = np.arange(1, 1e4, dtype=int) #C 
a = np.arange(1, 1e5, dtype=float) #D 

结果与Python 2.7.5

 

     |  1  |  2  |  3  |  4  | 
-------+-----------+-----------+-----------+-----------+ 
A  20.8 µs  13.3 µs  22.6 µs  39.6 µs  
B  106 µs  95.3 µs  5.92 µs  26.1 µs 
C  4.34 ms  3.51 ms  16.7 µs  38.9 µs 
D  46.6 ms  38.5 ms  180 µs  216 µs 

结果：np.prod是最快的国家之一，如果你使用np.array为数据结构（小阵列为18x，大阵列为250x）

机智h python 3.3.2：

 

     |  1  |  2  |  3  |  4  | 
-------+-----------+-----------+-----------+-----------+ 
A  23.6 µs  12.3 µs  68.6 µs  84.9 µs  
B  133 µs  107 µs  7.42 µs  27.5 µs 
C  4.79 ms  3.74 ms  18.6 µs  40.9 µs 
D  48.4 ms  36.8 ms  187 µs  214 µs 

python 3是否比较慢？

Answer 2

reduce(lambda x, y: x * y, list, 1) 

Answer 3

import operator 
reduce(operator.mul, list, 1) 

Answer 4

我记得在comp.lang.python上一些长期讨论（抱歉，懒得现在产生指针）得出的结论是你原来product()定义是最Python化。

请注意，建议不要在每次要写入for循环时编写for循环，而要编写一次函数（每种减少类型）并根据需要调用它！减少调用函数是非常Python的 - 它与发电机表情甜蜜地工作，而且由于SUCESSFUL引进sum()，Python会越来越大，越来越内建功能降低 - any()和all()是最新加入...

这一结论是有点儿官方 - reduce()来自内建removed在Python 3.0，他说：

“使用functools.reduce()如果你真的需要它;然而，时间明确的for循环99％更具有可读性。”

另请参阅The fate of reduce() in Python 3000以获得Guido的支持报价（以及一些Lispers支持阅读该博客的支持评论）。

P.S.如果碰巧你需要组合product()，请参阅math.factorial()（新2.6）。

Answer 5

此答案的目的是提供一种计算即在某些情况下有用的 - 即当一个）有乘以大量的值，使得最终产品可以是非常大或非常小，和b ），你真的不关心确切的答案，而是有一个数列，并希望能够根据每个人的产品进行排序。

如果要乘一个列表，其中L为列表中的元素，你可以这样做：

import math 
math.exp(sum(map(math.log, l))) 

现在，这种方法并不像

from operator import mul 
reduce(mul, list) 

的可读性如果您对于一个不熟悉reduce（）的数学家来说可能是正确的，但我不建议在正常情况下使用它。它也比问题中提到的product（）函数更不可读（至少对非数学家来说）。

但是，如果你在一个情况是永远在那里，你的风险溢或上溢，如

>>> reduce(mul, [10.]*309) 
inf 

，你的目的是比较不同序列的产品，而不是知道产品是什么，然后

>>> sum(map(math.log, [10.]*309)) 
711.49879373515785 

是去，因为它几乎不可能有实际问题中，你会溢出或下溢本办法的办法。 （该计算的结果是越大，产品的是，如果你可以计算。）

Answer 6

，如果你只是在你的列表编号：

from numpy import prod 
prod(list) 

编辑：如通过@指出off99555这对于大整数结果在这种情况下，它返回而基于operator.mul和reduce作品大整数结果伊恩Clelland的解决方案，因为它返回longnumpy.int64类型的结果是行不通的。

Answer 7

这也适用，虽然它的欺骗

def factorial(n): 
    x=[] 
    if n <= 1: 
     return 1 
    else: 
     for i in range(1,n+1): 
      p*=i 
      x.append(p) 
     print x[n-1]  

Answer 8

那么，如果你真的想使一行没有进口任何物件，你可以这样做：

eval('*'.join(str(item) for item in list)) 

但是不要。

Answer 9

我很惊讶，没有人使用了与itertools.accumulate建议operator.mul。这避免了使用reduce，这对于Python 2和3个不同的（由于用于Python 3所需的functools进口），并且此外被认为是未Python化by Guido van Rossum himself：

from itertools import accumulate 
from operator import mul 

def prod(lst): 
    for value in accumulate(lst, mul): 
     pass 
    return value 

实施例：

prod([1,5,4,3,5,6]) 
# 1800