Wie kann ich alle Elemente in einer Liste zusammen mit Python multiplizieren?

Ich muss eine Funktion schreiben, die eine Liste von Zahlen nimmt und sie miteinander multipliziert . Beispiel: [1,2,3,4,5,6]wird mir geben 1*2*3*4*5*6. Ich könnte deine Hilfe wirklich gebrauchen.

Python 3: benutze functools.reduce:

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

Python 2: benutze reduce:

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

Für die Kompatibilität mit 2 und 3 pip install sixgilt dann:

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

Sie können verwenden:

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

Siehe reduceund operator.mulDokumentationen für eine Erklärung.

Sie benötigen die import functoolsZeile in Python 3+.

Ich würde das verwenden numpy.prod, um die Aufgabe auszuführen. Siehe unten.

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

Wenn Sie das Importieren von Objekten und komplexere Bereiche von Python vermeiden möchten, können Sie eine einfache for-Schleife verwenden

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

Ab dem Start Python 3.8wurde eine .prodFunktion in das mathModul in der Standardbibliothek aufgenommen:

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

Die Methode gibt das Produkt eines startWerts (Standard: 1) mal einer iterierbaren Zahl zurück:

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

>>> 720

Wenn die Iterable leer ist, wird dies erzeugt 1(oder der startWert, falls angegeben).

Hier sind einige Leistungsmessungen von meinem Computer. Relevant für den Fall, dass dies für kleine Eingaben in einer langen Schleife durchgeführt wird:

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

Ergebnisse:

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

Sie können sehen, dass Numpy bei kleineren Eingaben etwas langsamer ist, da es ein Array zuweist, bevor die Multiplikation durchgeführt wird. Achten Sie auch auf den Überlauf in Numpy.

Ich persönlich mag dies für eine Funktion, die alle Elemente einer generischen Liste miteinander multipliziert:

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

Es ist kompakt, verwendet einfache Dinge (eine Variable und eine for-Schleife) und fühlt sich für mich intuitiv an (es sieht so aus, als würde ich das Problem betrachten, nehmen Sie einfach eines, multiplizieren Sie es, multiplizieren Sie es mit dem nächsten und so weiter! )

Der einfache Weg ist:

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

Numpyhat die prod()Funktion, die das Produkt einer Liste zurückgibt, oder in diesem Fall, da es numpy ist, ist es das Produkt eines Arrays über einer bestimmten Achse:

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

... oder Sie können einfach importieren numpy.prod():

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

Ich habe diese Frage heute gefunden, aber ich habe festgestellt, dass es nicht den Fall gibt None, in dem es in der Liste gibt. Die vollständige Lösung wäre also:

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

Im Falle der Hinzufügung haben wir:

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

Ich möchte dies folgendermaßen:

    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

Das ist mein Code:

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

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

Wie wäre es mit Rekursion?

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

Meine Lösung:

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

  pass

'' 'die einzige einfache Methode, um die Logik für die Schleife zu verstehen' ''

Runde = [2,5,7,7,9] x = 1 für i in Runde: x = i * x print (x)

Es ist sehr einfach, nichts zu importieren. Das ist mein Code. Dadurch wird eine Funktion definiert, die alle Elemente in einer Liste multipliziert und ihr Produkt zurückgibt.

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