web-dev-qa-db-fra.com

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

Je dois écrire une fonction qui prend Une liste de nombres et multiplie eux ensemble. Exemple: [1,2,3,4,5,6] me donnera 1*2*3*4*5*6. Je pourrais vraiment utiliser votre aide.

pythonlistmultiplication
159
user1897814

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 compatible avec 2 et 3, utilisez pip install six, alors:

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

Vous pouvez utiliser:

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

Voir reduce et operator.mul documentations pour une explication.

Vous avez besoin de la ligne import functools dans Python 3+.

149
icecrime

Je voudrais utiliser le numpy.prod pour effectuer la tâche. Voir ci-dessous.

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

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

Personnellement, j'aime bien 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 (je dirais comment je penserais le problème, prenons-en un, multipliez-le, multipliez-le ensuite, etc.! ) 

8
user5038135

Le moyen simple est:

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

Voici quelques mesures de performance 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 des entrées plus petites, car il alloue un tableau avant la multiplication. Aussi, faites attention au débordement dans Numpy.

7
pishock

J'ai trouvé cette question aujourd'hui, mais j'ai remarqué qu'il n'y a pas de cas où il y a None dans la liste. La solution complète serait donc:

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))
2
Xxxo
nums = str(Tuple([1,2,3]))
mul_nums = nums.replace(',','*')
print(eval(mul_nums))
2
M. Dickson

Je voudrais ceci 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
1
Shakti Nandan

À partir de Python 3.8, une fonction prod a été incluse dans le module math de la bibliothèque standard:

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

qui renvoie le produit d'une valeur start (par défaut: 1) fois un nombre itérable:

import math

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

Notez que si l'itérable est vide, cela produira 1 (ou la valeur start si fournie).

0
Xavier Guihot

Numpy a la fonction prod qui retourne le produit d'une liste, ou dans ce cas depuis numpy, c'est techniquement le produit d'un tableau sur un axe donné.

une manière:

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

l'autre joue simplement à la façon dont vous importez:

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

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

0
jackim

Ma solution:

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

  pass
0
Dorian Vanzant