Contenu du cours

Techniques d'Optimisation en Python

1. Comprendre et Mesurer la Performance

Introduction à la Performance de Python Notions de Base sur le Chronométrage et le Benchmarking Mesurer la Performance des Fonctions Défi : Mise en Œuvre du Benchmarking

2. Utilisation Efficace des Structures de Données

Listes et Tableaux NumPy Ensembles et Tuples Défi : Choisir des Structures de Données Optimales Utilisation du Module Collections Défi : Gestion des Demandes des Clients

3. Améliorer les Performances avec des Outils Intégrés

Tirer Parti de map() et des Compréhensions de Liste Gestion des Fichiers Volumineux Maximiser l'Efficacité du Tri Opérations de Chaîne Efficaces

Notions de Base sur le Chronométrage et le Benchmarking

Puisque nous ne mettons pas l'accent sur l'analyse de la complexité temporelle dans ce cours, nous nous concentrerons sur les méthodes empiriques (pratiques) pour mesurer la performance réelle du code. L'une des façons les plus simples de mesurer la performance d'un extrait de code est d'utiliser la fonction intégrée time.time().

Cette fonction renvoie le temps actuel en secondes depuis l'époque (le point de référence du système pour le temps). En appelant time.time() avant et après un morceau de code, vous pouvez calculer la différence pour voir combien de temps il faut pour exécuter.


              123456789101112131415
            
import time

# Record the start time
start_time = time.time() 

# Code you want to measure
result = [x**2 for x in range(1000000)]

# Record the end time
end_time = time.time()

# Calculate the difference to get the execution time
execution_time = end_time - start_time

print(f'Execution time: {execution_time} seconds')

Bien que l'utilisation de time.time() soit simple et efficace pour des estimations approximatives, elle présente plusieurs limitations :

Basse résolution : la précision de time.time() peut varier en fonction du système d'exploitation, entraînant des résultats inexacts pour les petites opérations ;
Surcharge : elle inclut d'autres processus système s'exécutant en arrière-plan, ce qui peut fausser la mesure ;
Ne se répète pas : pour des mesures plus précises, il est souvent nécessaire d'exécuter le même code plusieurs fois pour obtenir un résultat moyen, ce que time.time() ne gère pas automatiquement.

Avantages de l'utilisation de timeit

Le module timeit est un outil plus avancé conçu pour surmonter les limitations de time.time() et fournir un moyen fiable de mesurer le temps d'exécution de petits extraits de code, souvent appelés micro-benchmarking.

Les principaux avantages de timeit sont :

Haute précision : timeit utilise time.perf_counter() en interne, un minuteur haute résolution qui inclut le temps passé en sommeil et en attente d'E/S, le rendant plus précis pour les courts intervalles que time.time();
Répétition automatique : timeit exécute automatiquement le code plusieurs fois et calcule le temps d'exécution moyen. Cela aide à atténuer les effets des processus en arrière-plan, fournissant une mesure plus fiable des performances du code;
Surcharge minimale : timeit est conçu pour fonctionner dans un environnement propre, désactivant temporairement la collecte des ordures pour s'assurer que les mesures se concentrent sur le code en cours de benchmarking sans interférence des opérations de gestion de la mémoire.


              1234567
            
import timeit
# Code snippet to test
code_snippet = 'result = [x**2 for x in range(1000000)]'
# Running timeit to measure execution time
iterations = 30
execution_time = timeit.timeit(code_snippet, number=iterations)
print(f'Average Execution Time: {execution_time / iterations} seconds')

Dans cet exemple, timeit.timeit() exécute le code spécifié sous forme de chaîne (variable code_snippet) 30 fois (spécifié par le paramètre number) et renvoie le temps d'exécution total pour les 30 exécutions. En divisant le temps total par le nombre d'itérations (30), nous pouvons calculer le temps d'exécution moyen pour une seule exécution.

Choisir le Nombre d'Itérations

Le choix du nombre d'itérations dépend de la complexité du code que vous évaluez et de la précision que vous souhaitez dans les résultats de chronométrage. Exécuter votre code avec des comptes d'itérations variés vous permet d'évaluer la stabilité des résultats ; si les temps d'exécution sont cohérents, vous avez probablement trouvé un nombre d'itérations optimal.

Pour des extraits de code très rapides (millisecondes ou moins), visez 1000+ itérations pour obtenir des moyennes fiables. Pour du code modérément chronométré (quelques millisecondes à secondes), 100 à 500 itérations devraient suffire. Pour du code s'exécutant plus longtemps (plusieurs secondes ou plus), 10 à 50 itérations fourniront généralement un bon équilibre entre précision et temps passé à évaluer.

1. Quelle fonction offre une haute précision et exécute automatiquement le code plusieurs fois pour calculer un temps d'exécution moyen ?

2. Pourquoi l'utilisation de `time.time()` pour la mesure des performances pourrait-elle être moins fiable que `timeit.timeit()` ?

Tout était clair ?

Merci pour vos commentaires !