Comment multiplier chaque élément d'une liste par un nombre?

J'ai une liste:

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

Comment multiplier chaque élément my_listpar 5? La sortie doit ê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 de liste est généralement un moyen plus efficace de faire une forboucle:

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

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

Comme alternative, voici une solution utilisant le package Pandas populaire:

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]

Une approche incroyablement plus rapide consiste à faire la multiplication de manière vectorisée au lieu de boucler sur la liste. 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 l 'seront répétés comme la taille de ce nombre.

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 de liste, c'est fondamentalement le moyen le plus pythonique.

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]

Outre la compréhension de la liste, en tant qu'approche fonctionnelle pure, vous pouvez également utiliser la map()fonction intégrée comme suit:

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

Ce code passe tous les éléments contenus dans ce my_listà 5de » __mul__la méthode et renvoie un itérateur de type objet (en python-3.x). Vous pouvez ensuite convertir l'itérateur en liste à l'aide list()de la fonction intégrée (en Python-2.x, vous n'en avez pas besoin car maprenvoyez 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)

Vous pouvez le faire sur place comme ceci:

 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 pythonique.

Puisque je pense que vous êtes nouveau avec Python, faisons le long chemin, parcourez votre liste en utilisant la boucle for et multipliez et ajoutez chaque élément à une nouvelle liste.

utilisation de la boucle for

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

en utilisant la compréhension de liste, c'est aussi la même chose que l'utilisation de la boucle for mais plus `` pythonique ''

lst = [5, 20 ,15]

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

Avec la carte (pas aussi bonne, mais une autre approche du problème):

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

aussi, si vous utilisez des tableaux numpy ou numpy, vous pouvez utiliser ceci:

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)

est une façon dont vous pourriez le faire ... votre professeur connaît probablement une méthode beaucoup moins compliquée qui a probablement été abordée en classe

Multiplier chaque élément my_listpar k:

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

résultant en: [5, 10, 15, 20]

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

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