¿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 . Ejemplo: [1,2,3,4,5,6]me dará 1*2*3*4*5*6. Realmente podría usar tu ayuda.

Python 3: uso functools.reduce:

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

Python 2: uso reduce:

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

Para uso compatible con 2 y 3 pip install six, entonces:

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

Ver reduceyoperator.mul documentaciones para una explicación.

Necesitas la import functoolslínea en Python 3+.

Usaría el numpy.prodpara 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 for simple

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

Comenzando Python 3.8, .prodse ha incluido una función al mathmódulo en la biblioteca estándar:

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

El método devuelve el producto de un startvalor (predeterminado: 1) multiplicado por un iterable de números:

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

>>> 720

Si el iterable está vacío, esto producirá 1(o el startvalor, si se proporciona).

Aquí hay algunas mediciones de rendimiento de mi máquina. Relevante en caso de que esto se realice para entradas pequeñas en un ciclo 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.

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

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 pensaría en el problema, solo toma uno, multiplícalo, luego multiplícalo por el siguiente, ¡y así sucesivamente! )

La forma simple es:

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

Numpytiene la prod()función que devuelve el producto de una lista, o en este caso, ya que es numpy, es el producto de una matriz sobre un eje dado:

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

... o simplemente puedes importar numpy.prod():

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

Encontré esta pregunta hoy, pero me di cuenta de que no tiene el caso donde hay Noneen 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

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)

¿Qué tal el uso de la recursividad?

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

Mi solución:

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

  pass

'' 'el único método simple para comprender el uso lógico del bucle' ''

Vuelta = [2,5,7,7,9] x = 1 para i en Vuelta: x = i * x print (x)

Es muy sencillo no importar nada. Este es mi codigo. 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