¿Cómo multiplico cada elemento de una lista por un número?

Tengo una lista:

my_list = [1, 2, 3, 4, 5]

¿Cómo puedo multiplicar cada elemento my_listpor 5? La salida debe ser:

[5, 10, 15, 20, 25]

Puede usar una lista de comprensión:

my_list = [1, 2, 3, 4, 5]
my_new_list = [i * 5 for i in my_list]

>>> print(my_new_list)
[5, 10, 15, 20, 25]

Tenga en cuenta que la comprensión de una lista es generalmente una forma más eficiente de hacer un forbucle:

my_new_list = []
for i in my_list:
    my_new_list.append(i * 5)

>>> print(my_new_list)
[5, 10, 15, 20, 25]

Como alternativa, aquí hay una solución que utiliza el popular paquete Pandas:

import pandas as pd

s = pd.Series(my_list)

>>> s * 5
0     5
1    10
2    15
3    20
4    25
dtype: int64

O, si solo quiere la lista:

>>> (s * 5).tolist()
[5, 10, 15, 20, 25]

Un enfoque increíblemente más rápido es hacer la multiplicación de una manera vectorizada en lugar de recorrer la lista. Numpy ya ha proporcionado una forma muy sencilla y práctica para esto que puede utilizar.

>>> import numpy as np
>>> 
>>> my_list = np.array([1, 2, 3, 4, 5])
>>> 
>>> my_list * 5
array([ 5, 10, 15, 20, 25])

Tenga en cuenta que esto no funciona con las listas nativas de Python. Si multiplica un número con una lista, se repetirán los elementos del tamaño de ese número.

In [15]: my_list *= 1000

In [16]: len(my_list)
Out[16]: 5000

Si desea un enfoque basado en Python puro, el uso de una lista de comprensión es básicamente la forma más Pythonic a seguir.

In [6]: my_list = [1, 2, 3, 4, 5]

In [7]: [5 * i for i in my_list]
Out[7]: [5, 10, 15, 20, 25]

Además de la comprensión de la lista, como un enfoque funcional puro, también puede usar la función incorporada de la map()siguiente manera:

In [10]: list(map((5).__mul__, my_list))
Out[10]: [5, 10, 15, 20, 25]

Este código pasa todos los elementos dentro de la my_lista 5's __mul__método y devuelve un iterador-como objeto (en python-3.x). Luego puede convertir el iterador a una lista usando la list()función incorporada (en Python-2.x no lo necesita porque mapdevuelve una lista por defecto).

puntos de referencia:

In [18]: %timeit [5 * i for i in my_list]
463 ns ± 10.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [19]: %timeit list(map((5).__mul__, my_list))
784 ns ± 10.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [20]: %timeit [5 * i for i in my_list * 100000]
20.8 ms ± 115 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [21]: %timeit list(map((5).__mul__, my_list * 100000))
30.6 ms ± 169 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)


In [24]: arr = np.array(my_list * 100000)

In [25]: %timeit arr * 5
899 µs ± 4.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Puedes hacerlo en el lugar así:

 l = [1, 2, 3, 4, 5]
 l[:] = [x * 5 for x in l]

Esto no requiere importaciones adicionales y es muy pitónico.

Como creo que es nuevo en Python, hagamos el camino más largo, iteremos a través de su lista usando el bucle for y multipliquemos y agreguemos cada elemento a una nueva lista.

usando for loop

lst = [5, 20 ,15]
product = []
for i in lst:
    product.append(i*5)
print product

usando la comprensión de listas, esto también es lo mismo que usar for-loop pero más 'pitónico'

lst = [5, 20 ,15]

prod = [i * 5 for i in lst]
print prod

Con mapa (no tan bueno, pero otro enfoque al problema):

list(map(lambda x: x*5,[5, 10, 15, 20, 25]))

Además, si está utilizando matrices numpy o numpy, puede usar esto:

import numpy as np
list(np.array(x) * 5)

from functools import partial as p
from operator import mul
map(p(mul,5),my_list)

es una forma en que podrías hacerlo ... tu profesor probablemente conoce una forma mucho menos complicada que probablemente se trató en clase

Multiplicando cada elemento my_listpor k:

k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))

Resultando en: [5, 10, 15, 20]

La mejor forma es utilizar la comprensión de listas:

def map_to_list(my_list, n):
# multiply every value in my_list by n
# Use list comprehension!
    my_new_list = [i * n for i in my_list]
    return my_new_list
# To test:
print(map_to_list([1,2,3], -1))

Devuelve: [-1, -2, -3]