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

137

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

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

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

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

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

xxjjnn
источник
4
Почему вы спрашиваете это, когда вы уже сейчас о NumPy?
pwuertz
2
И, кстати, это поэлементное умножение, это не скалярное произведение.
pwuertz
3
Альтернатива: map (лямбда x, y: x * y, list1, list2) #derp ...
xxjjnn

Ответы:

284

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

[a*b for a,b in zip(lista,listb)]
gahooa
источник
9
С другой стороны, если они хотят сделать что-то еще, кроме тривиального случая, то ОП следует использовать Numpy.
Генри Гомерсалл
1
На Python 2 izip () может быть лучшим выбором.
Як
23
Вы также можете использовать map(lambda x,y:x*y,lista,listb).
mbomb007
Как изменится ответ, если нам дадут вместо listbдовольно список элементов типа listb, и нам нужно работать, чтобы получить единый список. Ex. (x, pi, e) с [(4, 5, 2), (1, 2, 4), (4, 5, 6), (1, 1, 2), (3, 3, 4)], когда взято (x, pi, e) оперируется с (4, 5, 2), а затем (x, pi, e) оперируется с (1, 2, 4) ... и так далее.
Gxyd
@gxyd Вы должны задать отдельный вопрос
mbomb007
88

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

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])
NPE
источник
1
Возможно, не самый научный, но я рассчитал это против ответа гаууа, используя timeit. Numpy на самом деле немного медленнее, чем метод zip.
Чейз Робертс
1
В моем случае, когда списки содержали двоичные значения, решение numpy было намного быстрее, чем использование izip.
Serendipity
Для удобства других, прибывших сюда из поиска в Google, я включил сравнение времени ниже.
паддыг
31

Используйте np.multiply (a, b):

import numpy as np
a = [1,2,3,4]
b = [2,3,4,5]
np.multiply(a,b)
Brisa
источник
21

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

ab = [a[i]*b[i] for i in range(len(a))]
Nate
источник
добро пожаловать в stackoverflow! Ответы только с кодом, как правило, не рекомендуется - пожалуйста, добавьте некоторые объяснения того, как это решает вопрос спрашивающего.
Корли Бригман
7
@CorleyBrigman Я не согласен; Существует очень небольшая разница между ответом: «Вот способ сделать это: <code>» и просто «<code>». В этой конкретной ситуации мало что можно объяснить, кроме «этот код решает вашу проблему».
Ледяные деревья
4
@CorleyBrigman Я не согласен; пример данных с отображением результатов будет на самом деле более полезным
Tjorriemorrie
2
Вот как программист на C, C ++ или Java, который является новичком в Python, решит проблему. Общепринятый ответ идиоматичен Python.
Дэвид Каллен
@Tjorriemorrie результаты ясны, поскольку они явно запрашиваются в вопросе. может быть, было бы неплохо объяснить, как работает понимание списков, или упомянуть, что для этого используется понимание списков, и тогда каждый может найти его, если он этого не знает.
xuiqzy
10

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

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

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

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

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

Петр Вепржек
источник
Если вы знаете карту, это действительно удобочитаемое решение! Имеет ли импорт какие-либо негативные последствия, кроме того, что он находится вверху файла? (редакторы могут скрыть импорт, если они хотят) Насколько я вижу, он должен быть доступен в каждой версии Python 2 и 3!
xuiqzy
9

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

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
водолазка
источник
9

Вы можете умножить, используя lambda

foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)
Вениамин
источник
4

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

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

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

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

aady
источник
4

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

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]
litepresence
источник
3

Ответ gahooa верен для вопроса, сформулированного в заголовке, но если списки уже имеют числовой формат или размер больше десяти, он будет НАМНОГО быстрее (на 3 порядка), а также более читабельным, чтобы выполнить простое умножение на кусочки, как предлагает 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))
paddyg
источник
3

Можно использовать перечислять.

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

ab = [val * b[i] for i, val in enumerate(a)]
SuperNova
источник
3

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()означает: применять функцию к каждому элементу итерируемого и создавать новый список. В 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()конструирует итератор, мы используем *итеративный оператор распаковки, чтобы получить список. Подход распаковки немного быстрее, чем listконструктор:

>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>
SG7
источник
1

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

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

или

list(np.array(a) * np.array(b))
mightypile
источник
0

Вы можете использовать это для списков одинаковой длины

def lstsum(a, b):
    c=0
    pos = 0
for element in a:
   c+= element*b[pos]
   pos+=1
return c
WOX GAMER
источник