Apprendre Exploitation de map() et des Compréhensions de Liste | Amélioration des Performances avec les Outils Intégrés

Dans la mesure du possible, il est préférable de s'appuyer sur des 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 un large éventail de cas particuliers.

Commençons par des outils puissants comme la fonction map() et les compréhensions de liste, qui peuvent accélérer considérablement votre code. Les compréhensions de liste sont plus optimisées pour la performance et map() est implémenté en C, elles s'exécutent donc généralement plus rapidement que les boucles écrites manuellement.

Compréhensions de liste

Les compréhensions de liste offrent une manière plus concise et souvent plus rapide de créer des listes par rapport aux boucles for traditionnelles. De plus, elles peuvent rendre votre code plus lisible et compréhensible.

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 :


              123456789101112131415161718192021
            
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 s’exécute souvent plus rapidement grâce à des optimisations au niveau C dans son implémentation, ce qui réduit la surcharge des appels de fonction répétés.

Bien que map puisse offrir certains avantages de performance, en particulier lors de l’utilisation de 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ées et, pour des opérations simples, l’avantage de performance de map est à peine perceptible. En pratique, le choix entre les deux doit davantage se baser sur la lisibilité et des cas d’utilisation spécifiques, comme l’efficacité mémoire avec map.

Comparaison des performances de map, des boucles for et des compréhensions de liste lors du formatage de 1000000 noms de clients en casse titre (par exemple, 'john doe' -> 'John Doe') :


              1234567891011121314151617181920212223242526
            
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 selon le cas d'utilisation spécifique. Parfois, les compréhensions de liste peuvent même surpasser map, en particulier pour des expressions plus simples.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 1

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you explain how the timeit_decorator works in these examples?

What are the main advantages of using map over list comprehensions?

When should I choose a for loop instead of map or list comprehensions?

Awesome!

Completion rate improved to 7.69

Glissez pour afficher le menu