Come posso moltiplicare tutti gli elementi in un elenco insieme a Python?

Devo scrivere una funzione che prende un elenco di numeri e li moltiplica insieme. Esempio: [1,2,3,4,5,6]mi darà 1*2*3*4*5*6. Potrei davvero usare il tuo aiuto.

Python 3: usa functools.reduce:

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

Python 2: usa reduce:

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

Per l'uso compatibile con 2 e 3 pip install six, quindi:

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

Puoi usare:

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

Vedi reducee operator.muldocumentazione per una spiegazione.

Hai bisogno della import functoolslinea in Python 3+.

Vorrei utilizzare il numpy.prodper eseguire l'attività. Vedi sotto.

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

Se vuoi evitare di importare qualcosa ed evitare aree più complesse di Python, puoi usare un semplice ciclo per

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

A partire Python 3.8, una .prodfunzione è stata inclusa nel mathmodulo nella libreria standard:

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

Il metodo restituisce il prodotto di un startvalore (valore predefinito: 1) volte un iterabile di numeri:

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

>>> 720

Se l'iterabile è vuoto, questo produrrà 1(o il startvalore, se fornito).

Ecco alcune misurazioni delle prestazioni dalla mia macchina. Rilevante nel caso in cui ciò venga eseguito per piccoli input in un ciclo di lunga durata:

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

risultati:

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

Puoi vedere che Numpy è un po 'più lento su input più piccoli, poiché alloca un array prima che venga eseguita la moltiplicazione. Inoltre, fai attenzione al trabocco di Numpy.

Personalmente mi piace questo per una funzione che moltiplica tutti gli elementi di un elenco generico insieme:

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

È compatto, usa cose semplici (una variabile e un ciclo for) e mi sembra intuitivo (sembra come penso al problema, ne prendo uno, lo moltiplico, poi lo moltiplico per il successivo e così via! )

Il modo semplice è:

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

Numpyha la prod()funzione che restituisce il prodotto di un elenco, o in questo caso poiché è intorpidito, è il prodotto di un array su un determinato asse:

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

... oppure puoi semplicemente importare numpy.prod():

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

Ho trovato questa domanda oggi, ma ho notato che non ha il caso in cui ci siano Nonenell'elenco. Quindi, la soluzione completa sarebbe:

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

In caso di aggiunta, abbiamo:

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

Vorrei questo nel modo seguente:

    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

Questo è il mio codice:

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

risultato: ('1 * 1 * 2 * 3 * 4', 24)

Che ne dici di usare la ricorsione?

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

La mia soluzione:

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

  pass

'' 'l'unico metodo semplice per comprendere l'uso della logica per il loop' ''

Giro = [2,5,7,7,9] x = 1 per i nel giro: x = i * x stampa (x)

È molto semplice non importare nulla. Questo è il mio codice Ciò definirà una funzione che moltiplica tutti gli articoli in un elenco e restituisce il loro prodotto.

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