¿Cómo puedo multiplicar todos los elementos de una lista junto con Python?

Necesito escribir una función que tome una lista de números y los multiplique juntos. Ejemplo: [1,2,3,4,5,6] me dará 1*2*3*4*5*6 . Realmente podría usar tu ayuda.

Related of "¿Cómo puedo multiplicar todos los elementos de una lista junto con Python?"

Python 3: utiliza functools.reduce :

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

Python 2: usar reduce

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

Para compatible con 2 y 3, use pip install six , luego:

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

Puedes usar:

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

Consulte la documentación de reduce y operator.mul para obtener una explicación.

Necesitas la línea de import functools en Python 3+.

Yo usaría el numpy.prod para realizar la tarea. Vea abajo.

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

Si desea evitar importar algo y evitar áreas más complejas de Python, puede usar un bucle simple para

 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 

Personalmente me gusta esto para una función que multiplica todos los elementos de una lista genérica juntos:

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

Es compacto, usa cosas simples (una variable y un bucle for), y me parece intuitivo (parece que pensaba en el problema, solo toma uno, multiplícalo, luego multiplícalo por el siguiente, ¡y así sucesivamente!) )

La forma más sencilla es:

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

Aquí hay algunas medidas de rendimiento de mi máquina. Relevante en caso de que esto se realice para entradas pequeñas en un bucle de larga duración:

 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}') 

Resultados:

 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 

Puede ver que Numpy es bastante más lento en entradas más pequeñas, ya que asigna una matriz antes de que se realice la multiplicación. Además, ten cuidado con el desbordamiento en Numpy.

Encontré esta pregunta hoy pero noté que no tiene el caso donde no hay None en la lista. Entonces, la solución completa sería:

 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)) 

En el caso de la adición, tenemos:

 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)) 

Me gustaría esto de la siguiente manera:

  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 

Al iniciar Python 3.8 , se ha incluido una función prod en el módulo math en la biblioteca estándar:

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

que devuelve el producto de un valor de start (predeterminado: 1) multiplicado por una iterable de números:

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

Tenga en cuenta que si el iterable está vacío, esto producirá 1 (o el valor de start si se proporciona).

Este es mi código:

 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])) 

resultado: (‘1 * 1 * 2 * 3 * 4’, 24)

Mi solución:

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

¿Qué hay de usar la recursión?

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

Es muy sencillo no importar nada. Este es mi código. Esto definirá una función que multiplica todos los elementos de una lista y devuelve su producto.

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