Je me souviens encore de la fois où j’ai écrit un script Python dans lequel je devais traiter un grand ensemble de données. Il s’agissait d’un petit projet, mais pour traiter autant de données, j’ai dû attendre… attendre… attendre longtemps.
La tâche qui aurait pu être réalisée en quelques minutes s’est éternisée pendant des heures.
Puis, j’ai compris que quelque chose n’allait pas. Mon code n’était pas optimisé, j’ai donc appris à optimiser mon code après de nombreuses tentatives. Cela a permis d’accélérer mon script Python de 300%.
Voyons étape par étape ce que j’ai fait.
#1. Profile d’abord ton code
Tout d’abord, nous devons déterminer quelle partie du code est à l’origine de la lenteur.
En Python, nous pouvons utiliser cProfile, qui nous aide à comprendre quelle partie du programme prend le plus de temps.
Voyons comment je l’utilise :
import cProfile
def my_script():
# Ton code ici
pass
cProfile.run('my_script()')
Il nous donnera une ventilation détaillée du temps que prend chaque fonction.
Lorsque j’ai utilisé cProfile dans mon script, j’ai constaté que 80 % du temps d’exécution de mon script était consacré à deux fonctions seulement. J’ai donc décidé d’optimiser ces fonctions.
#2. Utiliser des fonctions intégrées
Comme nous le savons déjà, les fonctions intégrées (built-in) de Python sont écrites en C, elles seront beaucoup plus rapides à exécuter que les fonctions que nous écrirons en Python.
Dans mon code, j’ai utilisé une boucle for pour additionner les nombres d’une liste :
total = 0
for num in my_list:
total += num
Je l’ai donc remplacée par la fonction intégrée sum de Python :
total = sum(my_list)
Cela réduit simplement la durée d’exécution de cette partie de mon code de 50 %.
#3. Utiliser des listes de compréhension au lieu de boucles
Je sais que les boucles sont faciles à écrire, mais pas toujours les plus rapides. J’ai un code qui crée une nouvelle liste à partir d’une liste existante en utilisant une boucle for :
new_list = []
for item in old_list:
if item > 10:
new_list.append(item)
J’ai remplacé ce code par liste de compréhension :
new_list = [item for item in old_list if item > 10]
Grâce à ce changement, mon code ci-dessus est deux fois plus rapide.
#4. Éviter les variables globales
Les variables globales peuvent ralentir notre script car Python doit vérifier de nombreux scopes pour trouver la valeur des variables globales.
J’ai utilisé une variable globale counter dans une fonction :
counter = 0
def count_items(items):
global counter
for item in items:
counter += 1
Mais j’ai décidé de déplacer cette variable à l’intérieur d’une fonction, comme ceci :
def count_items(items):
counter = 0
for item in items:
counter += 1
Ce changement m’aide beaucoup à augmenter la vitesse de mon script.
#5. Remplacer les boucles régulières par NumPy
J’ai d’abord utilisé des listes Python pour traiter mes données numériques, puis j’ai réalisé que je devais utiliser NumPy pour cela.
Par exemple, je devais multiplier chaque élément de la liste par 2. Avant NumPy, je faisais comme ceci :
result = [x * 2 for x in my_list]
Mais avec NumPy, cela donne ça :
import numpy as np array = np.array(my_list) result = array * 2
Et cette version de NumPy fonctionne 10x plus vite si nous avons de grandes listes (car NumPy est construit en C).
#6. Utiliser des générateurs pour les données volumineuses
Dans mon script, j’avais une fonction qui traitait un grand ensemble de données. J’utilisais des listes pour stocker ses résultats intermédiaires, ce qui utilisait la majeure partie de la mémoire et ralentissait tout.
squares = [x**2 for x in range(1_000_000)]
Puis j’ai commencé à utiliser des générateurs, qui traitent les éléments de manière séquentielle et non pas en une seule fois.
squares = (x**2 for x in range(1_000_000))
Cela m’aide à réduire l’utilisation de la mémoire et donc à améliorer mon script.
#7. Traitement parallèle avec multiprocessing
J’ai obtenu les meilleurs résultats lorsque j’ai appris à connaître les cœurs multiples de l’unité centrale.
Comme tu le sais, par défaut, Python fonctionne sur un seul cœur. Mais si nous utilisons la bibliothèque multiprocessing, il peut répartir les tâches sur les autres cœurs disponibles.
Laisse-moi t’expliquer comment j’ai procédé :
from multiprocessing import Pool
def process_data(item):
# Ta logique de traitement ici
return item * 2
if __name__ == "__main__":
with Pool() as pool:
results = pool.map(process_data, my_list)
Cette simple modification permet à mon script d’augmenter sa vitesse de 100 %, car certaines tâches peuvent désormais être exécutées en parallèle.
#8. Éviter de répéter le travail
Auparavant, j’avais une fonction qui calculait toujours le même résultat.
for item in my_list:
result = expensive_function(item)
print(result)
Mais ensuite, j’ai décidé de stocker ce résultat dans une seule variable :
cache = {}
for item in my_list:
if item not in cache:
cache[item] = expensive_function(item)
print(cache[item])
Nous pouvons appeler cette technique la mémorisation et elle m’aide à gagner beaucoup de temps.
#9. Optimiser les importations
Auparavant, pour utiliser ne serait-ce qu’une seule fonction de la bibliothèque, j’avais l’habitude d’importer toute la bibliothèque.
import pandas
result = pandas.read_csv("data.csv")
Mais j’ai décidé de changer de méthode, j’ai simplement importé cette fonction de la bibliothèque dont j’ai besoin :
from pandas import read_csv
result = read_csv("data.csv")
Cette méthode ne s’est pas contentée d’accélérer mon script, elle m’a également permis de réduire le temps de démarrage de mon script.
#10. Utiliser la dernière version de Python
Auparavant, j’utilisais l’ancienne version de Python. Je suis donc passé à la version la plus récente et j’ai constaté une augmentation sensible de la vitesse de mon script, même sans changer une seule ligne de code.
Si je peux augmenter la vitesse de mon script, tu peux aussi le faire. Il suffit d’avoir la patience et la volonté d’expérimenter.
Essaye ces étapes sur ton code Python et dis-moi si ces méthodes t’aident ou non 🙂
