Comment multiplier chaque élément d'une liste par un nombre?
J'ai une liste:
my_list = [1, 2, 3, 4, 5]
Comment puis-je multiplier chaque élément de my_list par 5? Le résultat devrait être:
[5, 10, 15, 20, 25]
Vous pouvez simplement utiliser une compréhension de liste:
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]
Notez qu'une compréhension par liste est généralement un moyen plus efficace de créer une boucle for:
my_new_list = []
for i in my_list:
my_new_list.append(i * 5)
>>> print(my_new_list)
[5, 10, 15, 20, 25]
En guise d'alternative, voici une solution utilisant le populaire paquetage Pandas:
import pandas as pd
s = pd.Series(my_list)
>>> s * 5
0 5
1 10
2 15
3 20
4 25
dtype: int64
Ou, si vous voulez juste la liste:
>>> (s * 5).tolist()
[5, 10, 15, 20, 25]
Vous pouvez le faire sur place comme suit:
l = [1, 2, 3, 4, 5]
l[:] = [x * 5 for x in l]
Cela ne nécessite aucune importation supplémentaire et est très Pythonic.
Une approche extrêmement rapide consiste à effectuer la multiplication de manière vectorielle au lieu de parcourir la liste en boucle. Numpy a déjà fourni un moyen très simple et pratique pour cela que vous pouvez utiliser.
>>> import numpy as np
>>>
>>> my_list = np.array([1, 2, 3, 4, 5])
>>>
>>> my_list * 5
array([ 5, 10, 15, 20, 25])
Notez que cela ne fonctionne pas avec les listes natives de Python. Si vous multipliez un nombre par une liste, les éléments de la taille de ce nombre seront répétés.
In [15]: my_list *= 1000
In [16]: len(my_list)
Out[16]: 5000
Si vous voulez une approche purement basée sur Python utilisant une compréhension par liste, c'est la meilleure façon de faire Pythonic.
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]
En plus de la compréhension de la liste, vous pouvez également utiliser la fonction intégrée map() comme suit:
In [10]: list(map((5).__mul__, my_list))
Out[10]: [5, 10, 15, 20, 25]
Ce code transmet tous les éléments de la méthode my_list à la méthode 5__mul__ et renvoie un objet de type itérateur (en python-3.x). Vous pouvez ensuite convertir l'itérateur en liste à l'aide de la fonction intégrée list() (dans pyhton-2.x, vous n'en avez pas besoin, car map renvoie une liste par défaut).
repères:
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)
Puisque je pense que vous êtes nouveau avec Python, faisons le long chemin, parcourons votre liste en utilisant for boucle, multipliez et ajoutez chaque élément à une nouvelle liste.
en utilisant la boucle
lst = [5, 20 ,15]
product = []
for i in lst:
product.append(i*5)
print product
en utilisant la compréhension par liste, cela revient aussi à utiliser une boucle for mais plus de 'Pythonic'
lst = [5, 20 ,15]
prod = [i * 5 for i in lst]
print prod
from functools import partial as p
from operator import mul
map(p(mul,5),my_list)
est une façon de le faire ... votre professeur connaît probablement une manière beaucoup moins compliquée qui a probablement été abordée en classe
Avec la carte (pas aussi bon, mais une autre approche du problème):
list(map(lambda x: x*5,[5, 10, 15, 20, 25]))
Le meilleur moyen est d'utiliser la compréhension de liste:
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))
Retours: [-1, -2, -3]