Jak mogę pomnożyć wszystkie elementy na liście razem z Pythonem?

Muszę napisać funkcję, która pobiera listę liczb i mnoży je razem. Przykład: [1,2,3,4,5,6]da mi 1*2*3*4*5*6. Naprawdę mógłbym skorzystać z twojej pomocy.

Python 3: użyj functools.reduce:

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

Python 2: użyj reduce:

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

Aby zachować zgodność z trybem 2 i 3, należy pip install six:

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

Możesz użyć:

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

Zobacz wyjaśnienia reducei operator.muldokumentacje.

Potrzebujesz import functoolslinii w Pythonie 3+.

Użyłbym tego numpy.proddo wykonania zadania. Patrz poniżej.

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

Jeśli chcesz uniknąć importowania czegokolwiek i uniknąć bardziej złożonych obszarów Pythona, możesz użyć prostej pętli 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

Zaczynając Python 3.8, .prodfunkcja została dołączona do mathmodułu w standardowej bibliotece:

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

Metoda zwraca iloczyn startwartości (domyślnie: 1) razy iterowalnej liczby:

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

>>> 720

Jeśli iterowalny jest pusty, wygeneruje 1(lub startwartość, jeśli podano).

Oto kilka pomiarów wydajności z mojej maszyny. Istotne w przypadku, gdy jest to wykonywane dla małych wejść w długo działającej pętli:

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

Wyniki:

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

Widać, że Numpy jest nieco wolniejszy na mniejszych wejściach, ponieważ przydziela tablicę przed wykonaniem mnożenia. Uważaj też na przepełnienie Numpy.

Osobiście podoba mi się ta funkcja, która zwielokrotnia wszystkie elementy listy ogólnej:

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

Jest kompaktowy, wykorzystuje proste rzeczy (zmienną i pętlę for) i jest dla mnie intuicyjny (wygląda na to, jak bym pomyślał o problemie, wystarczy wziąć jeden, pomnożyć go, a następnie pomnożyć przez następny i tak dalej! )

Prosty sposób to:

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

Numpyma prod()funkcję, która zwraca iloczyn listy, lub w tym przypadku, ponieważ jest numpy, jest iloczynem tablicy nad daną osią:

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

... lub możesz po prostu zaimportować numpy.prod():

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

Znalazłem to pytanie dzisiaj, ale zauważyłem, że nie ma przypadku, w którym są Nonena liście. Tak więc kompletnym rozwiązaniem byłoby:

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

W przypadku dodania mamy:

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

Chciałbym to w następujący sposób:

    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

To jest mój kod:

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

wynik: („1 * 1 * 2 * 3 * 4”, 24)

Co powiesz na użycie rekurencji?

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

Moje rozwiązanie:

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

  pass

'' jedyna prosta metoda zrozumienia logiki użycia pętli ''

Lap = [2,5,7,7,9] x = 1 dla i na Lap: x = i * x print (x)

To bardzo proste, nic nie importuj. To jest mój kod. Spowoduje to zdefiniowanie funkcji, która zwielokrotnia wszystkie pozycje na liście i zwraca ich produkt.

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