Blogs perficient / blogs / perficient / Python Optimisation: Améliorer les performances du code

🎯 Introduction

Python est un langage de programmation incroyablement puissant et facile à utiliser. Cependant, il peut être lent sinon optimisé correctement! 😱 Ce guide vous apprendra comment turbuler votre code, le rendant plus rapide, plus maigre et plus efficace. Bouclez-vous et plongeons dans certains hacks d’optimisation épique! 💡🔥

Pour en savoir plus sur les bases de Python, consultez notre guide pour le débutant de la programmation Python.

🏎️ 1. Choisir les bonnes structures de données pour de meilleures performances

Choisir la bonne structure de données, c’est comme choisir le bon outil pour un travail – faites-le mal et vous frapperez un clou avec un tournevis! 🚧

🏗️ 1.1 listes vs tuples: Optimisez votre stockage de données

• Utilisez des tuples au lieu des listes Lorsque les éléments ne changent pas (données immuables). Les tuples ont des frais généraux plus bas et sont rapides! ⚡️

# List (mutable)
my_list = [1, 2, 3]
# Tuple (immutable, faster)
my_tuple = (1, 2, 3)

🛠️ 1.2 Utiliser des ensembles et des dictionnaires pour des recherches rapides

• Recherche dans une liste c’est comme chercher une chaussette perdue dans une pièce en désordre 🧦. D’autre part, Recherche dans un ensemble ou un dictionnaire c’est comme googler quelque chose! 🚀

# Slow list lookup (O(n))
numbers = [1, 2, 3, 4, 5]
print(3 in numbers)  # Yawn... Slow!

# Fast set lookup (O(1))
numbers_set = {1, 2, 3, 4, 5}
print(3 in numbers_set)  # Blink and you'll miss it! ⚡️

🚀 1.3 Utilisez des générateurs au lieu de listes pour l’efficacité de la mémoire

• Pourquoi stocker des millions de valeurs en mémoire alors que vous pouvez les générer à la volée? 😎

# Generator (better memory usage)
def squared_numbers(n):
    for i in range(n):
        yield i * i
squares = squared_numbers(1000000)  # No memory explosion! 💥

🔄 2. Optimisations de boucle pour le code Python plus rapide

⛔ 2.1 Évitez le calcul répété dans les boucles pour améliorer les performances

# Inefficient
for i in range(10000):
    result = expensive_function()  # Ugh! Repeating this is a performance killer 😩
    process(result)

# Optimized
cached_result = expensive_function()  # Call it once and chill 😎
for i in range(10000):
    process(cached_result)

💡 2.2 Utilisez des compréhensions de la liste au lieu de boucles traditionnelles pour le code pythonique

• Pourquoi écrire des boucles ennuyeuses alors que vous pouvez être pythonique? 🐍

# Traditional loop (meh...)
squares = []
for i in range(10):
    squares.append(i * i)

# Optimized list comprehension (so sleek! 😍)
squares = [i * i for i in range(10)]

🎭 3. Techniques d’optimisation des chaînes

🚀 3.1 Utilisez join () au lieu de la concaténation des cordes pour de meilleures performances

# Inefficient (Creates too many temporary strings 🤯)
words = ["Hello", "world", "Python"]
sentence = ""
for word in words:
    sentence += word + " "

# Optimized (Effortless and FAST 💨)
sentence = " ".join(words)

🏆 3.2 Utilisez des cordes F pour la mise en forme des chaînes dans Python (Python 3.6+)

name = "Alice"
age = 25

# Old formatting (Ew 🤢)
print("My name is {} and I am {} years old.".format(name, age))

# Optimized f-string (Sleek & stylish 😎)
print(f"My name is {name} and I am {age} years old.")

⏳ 4.1 Utilisez du temps pour mesurer le temps d’exécution

import timeit
print(timeit.timeit("sum(range(1000))", number=10000))  # How fast is your code? 🚀

🧐 4.2 Utiliser le CPROFILE pour un profilage de performances détaillé

import cProfile
cProfile.run('my_function()')  # Find bottlenecks like a pro! 🔍

Pour en savoir plus sur le profilage, consultez notre guide des outils de profilage Python.

🧠 5. Techniques d’optimisation de la mémoire

🔍 5.1 Utiliser sys.getSizeOf () pour vérifier l’utilisation de la mémoire

import sys
my_list = [1, 2, 3, 4, 5]
print(sys.getsizeof(my_list))  # How big is that object? 🤔

🗑️ 5.2 Utilisez Del et GC.Collect () pour gérer la mémoire

import gc
large_object = [i for i in range(1000000)]
del large_object  # Say bye-bye to memory hog! 👋
gc.collect()  # Cleanup crew 🧹

⚡ 6. Traitement parallèle et multithreading

🏭 6.1 Utiliser le multiprocessement pour les tâches liées au CPU

from multiprocessing import Pool

def square(n):
    return n * n

with Pool(4) as p:  # Use 4 CPU cores 🏎️
    results = p.map(square, range(100))

🌐 6.2 Utiliser le filetage pour les tâches liées aux E / S

import threading

def print_numbers():
    for i in range(10):
        print(i)

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

Pour en savoir plus sur le traitement parallèle, consultez notre introduction à Python Multithreading.

🎉 Conclusion

Félicitations! 🎊 Vous avez débloqué le plein potentiel de Python en apprenant ces astuces d’optimisation des tueurs. Allez maintenant et écrivez un code Python en fast-fast, économe en mémoire et propre. 🚀🐍

Vous avez des hacks d’optimisation préférés? Déposez-les dans les commentaires! 💬🔥

Pour des informations plus détaillées sur l’optimisation de Python, consultez ces ressources: