返回列表的產品

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