Comment puis-je multiplier tous les éléments d'une liste avec Python?

J'ai besoin d'écrire une fonction qui prend une liste de nombres et les multiplie . Exemple: [1,2,3,4,5,6]me donnera 1*2*3*4*5*6. Je pourrais vraiment utiliser votre aide.

Python 3: utilisez functools.reduce:

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

Python 2: utilisez reduce:

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

Pour une utilisation compatible avec 2 et 3 pip install six, alors:

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

Vous pouvez utiliser:

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

Voir reduceet operator.muldocumentations pour une explication.

Vous avez besoin de la import functoolsligne en Python 3+.

J'utiliserais le numpy.prodpour effectuer la tâche. Voir ci-dessous.

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

Si vous voulez éviter d'importer quoi que ce soit et éviter les zones plus complexes de Python, vous pouvez utiliser une boucle 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

Au démarrage Python 3.8, une .prodfonction a été intégrée au mathmodule dans la bibliothèque standard:

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

La méthode renvoie le produit d'une startvaleur (par défaut: 1) multipliée par un itérable de nombres:

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

>>> 720

Si l'itérable est vide, cela produira 1(ou la startvaleur, si elle est fournie).

Voici quelques mesures de performances de ma machine. Pertinent dans le cas où cela est effectué pour de petites entrées dans une boucle longue:

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

Résultats:

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

Vous pouvez voir que Numpy est un peu plus lent sur les petites entrées, car il alloue un tableau avant la multiplication. Faites également attention au débordement dans Numpy.

Personnellement, j'aime cela pour une fonction qui multiplie tous les éléments d'une liste générique:

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

Il est compact, utilise des choses simples (une variable et une boucle for) et me semble intuitif (il ressemble à ce que je penserais du problème, il suffit d'en prendre un, de le multiplier, puis de multiplier par le suivant, et ainsi de suite! )

La manière la plus simple est:

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

Numpya la prod()fonction qui retourne le produit d'une liste, ou dans ce cas puisque c'est numpy, c'est le produit d'un tableau sur un axe donné:

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

... ou bien vous pouvez simplement importer numpy.prod():

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

J'ai trouvé cette question aujourd'hui mais j'ai remarqué qu'elle n'a pas le cas où il y en a Nonedans la liste. Ainsi, la solution complète serait:

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 cas d'addition, nous avons:

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

Je voudrais cela de la manière suivante:

    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

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

résultat: ('1 * 1 * 2 * 3 * 4', 24)

Que diriez-vous d'utiliser la récursivité?

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

Ma solution:

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

  pass

'' 'la seule méthode simple pour comprendre l'utilisation logique de la boucle' ''

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

Il est très simple de ne rien importer. Ceci est mon code. Cela définira une fonction qui multiplie tous les articles d'une liste et renvoie leur produit.

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