¿Cómo realizar la multiplicación por elementos de dos listas?

Quiero realizar una multiplicación sabia de elementos, para multiplicar dos listas juntas por valor en Python, como podemos hacerlo en Matlab.

Así es como lo haría en Matlab.

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

Una comprensión de la lista daría 16 entradas de lista, por cada combinación x * yde xfrom ay yfrom b. No estoy seguro de cómo mapear esto.

Si a alguien le interesa por qué, tengo un conjunto de datos y quiero multiplicarlo por Numpy.linspace(1.0, 0.5, num=len(dataset)) =).

Use una lista de comprensión mezclada con zip():.

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

Como ya está utilizando numpy, tiene sentido almacenar sus datos en una numpymatriz en lugar de una lista. Una vez que haces esto, obtienes cosas como productos basados ​​en elementos gratis:

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

Use np.multiply (a, b):

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

Puedes intentar multiplicar cada elemento en un bucle. La mano corta para hacer eso es

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

Otra respuesta más:

-1... requiere importación
+1... es muy legible

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

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

salidas [10, 22, 36, 52]

Manera bastante intuitiva de hacer esto:

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

puedes multiplicar usando lambda

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

Para listas grandes, podemos hacerlo de la siguiente manera:

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

product_iter_object.next() da cada uno de los elementos en la lista de salida.

La salida sería la longitud de la más corta de las dos listas de entrada.

crear una variedad de unos; multiplicar cada lista por la matriz; convertir matriz a una lista

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]

La respuesta de gahooa es correcta para la pregunta tal como está redactada en el encabezado, pero si las listas ya tienen formato numpy o más de diez, será MUCHO más rápido (3 órdenes de magnitud) y más legible, para hacer una multiplicación numpy simple como lo sugiere NPE. Tengo estos horarios:

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

es decir, del siguiente programa de prueba.

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

Puede usar enumerate.

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

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

La mapfunción puede ser muy útil aquí. Usando mappodemos aplicar cualquier función a cada elemento de un iterable.

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

Por supuesto:

map(f, iterable)

es equivalente a

[f(x) for x in iterable]

Para que podamos obtener nuestra solución a través de:

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

En Python 2.x map()significa: aplicar una función a cada elemento de un iterable y construir una nueva lista. En Python 3.x, mapconstruya iteradores en lugar de listas.

En lugar de my_mulpodríamos usar muloperador

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

Tenga en cuenta que, dado que map()construye un iterador, utilizamos un *operador de desempaquetado iterable para obtener una lista. El enfoque de desempaquetado es un poco más rápido que el listconstructor:

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

Para mantener el tipo de lista y hacerlo en una línea (después de importar numpy como np, por supuesto):

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

o

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

puedes usar esto para listas de la misma longitud

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