Contenu du cours
Techniques d'Optimisation en Python
Techniques d'Optimisation en Python
Tirer Parti de map() et des Compréhensions de Liste
Dans la mesure du possible, il est préférable de s'appuyer sur les fonctions intégrées, méthodes ou fonctions de bibliothèque plutôt que de créer des algorithmes à partir de zéro. Les fonctions intégrées et de bibliothèque sont généralement optimisées pour la performance, s'exécutent plus efficacement et sont conçues pour gérer efficacement une large gamme de cas particuliers.
Commençons par des outils puissants comme la fonction map() et les compréhensions de liste, qui peuvent considérablement accélérer votre code. Étant donné que les compréhensions de liste sont plus optimisées pour la performance et que map() est implémenté en C, elles s'exécutent généralement plus rapidement que les boucles écrites manuellement.
Compréhensions de Liste
Les compréhensions de liste offrent un moyen plus concis et souvent plus rapide de créer des listes par rapport aux boucles for traditionnelles. De plus, elles peuvent rendre votre code plus facile à lire et à comprendre.
Comparons la performance d'une boucle for et d'une compréhension de liste en générant une liste où chaque nombre de 1 à 10000000 est multiplié par 2 :
import os os.system('wget https://content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null') from decorators import timeit_decorator numbers = list(range(1, 10000001)) @timeit_decorator(number=3) def list_comprehension(): return [x * 2 for x in numbers] @timeit_decorator(number=3) def for_loop(): result = [] for x in numbers: result.append(x * 2) return result list_1 = list_comprehension() list_2 = for_loop() print(list_1 == list_2)
Utilisation de map()
La fonction map applique une fonction spécifiée à chaque élément d'un itérable (par exemple, une liste).
En plus d'être plus concise que l'écriture de boucles, elle est souvent plus rapide grâce aux optimisations au niveau C dans son implémentation, ce qui réduit le surcoût des appels de fonction répétés.
Bien que map puisse offrir certains avantages de performance, surtout lorsqu'on travaille avec des fonctions intégrées, la différence de vitesse par rapport aux compréhensions de liste est souvent négligeable. Les deux sont hautement optimisés, et pour des opérations simples, l'avantage de performance de map est à peine perceptible. En pratique, le choix entre les deux devrait être basé davantage sur la lisibilité et des cas d'utilisation spécifiques, tels que l'efficacité mémoire avec map.
Comparons la performance de map, des boucles for, et des compréhensions de liste lors du formatage de 1000000 noms de clients en majuscules (par exemple, 'john doe' -> 'John Doe'):
import os os.system('wget https://content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null') from decorators import timeit_decorator customer_names = ['john doe', 'jane smith', 'alex johnson', 'ivan smith'] * 250000 @timeit_decorator(number=10) def map_function(): return list(map(str.title, customer_names)) @timeit_decorator(number=10) def list_comprehension(): return [name.title() for name in customer_names] @timeit_decorator(number=10) def for_loop(): result = [] for name in customer_names: result.append(name.title()) return result formatted_with_map = map_function() formatted_with_comprehension = list_comprehension() formatted_with_for_loop = for_loop() print(formatted_with_map == formatted_with_comprehension == formatted_with_for_loop)
Comme prévu, la boucle for est l'approche la plus lente des trois. Dans cet exemple, map s'est avéré plus rapide que la compréhension de liste, bien qu'en pratique, les performances puissent varier en fonction du cas d'utilisation spécifique. Parfois, les compréhensions de liste peuvent même surpasser map, surtout pour des expressions plus simples.
Merci pour vos commentaires !
