Le nom des variables qui commence par des majuscules n'est pas Pythonic. Et ce sont des listes, pas des nombres. Je suggérerais donc d'utiliser l1et l2comme nom de variable.
Casimir Crystal
4
L'utilisation de «l» comme variable est également déconseillée car la lettre «l» et le nombre 1 sont facilement confondus. J'ai utilisé les variables dans la question initiale du PO, et je pense que votre modification de la question a fait plus de mal que de bien.
Alexander
1
Si vous pensez que ma modification est mauvaise, vous pouvez modifier la question pour l'améliorer. Aussi, nous pouvons choisir d' autres variables plutôt que par l1exemple l_1, list_1etc. Ce sont tous mieux que Num_1.
Casimir Crystal
26
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.
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 * 5899 µs ± 4.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Je suis intéressé par la raison pour laquelle la méthode numpy est «incroyablement plus rapide»? Pourriez-vous me donner des détails ou m'indiquer certaines ressources? Je ne sais pas ce qu'est la vectorisation.
@Kasramvd Ce lien est incorrect. Le lien traite d'une signification différente de la vectorisation en tant que données multiples à instruction unique (application d'une opération à plusieurs données à la fois, comme le font les GPU). Dans le contexte de NumPy, la vectorisation fait référence à l'utilisation de boucles C précompilées rapides pour opérer sur une séquence de données, plutôt que sur du Python pur.
De plus: le concept est appelé compréhension de liste si vous souhaitez rechercher plus d'informations à ce sujet.
Michael le
1
Je préfère l = [x * 5 for x in l]plus l[:] = [x * 5 for x in l]. Ce dernier crée une nouvelle liste, puis l'utilise pour écraser le contenu de lplutôt que de simplement réaffecter la référence qui est moins chère. Si vous êtes réellement préoccupé par l'espace, itérez simplement avec une boucle et mute sur place.
cs95
6
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 * 5for i in lst]
print prod
En quoi le "long chemin" est-il de quelque façon meilleur? C'est plus long - donc plus difficile à lire - et pas plus facile à écrire.
lirtosiast
1
ok peut-être que vous avez eu une mauvaise impression sur mon titre et je n'ai jamais dit que c'était mieux, juste en essayant de lui montrer comment le faire sans utiliser la compréhension. car d'après mon expérience quand j'étais nouveau en python, je n'ai pas pu saisir facilement le concept de compréhension.
wasp8898
Ah d'accord. Je ne peux pas me rapporter directement car j'ai commencé avec des langages fonctionnels.
lirtosiast le
Je vois, bien là. J'ai édité la réponse pour inclure également la manière efficace de le faire.
wasp8898
4
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:
Pourquoi ne pas utiliser une fonction lambda au lieu de définir la fonction timesfive?
Vimanyu le
2
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
Vous pouvez le faire sans les instructions d'importation à l'aide d'une expression lambda. En outre, votre extrait de code renvoie un objet de carte, qui est inutile à moins d'être converti en liste. liste (carte (lambda x: 5 * x, ma_liste)).
castle-bravo
@ castle-bravo son utilité dépend de ce que vous devez en faire ... il existe de nombreuses façons d'accomplir cette solution (comme je le mentionne ...)
Joran Beasley
4
Veuillez ne pas apprendre aux gens à utiliser mapavec lambda; au moment où vous avez besoin d'un lambda, vous auriez été mieux avec une compréhension de liste ou une expression de générateur. Si vous êtes intelligent, vous pouvez faire le maptravail sans lambdabeaucoup de sa, par exemple dans ce cas, map((5).__mul__, my_list)bien que dans ce cas particulier, grâce à quelques optimisations dans l'interpréteur de code octet pour de simples intmathématiques, [x * 5 for x in my_list]est plus rapide, tout en étant plus Pythonic et plus simple .
ShadowRanger
1
Multiplier chaque élément my_listpar k:
k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))
Le meilleur moyen est d'utiliser la compréhension de liste:
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))
Cela prend juste la réponse acceptée et la transforme en fonction. Vous pourriez probablement faire cela avec plus de la moitié des réponses sur SO, mais cela n'ajoute rien et n'est pas ce que le PO a demandé.
mapvaut mieux quefor-loop.map(et toujours meilleure simapcela nécessiterait alambda).Réponses:
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: int64Ou, si vous voulez juste la liste:
>>> (s * 5).tolist() [5, 10, 15, 20, 25]la source
l1etl2comme nom de variable.l1exemplel_1,list_1etc. Ce sont tous mieux queNum_1.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]: 5000Si 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'aidelist()de la fonction intégrée (en Python-2.x, vous n'en avez pas besoin carmaprenvoyez 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)la source
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.
la source
l = [x * 5 for x in l]plusl[:] = [x * 5 for x in l]. Ce dernier crée une nouvelle liste, puis l'utilise pour écraser le contenu delplutôt que de simplement réaffecter la référence qui est moins chère. Si vous êtes réellement préoccupé par l'espace, itérez simplement avec une boucle et mute sur place.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 producten 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 prodla source
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)la source
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
la source
mapaveclambda; au moment où vous avez besoin d'unlambda, vous auriez été mieux avec une compréhension de liste ou une expression de générateur. Si vous êtes intelligent, vous pouvez faire lemaptravail sanslambdabeaucoup de sa, par exemple dans ce cas,map((5).__mul__, my_list)bien que dans ce cas particulier, grâce à quelques optimisations dans l'interpréteur de code octet pour de simplesintmathématiques,[x * 5 for x in my_list]est plus rapide, tout en étant plus Pythonic et plus simple .Multiplier chaque élément
my_listpark:k = 5 my_list = [1,2,3,4] result = list(map(lambda x: x * k, my_list))résultant en:
[5, 10, 15, 20]la source
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]
la source