web-dev-qa-db-fra.com

Comment effectuer la multiplication élément par élément de deux listes en Python?

Je veux effectuer une multiplication élément par élément, multiplier deux listes ensemble par valeur en Python, comme nous pouvons le faire dans Matlab.

Voici comment je le ferais dans Matlab.

a = [1,2,3,4]
b = [2,3,4,5]
a .* b = [2, 6, 12, 20]

Une compréhension de liste donnerait 16 entrées de liste, pour chaque combinaison x * y de x de a et y de b. Vous ne savez pas comment cartographier cela.

Si quelqu'un est intéressé pourquoi, j'ai un jeu de données et je veux le multiplier par Numpy.linspace(1.0, 0.5, num=len(dataset)) =).

pythonlistmultiplyingelementwise-operations
105
xxjjnn

Utilisez une compréhension de liste mélangée à Zip() :.

[a*b for a,b in Zip(lista,listb)]
217
gahooa

Puisque vous utilisez déjà numpy, il est logique de stocker vos données dans un tableau numpy plutôt que dans une liste. Une fois que vous faites cela, vous obtenez des choses comme des produits élément-sains gratuitement:

In [1]: import numpy as np

In [2]: a = np.array([1,2,3,4])

In [3]: b = np.array([2,3,4,5])

In [4]: a * b
Out[4]: array([ 2,  6, 12, 20])
72
NPE

Utilisez np.multiply (a, b):

import numpy as np
a = [1,2,3,4]
b = [2,3,4,5]
np.multiply(a,b)
19
Brisa

Vous pouvez essayer de multiplier chaque élément dans une boucle. La main courte pour le faire est

ab = [a[i]*b[i] for i in range(len(a))]
17
Nate

Manière assez intuitive de faire ceci:

a = [1,2,3,4]
b = [2,3,4,5]
ab = []                        #Create empty list
for i in range(0, len(a)):
     ab.append(a[i]*b[i])      #Adds each element to the list
7
Turtleneck

Encore une autre réponse:

-1 ... nécessite une importation
+1 ... est très lisible

import operator
a = [1,2,3,4]
b = [10,11,12,13]

list(map(operator.mul, a, b))

sorties [10, 22, 36, 52]

5
Petr Vepřek

vous pouvez multiplier en utilisant lambda 

foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)
5
Benjamin

créer un tableau de uns; multiplier chaque liste par le tableau; convertir un tableau en liste

import numpy as np

a = [1,2,3,4]
b = [2,3,4,5]

c = (np.ones(len(a))*a*b).tolist()

[2.0, 6.0, 12.0, 20.0]
4
litepresence

Pour les grandes listes, nous pouvons le faire à la manière suivante:

product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])

product_iter_object.next() donne chacun des éléments dans la liste de sortie.

La sortie serait la longueur de la plus courte des deux listes d’entrée.

3
aady

la réponse de gahooa est correcte pour la question telle qu'elle est formulée dans l'en-tête, mais si les listes sont déjà au format numpyouplus grandes que dix, elles seront BEAUCOUP plus rapides (3 ordres de grandeur) et plus lisibles, faire une simple multiplication numpy comme suggéré par NPE. Je reçois ces timings:

0.0049ms -> N = 4, a = [i for i in range(N)], c = [a*b for a,b in Zip(a, b)]
0.0075ms -> N = 4, a = [i for i in range(N)], c = a * b
0.0167ms -> N = 4, a = np.arange(N), c = [a*b for a,b in Zip(a, b)]
0.0013ms -> N = 4, a = np.arange(N), c = a * b
0.0171ms -> N = 40, a = [i for i in range(N)], c = [a*b for a,b in Zip(a, b)]
0.0095ms -> N = 40, a = [i for i in range(N)], c = a * b
0.1077ms -> N = 40, a = np.arange(N), c = [a*b for a,b in Zip(a, b)]
0.0013ms -> N = 40, a = np.arange(N), c = a * b
0.1485ms -> N = 400, a = [i for i in range(N)], c = [a*b for a,b in Zip(a, b)]
0.0397ms -> N = 400, a = [i for i in range(N)], c = a * b
1.0348ms -> N = 400, a = np.arange(N), c = [a*b for a,b in Zip(a, b)]
0.0020ms -> N = 400, a = np.arange(N), c = a * b

c'est-à-dire du programme de test suivant.

import timeit

init = ['''
import numpy as np
N = {}
a = {}
b = np.linspace(0.0, 0.5, len(a))
'''.format(i, j) for i in [4, 40, 400] 
                  for j in ['[i for i in range(N)]', 'np.arange(N)']]

func = ['''c = [a*b for a,b in Zip(a, b)]''',
'''c = a * b''']

for i in init:
  for f in func:
    lines = i.split('\n')
    print('{:6.4f}ms -> {}, {}, {}'.format(
           timeit.timeit(f, setup=i, number=1000), lines[2], lines[3], f))
2
paddyg

La fonction map peut être très utile ici . En utilisant map, nous pouvons appliquer n’importe quelle fonction à chaque élément d’un élément itérable.

Python 3.x

>>> def my_mul(x,y):
...     return x*y
...
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>>
>>> list(map(my_mul,a,b))
[2, 6, 12, 20]
>>>

Bien sûr: 

map(f, iterable)

est équivalent à 

[f(x) for x in iterable]

Nous pouvons donc obtenir notre solution via:

>>> [my_mul(x,y) for x, y in Zip(a,b)]
[2, 6, 12, 20]
>>>

En Python 2.x, map() signifie: applique une fonction à chaque élément d'une variable et permet de construire une nouvelle liste . En Python 3.x, map construit des itérateurs au lieu de listes. 

Au lieu de my_mul, nous pourrions utiliser l'opérateur mul

Python 2.7

>>>from operator import mul # import mul operator
>>>a = [1,2,3,4]
>>>b = [2,3,4,5]
>>>map(mul,a,b)
[2, 6, 12, 20]
>>>

Python 3.5+

>>> from operator import mul
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>> [*map(mul,a,b)]
[2, 6, 12, 20]
>>>

Veuillez noter que puisque map() construit un itérateur, nous utilisons * opérateur de décompression itérable pour obtenir une liste . L’approche de décompression est un peu plus rapide que le constructeur list:

>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>
1
sg7

Pour conserver le type de liste et le faire sur une ligne (après avoir importé numpy en tant que np, bien sûr):

list(np.array([1,2,3,4]) * np.array([2,3,4,5]))

ou

list(np.array(a) * np.array(b))
0
mightypile

Peut utiliser énumérer.

a = [1, 2, 3, 4]
b = [2, 3, 4, 5]

ab = [val * b[i] for i, val in enumerate(a)]
0
SuperNova

vous pouvez l'utiliser pour des listes de même longueur

def lstsum(a, b):
    c=0
    pos = 0
for element in a:
   c+= element*b[pos]
   pos+=1
return c
0
WOX GAMER