El nombre de las variables que comienza con mayúsculas no es Pythonic. Y son listas, no números. Así que sugiero usar l1y l2como nombre de variable.
Casimir Crystal
4
También se desaconseja el uso de 'l' como variable porque la letra 'l' y el número 1 se confunden fácilmente. Usé las variables en la pregunta original del OP, y creo que su edición de la pregunta hizo más daño que bien.
Alexander
1
Si cree que mi edición es mala, puede editar la pregunta para mejorarla. Además, podemos elegir otra variable en lugar de l1como l_1, list_1, etc. Estos son todos mejores que Num_1.
Casimir Crystal
26
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.
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 * 5899 µs ± 4.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Me interesa saber por qué el método numpy es "increíblemente más rápido". ¿Podría darme más detalles o señalarme algunos recursos? No estoy seguro de qué es la vectorización.
@Kasramvd Ese enlace es incorrecto. El enlace analiza un significado diferente de vectorización como una sola instrucción-múltiples-datos (aplicando una operación a muchos datos a la vez, como lo hacen las GPU). En el contexto de NumPy, la vectorización se refiere al uso de bucles C rápidos precompilados para operar en una secuencia de datos, en lugar de Python puro.
Además: el concepto se llama comprensión de listas si quieres buscar más información al respecto.
Michael
1
Prefiero l = [x * 5 for x in l]terminar l[:] = [x * 5 for x in l]. Este último crea una nueva lista, luego la usa para sobrescribir el contenido de len lugar de simplemente reasignar la referencia que es más barata. Si realmente le preocupa el espacio, simplemente repita con un bucle y mute en el lugar.
cs95
6
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 * 5for i in lst]
print prod
¿Cómo es mejor el "camino largo"? Es más largo, por lo tanto más difícil de leer, y no más fácil de escribir.
lirtosiast
1
bueno, tal vez tuviste una impresión equivocada en mi título y nunca dije que fuera mejor, solo trato de mostrarle cómo hacerlo sin usar la comprensión. porque en mi experiencia cuando era nuevo en Python no podía captar fácilmente el concepto de comprensión.
wasp8898
Ah, vale. No puedo relacionarme directamente porque comencé con lenguajes funcionales.
lirtosiast
Ya veo, bueno ahí. Edité la respuesta para incluir también la forma eficiente de hacerlo.
wasp8898
4
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:
Puede hacerlo sin las declaraciones de importación utilizando una expresión lambda. Además, su fragmento devuelve un objeto de mapa, que es inútil a menos que se envíe a una lista. lista (mapa (lambda x: 5 * x, mi_lista)).
Castle-Bravo
@ castle-bravo su utilidad depende de lo que necesites hacer con él ... hay muchas formas de lograr esta solución (como menciono ...)
Joran Beasley
4
Por favor, no enseñe a la gente a usar mapcon lambda; en el instante en que necesite una lambda, habría estado mejor con una comprensión de lista o una expresión generadora. Si eres inteligente, que puede hacer mapel trabajo sin lambdamucha sa, por ejemplo, en este caso, map((5).__mul__, my_list)aunque en este caso en particular, gracias a algunas optimizaciones en el intérprete de código de bytes para los simplesint matemáticas, [x * 5 for x in my_list]es más rápido, además de ser más y más simple Pythonic .
ShadowRanger
1
Multiplicando cada elemento my_listpor k:
k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))
La mejor forma es utilizar la comprensión de listas:
defmap_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))
Esto solo toma la respuesta aceptada y la convierte en una función. Probablemente podría hacer eso con más de la mitad de las respuestas en SO, pero no agrega nada y no es lo que pidió el OP.
mapes mejor quefor-loop.map(y siempre mejor simapse requiere alambda).Respuestas:
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: int64O, si solo quiere la lista:
>>> (s * 5).tolist() [5, 10, 15, 20, 25]fuente
l1yl2como nombre de variable.l1comol_1,list_1, etc. Estos son todos mejores queNum_1.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]: 5000Si 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_lista5's__mul__método y devuelve un iterador-como objeto (en python-3.x). Luego puede convertir el iterador a una lista usando lalist()función incorporada (en Python-2.x no lo necesita porquemapdevuelve 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)fuente
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.
fuente
l = [x * 5 for x in l]terminarl[:] = [x * 5 for x in l]. Este último crea una nueva lista, luego la usa para sobrescribir el contenido delen lugar de simplemente reasignar la referencia que es más barata. Si realmente le preocupa el espacio, simplemente repita con un bucle y mute en el lugar.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 productusando 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 prodfuente
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)fuente
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
fuente
mapconlambda; en el instante en que necesite unalambda, habría estado mejor con una comprensión de lista o una expresión generadora. Si eres inteligente, que puede hacermapel trabajo sinlambdamucha sa, por ejemplo, en este caso,map((5).__mul__, my_list)aunque en este caso en particular, gracias a algunas optimizaciones en el intérprete de código de bytes para los simplesintmatemáticas,[x * 5 for x in my_list]es más rápido, además de ser más y más simple Pythonic .Multiplicando cada elemento
my_listpork:k = 5 my_list = [1,2,3,4] result = list(map(lambda x: x * k, my_list))Resultando en:
[5, 10, 15, 20]fuente
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]
fuente