Как выполнить поэлементное умножение двух списков в Python?

Я хочу выполнить умножение элемента, чтобы умножить два списка вместе на значение в Python, как мы можем сделать это в Matlab.

вот как я бы это сделал в Matlab.

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

понимание списка даст 16 записей списка для каждой комбинации x * y of x С a и y С b. Не уверен,как это отобразить.

если кому-то интересно почему, у меня есть набор данных, и вы хотите умножить его на Numpy.linspace(1.0, 0.5, num=len(dataset)) =).

91
elementwise-operations list multiplying python

13 ответов

используйте понимание списка, смешанное с zip():.

[a*b for a,b in zip(lista,listb)]
199

Так как вы уже используете numpy имеет смысл хранить свои данные в numpy массив, а не список. Как только вы это сделаете, вы получите такие вещи, как продукты element-wise бесплатно:

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

использовать np.умножьте (a, b):

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

вы можете попробовать умножить каждый элемент в цикле. Короткая рука для этого

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

довольно интуитивный способ сделать это:

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

еще один ответ:

-1 ... требуется импортировать
+1 ... очень читабельно

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

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

выходы [10, 22, 36, 52]

4

для больших списков мы можем сделать это iter-way:

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

product_iter_object.next() дает каждый элемент в выходном списке.

выход будет длиной более короткого из двух входных списков.

3

создать массив из них; умножьте каждый раз массив; преобразовать массив в список

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

вы можете умножение с помощью lambda 

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

ответ gahooa верен для вопроса, сформулированного в заголовке, но если списки уже имеют формат numpy или больше десяти это будет намного быстрее (3 порядка величины), а также более читаемым, чтобы сделать простое умножение numpy, как предложено NPE. Я получаю эти тайминги:

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

т. е. из следующей программы испытаний.

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

на map функция может быть очень полезна здесь. Используя map мы можем применить любую функцию к каждому элементу в массиве.

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

конечно: 

map(f, iterable)

эквивалентно 

[f(x) for x in iterable]

так мы можем получить наше решение через:

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

В Python 2.x map() означает: применить функцию к каждому элементу iterable и построить новый список. В Python 3.x,map построить итераторы вместо списки.

вместо my_mul мы могли бы использовать 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]
>>>

обратите внимание, что после map() создает итератор, который мы используем * iterable распаковка оператор, чтобы получить список. Распаковка подход немного быстрее, чем list конструктора:

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

можно использовать enumerate.

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

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

чтобы сохранить тип списка и сделать это в одной строке (после импорта numpy как np, конечно):

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

или

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