tamaño - sacar elementos de una lista python

¿Cómo realizar la multiplicación basada en elementos de dos listas en Python?

Question

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 lista de comprensión daría 16 entradas a la lista, para cada combinación x * y de x de a y y de b . Inseguro de cómo mapear esto.

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

Answer 1

Como ya está usando numpy , tiene sentido almacenar sus datos en una matriz numpy lugar de una lista. Una vez que hace esto, obtiene cosas como productos de elementos de forma gratuita:

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

Answer 2

La función de map puede ser muy útil aquí. Usando el map podemos 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, traza iteradores de construcción en lugar de listas.

En lugar de my_mul podríamos usar el operador 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]
>>>

Tenga en cuenta que, como map() construye un iterador, usamos * iterable unpacking operator para obtener una lista. El enfoque de desempaquetado es un poco más rápido que el constructor de la list :

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

Answer 3

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

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

Answer 4

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]

Answer 5

Para listas grandes, podemos hacerlo al revés:

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

product_iter_object.next() proporciona 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.

Answer 6

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

Answer 7

Puede usar enumerate.

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

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

Answer 8

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

Answer 9

Una forma 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

Answer 10

Use np.multiply (a, b):

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

Answer 11

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

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

Answer 12

crea una matriz 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]

Answer 13

puedes multiplicar usando lambda

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