返回列表的乘积

Question

有没有更简洁、高效或者更符合Python风格的方法来做以下事情呢？

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

---

经过一些测试，我发现这个方法比使用 operator.mul 稍微快一点：

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

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

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

def forloop(lst):
    r = 1
    for x in lst:
        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 functools import reduce

a = [1, 2, 3]
reduce(lambda x, y: x * y, a, 1)

Answer 2

从 Python 3.8 开始，标准库的 math 模块里新增了一个 prod 函数：

math.prod(iterable, *, start=1)

这个函数会返回一个值，它是 start 值（默认是 1）和一组数字的乘积：

import math

math.prod([2, 3, 4]) # 24

需要注意的是，如果这组数字是空的，那么结果会是 1（或者如果你提供了 start 值，那就返回这个值）。

Answer 3

不使用lambda表达式：

from operator import mul
# from functools import reduce # python3 compatibility
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.array作为数据结构，np.prod是最快的（对于小数组快18倍，对于大数组快250倍）

在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会更慢吗？