wake-up-neo.com

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

Ich möchte eine elementweise Multiplikation durchführen, um zwei Listen in Python mit dem Wert zu multiplizieren, wie wir es in Matlab tun können.

So würde ich es in Matlab machen.

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

Ein Listenverständnis würde 16 Listeneinträge für jede Kombination x * y von x aus a und y aus b ergeben. Sie sind sich nicht sicher, wie Sie dies zuordnen können.

Wenn jemand warum interessiert ist, habe ich einen Datensatz und möchte ihn mit Numpy.linspace(1.0, 0.5, num=len(dataset)) =) multiplizieren.

105
xxjjnn

Verwenden Sie ein Listenverständnis, das mit Zip(): gemischt ist.

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

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

Verwenden Sie np.multiply (a, b):

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

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

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

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]

5
Petr Vepřek

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

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

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.

3
aady

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

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

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

Kann Aufzählung verwenden.

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

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

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
0
WOX GAMER