如何用Python将列表中的所有项相乘?

你可以使用:

import operator
import functools
functools.reduce(operator.mul, [1,2,3,4,5,6], 1)

有关解释，请参阅reduce和operator.mul文档。

在Python 3+中需要import functools行。

Python 3:使用functools.reduce:

>>> from functools import reduce
>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720

Python 2:使用reduce:

>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720

为了兼容2和3，使用pip install six，那么:

>>> from six.moves import reduce
>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720

如果你想避免导入任何东西，避免Python中更复杂的部分，你可以使用一个简单的for循环

product = 1  # Don't use 0 here, otherwise, you'll get zero
# because anything times zero will be zero.
list = [1, 2, 3]
for x in list:
product *= x

我个人喜欢这样一个函数，它将泛型列表的所有元素相乘:

def multiply(n):
total = 1
for i in range(0, len(n)):
total *= n[i]
print total

它很紧凑，使用简单的东西(一个变量和一个for循环)，对我来说感觉很直观(它看起来像我想到的问题，只是取一个，乘以它，然后乘以下一个，等等!)

我将使用numpy.prod来执行任务。见下文。

import numpy as np
mylist = [1, 2, 3, 4, 5, 6]
result = np.prod(np.array(mylist))

我希望这样做:

    def product_list(p):
total =1 #critical step works for all list
for i in p:
total=total*i # this will ensure that each elements are multiplied by itself
return total
print product_list([2,3,4,2]) #should print 48

今天发现了这个问题，但我注意到它没有列表中有None的情况。所以，完整的解决方案是:

from functools import reduce


a = [None, 1, 2, 3, None, 4]
print(reduce(lambda x, y: (x if x else 1) * (y if y else 1), a))

在加法的情况下，我们有:

print(reduce(lambda x, y: (x if x else 0) + (y if y else 0), a))

nums = str(tuple([1,2,3]))
mul_nums = nums.replace(',','*')
print(eval(mul_nums))

这是我的机器的一些性能测量。适用于长时间运行的循环中的小输入:

import functools, operator, timeit
import numpy as np


def multiply_numpy(iterable):
return np.prod(np.array(iterable))


def multiply_functools(iterable):
return functools.reduce(operator.mul, iterable)


def multiply_manual(iterable):
prod = 1
for x in iterable:
prod *= x


return prod


sizesToTest = [5, 10, 100, 1000, 10000, 100000]


for size in sizesToTest:
data = [1] * size


timerNumpy = timeit.Timer(lambda: multiply_numpy(data))
timerFunctools = timeit.Timer(lambda: multiply_functools(data))
timerManual = timeit.Timer(lambda: multiply_manual(data))


repeats = int(5e6 / size)
resultNumpy = timerNumpy.timeit(repeats)
resultFunctools = timerFunctools.timeit(repeats)
resultManual = timerManual.timeit(repeats)
print(f'Input size: {size:>7d} Repeats: {repeats:>8d}    Numpy: {resultNumpy:.3f}, Functools: {resultFunctools:.3f}, Manual: {resultManual:.3f}')

结果:

Input size:       5 Repeats:  1000000    Numpy: 4.670, Functools: 0.586, Manual: 0.459
Input size:      10 Repeats:   500000    Numpy: 2.443, Functools: 0.401, Manual: 0.321
Input size:     100 Repeats:    50000    Numpy: 0.505, Functools: 0.220, Manual: 0.197
Input size:    1000 Repeats:     5000    Numpy: 0.303, Functools: 0.207, Manual: 0.185
Input size:   10000 Repeats:      500    Numpy: 0.265, Functools: 0.194, Manual: 0.187
Input size:  100000 Repeats:       50    Numpy: 0.266, Functools: 0.198, Manual: 0.185

您可以看到，Numpy在较小的输入上要慢得多，因为它在执行乘法之前分配一个数组。另外，要注意Numpy中的溢出。

简单的方法是:

import numpy as np
np.exp(np.log(your_array).sum())

那么使用递归呢?

def multiply(lst):
if len(lst) > 1:
return multiply(lst[:-1])* lst[-1]
else:
return lst[0]

def myfunc(lst):
multi=1
for product in lst:
multi*=product
return product

这是我的代码:

def product_list(list_of_numbers):
xxx = 1
for x in list_of_numbers:
xxx = xxx*x
return xxx


print(product_list([1,2,3,4]))

结果:('1*1*2*3*4'，24)

我的解决方案:

def multiply(numbers):
a = 1
for num in numbers:
a *= num
return a

从Python 3.8开始，标准库中的math模块已经包含了一个.prod函数:

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

该方法返回start值(默认值:1)乘以数字可迭代对象的乘积:

import math
math.prod([1, 2, 3, 4, 5, 6])


>>> 720

如果可迭代对象为空，将生成1(如果提供了start值)。

Numpy有prod()函数，返回一个列表的乘积，或者在本例中，由于它是numpy，它是一个数组在给定轴上的乘积:

import numpy
a = [1,2,3,4,5,6]
b = numpy.prod(a)

.．.或者你可以直接导入numpy.prod():

from numpy import prod
a = [1,2,3,4,5,6]
b = prod(a)

" '是理解逻辑的唯一简单方法 使用for循环" '

只是想添加一个Python 3.10一行程序回答:

def multiply(l):
return [b := 1, [b := b * a for a in l]][-1][-1]




print(multiply([2, 3, 8, 10]))

输出:

480

解释:

• [b := 1, 用于定义临时变量

• ...[b := b * a for a in l]用于遍历列表并将b乘以每个元素

• ...[-1][-1]是因为最终列表是[b, [b * l[0], b * l[1], ..., b * l[-1]]]。所以最后位置的元素是列表中所有元素的乘积。

在这个帖子里有很多很好的答案。如果您想在实际生产中进行列表相乘，我建议使用标准numpy或math包。

如果你只是在寻找一个快速而肮脏的解决方案，你不想导入任何东西，你可以这样做:

l = [1,2,3,4,5,6]


def list_multiply(l):
return eval('*'.join(map(str,l)))
    

print(list_multiply(l))
#Output: 720

map(str,l)将列表中的每个元素转换为字符串。join将每个元素组合成一个由*符号分隔的字符串。eval将字符串转换回可以求值的函数。

警告:eval被认为是危险的使用，特别是当程序接受用户输入时，因为用户可能会在代码中注入任何函数并危及您的系统。