Wie führe ich eine elementweise Multiplikation zweier Listen in Python durch?

Ich möchte ein element-Weise Multiplikation, multiplizieren von zwei Listen zusammen, die von Wert in Python, wie wir es tun können in Matlab.

Dies ist, wie ich es tun würde in Matlab.

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

Einer Liste Verständnis geben würde 16 Liste der Einträge, für jede Kombination x * y von x aus a und y aus b. Unsicher, wie diese Karte.

Wenn jemand interessiert ist, warum, ich habe einen Datensatz, und möchten, multiplizieren Sie es durch Numpy.linspace(1.0, 0.5, num=len(dataset)) =).

InformationsquelleAutor der Frage xxjjnn | 2012-04-22

196

Verwenden einer list-comprehension gemischt mit zip():.
```
[a*b for a,b in zip(lista,listb)]
```
InformationsquelleAutor der Antwort gahooa
67

Da Sie bereits mit numpy macht es Sinn, um Ihre Daten zu speichern in einer numpy array statt einer Liste. Sobald Sie dies tun, erhalten Sie Dinge wie element-wise-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])
```
InformationsquelleAutor der Antwort NPE

Verwenden, np.multiply(a,b):

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

InformationsquelleAutor der Antwort Brisa

13

Können Sie versuchen, die Multiplikation jedes element in einer Schleife. Die Abkürzung dafür ist
```
ab = [a[i]*b[i] for i in range(len(a))]
```
InformationsquelleAutor der Antwort Nate

Ziemlich intuitive Art und Weise, dies zu tun:

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

InformationsquelleAutor der Antwort Turtleneck

4

Noch eine andere Lösung:

-1 ... erfordert 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]

InformationsquelleAutor der Antwort Petr Vepřek
3

Für große Listen, wir können es tun, iter-Weg:
```
product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])
```
product_iter_object.next() gibt jedes element in der Liste der Ausgabespalten.

Die Ausgabe wäre die Länge der kürzeren der beiden input-Listen.

InformationsquelleAutor der Antwort aady
3

erstellen Sie ein array von Einsen;
multiplizieren Sie jede Liste mal die array;
konvertieren array zu einer 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]
```
InformationsquelleAutor der Antwort litepresence
3

können Sie Multiplikation mit lambda
```
foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)
```
InformationsquelleAutor der Antwort Benjamin

gahooa s Antwort ist korrekt, für die Frage, wie formuliert in der überschrift, aber wenn die Listen sind bereits numpy-format oder größer als zehn werden es VIEL schneller (3 Größenordnungen) sowie mehr lesbar, zu tun, einfache numpy Multiplikation vorgeschlagen von NPE. Bekomme ich diese 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

d.h. aus dem folgenden Programm testen.

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

InformationsquelleAutor der Antwort paddyg

1

Den map - Funktion kann hier sehr hilfreich.
Mit map können wir eine beliebige Funktion auf jedes element eines durchsuchbar.

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]
>>>
```
Natürlich:
```
map(f, iterable)
```
entspricht
```
[f(x) for x in iterable]
```
So können wir unsere Lösung über:
```
>>> [my_mul(x,y) for x, y in zip(a,b)]
[2, 6, 12, 20]
>>>
```
In Python 2.x map() bedeutet: anwenden einer Funktion auf jedes element eines wiederholenden und erstellen Sie eine neue Liste.
In Python 3.x, map konstruieren Iteratoren statt Listen.

Statt my_mul könnten wir mul Betreiber

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]
>>>
```
Bitte beachten Sie, dass seit map() Konstrukte, die einen iterator verwenden wir * iterierbar Auspacken-operator, um eine Liste.
Das Auspacken Ansatz ist ein bisschen schneller als die list Konstruktor:
```
>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>
```
InformationsquelleAutor der Antwort sg7

Verwenden können, aufgelistet werden.

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

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

InformationsquelleAutor der Antwort Vikram S

0

Pflegen der Liste Typ, und tun es in einer Zeile (nach dem Import numpy as np, natürlich):
```
list(np.array([1,2,3,4]) * np.array([2,3,4,5]))
```
oder
```
list(np.array(a) * np.array(b))
```
InformationsquelleAutor der Antwort mightypile

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.