두 목록을 요소별로 곱하는 방법은 무엇입니까?

Matlab에서 할 수있는 것처럼 파이썬에서 두 목록을 값으로 곱하기 위해 요소 현명한 곱셈을 수행하고 싶습니다.

이것이 내가 Matlab에서하는 방법입니다.

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

목록 이해는 from 과 from x * y의 모든 조합 에 대해 16 개의 목록 항목을 제공합니다 . 이것을 매핑하는 방법을 모릅니다.xayb

누군가 왜 그 이유에 관심이 있다면, 나는 데이터 세트를 가지고 있고 그것을 곱하고 싶습니다 Numpy.linspace(1.0, 0.5, num=len(dataset)) =).

zip(): 와 혼합 된 목록 이해를 사용하십시오 .

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

이미를 사용하고 있으므로 목록이 아닌 배열에 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])

np.multiply (a, b)를 사용하십시오.

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

루프에서 각 요소를 곱할 수 있습니다. 그렇게하는 짧은 손은

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

또 다른 대답 :

-1... 가져 오기
+1가 필요합니다 ... 매우 읽기 쉽습니다

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

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

출력 [10, 22, 36, 52]

이것을하는 상당히 직관적 인 방법 :

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

당신은 곱셈을 사용할 수 있습니다 lambda

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

큰 목록의 경우 iter-way로 할 수 있습니다.

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

product_iter_object.next() 출력 목록의 각 요소를 제공합니다.

출력은 두 입력 목록 중 더 짧은 길이입니다.

하나의 배열을 만듭니다. 각 목록에 배열을 곱하십시오. 배열을 목록으로 변환

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]

gahooa의 답변은 제목에 표시된 질문에 대해 맞지만 목록이 이미 numpy 형식 이거나 10보다 큰 경우 더 많은 (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))

열거 형을 사용할 수 있습니다.

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

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

이 map기능은 여기서 매우 유용 할 수 있습니다. 사용하여 map우리가 반복자의 각 요소에 어떤 기능을 적용 할 수 있습니다.

파이썬 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]
>>>

파이썬 2.x에서 map()의미 : iterable의 각 요소에 함수를 적용하고 새로운 목록을 구성하십시오. Python 3.x map에서는 목록 대신 반복자를 구성하십시오.

대신 연산자를 my_mul사용할 수 있습니다 mul

파이썬 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]
>>>

파이썬 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]
>>>

목록 유형을 유지하고 한 줄로 수행하십시오 (물론 numpy를 np로 가져온 후) :

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

또는

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

같은 길이의 목록에 사용할 수 있습니다

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