Wie führt man eine elementweise Multiplikation von zwei Listen in Python durch?

Da Sie numpy bereits verwenden, ist es sinnvoll, Ihre Daten in einem numpy-Array und nicht in einer Liste zu speichern. Wenn Sie dies tun, erhalten Sie Dinge wie elementare Produkte kostenlos:

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

Verwenden Sie np.multiply (a, b):

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

Sie können versuchen, jedes Element in einer Schleife zu multiplizieren. Die kurze Hand dafür ist

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

Ziemlich intuitiv:

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

Noch eine Antwort:

-1 ... erfordert den Import
+1 ... ist sehr gut lesbar

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

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

ausgänge [10, 22, 36, 52]

sie können die Multiplikation mit lambda durchführen. 

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

erstellen Sie ein Array von Einsen; multiplizieren Sie jede Liste mit dem Array. Array in eine Liste konvertieren

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]

Für große Listen können wir es iterativ machen:

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

product_iter_object.next() gibt jedes Element in der Ausgabeliste an.

Die Ausgabe wäre die Länge der kürzeren der beiden Eingabelisten.

gahooas Antwort ist richtig für die Frage in der Überschrift, aber wenn die Listen bereits numpy formatodergrößer als zehn sind, wird es VIEL schneller (3 Größenordnungen) sowie lesbarer sein einfache numerische Multiplikation, wie von NPE vorgeschlagen. Ich bekomme diese Zeiten:

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

d.h. aus dem folgenden Testprogramm.

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

Die map-Funktion kann hier sehr nützlich sein. Mit map können wir jede Funktion auf jedes Element einer iterierbaren Funktion anwenden.

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

Na sicher: 

map(f, iterable)

ist äquivalent zu 

[f(x) for x in iterable]

So können wir unsere Lösung erhalten über:

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

In Python 2.x bedeutet map(): Wende eine Funktion auf jedes Element einer iterierbaren Komponente an und konstruiere eine neue Liste. In Python 3.x konstruieren map Iteratoren anstelle von Listen. 

Anstelle von my_mul könnten wir den Operator mul verwenden

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

Da map() einen Iterator erstellt, verwenden wir den *-iterierbaren Entpackungsoperator, um eine Liste zu erhalten . Der Entpackungsansatz ist etwas schneller als der list-Konstruktor:

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

So pflegen Sie den Listentyp in einer Zeile (nach dem Import von numpy als np natürlich):

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

oder

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

Kann Aufzählung verwenden.

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

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

sie können dies für Listen gleicher Länge verwenden

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