Contenu du cours
Techniques d'Optimisation en Python
Techniques d'Optimisation en Python
Opérations de Chaîne Efficaces
Concatenation de chaînes efficace
Lorsque vous travaillez avec de nombreuses chaînes, il est essentiel d'utiliser la méthode la plus efficace pour la concaténation. Utiliser l'opérateur + (+=) de manière répétée est inefficace pour les grands ensembles de données, car il crée une nouvelle chaîne à chaque fois. Au lieu de cela, utiliser str.join() est beaucoup plus rapide et plus économe en mémoire.
Comparons les performances de deux approches pour concaténer des chaînes avec des caractères de nouvelle ligne en une seule chaîne. La première utilise une boucle for avec l'opérateur +=, tandis que la seconde exploite la méthode plus efficace str.join().
import os decorators = 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 # Simulated lines of a report lines = [f"Line {i}" for i in range(1, 1000001)] # Inefficient concatenation @timeit_decorator(number=50) def concat_with_plus(): result = "" for line in lines: result += line + "\n" return result # Efficient concatenation @timeit_decorator(number=50) def concat_with_join(): return "\n".join(lines) + "\n" # Add final newline for consistency result_plus = concat_with_plus() result_join = concat_with_join() print(result_plus == result_join)
Précompilation des Expressions Régulières
Lorsque vous travaillez avec des expressions régulières, la performance peut devenir un problème, surtout lorsqu'il s'agit de grands ensembles de données ou de correspondances de motifs répétitives. Dans de tels cas, précompiler le motif est une technique d'optimisation utile.
La précompilation garantit que le moteur regex ne recompile pas le motif à chaque utilisation, ce qui peut améliorer considérablement la performance lorsque le même motif est appliqué plusieurs fois à travers un ensemble de données. Cette approche est particulièrement bénéfique dans des scénarios tels que le filtrage, la validation ou la recherche dans de grands fichiers texte.
Comparons la performance de deux approches pour valider des noms d'utilisateur en utilisant des expressions régulières. La première approche utilise la fonction re.match avec le motif défini en ligne à chaque appel. La deuxième approche, plus efficace, précompile le motif regex en utilisant re.compile et le réutilise pour toutes les validations.
import os import re decorators = 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 # Simulated usernames usernames = ["user123", "admin!@#", "test_user", "invalid!"] * 100000 # Naive approach @timeit_decorator(number=10) def validate_with_re(): pattern = r"^\w+$" return [bool(re.match(pattern, username)) for username in usernames] # Optimized approach @timeit_decorator(number=10) def validate_with_compiled_re(): compiled_pattern = re.compile(r"^\w+$") return [bool(compiled_pattern.match(username)) for username in usernames] result_without_precompiling = validate_with_re() result_with_precompiling = validate_with_compiled_re() print(result_without_precompiling == result_with_precompiling)
1. Vous générez un rapport avec 10000 lignes, où chaque ligne représente un résumé de transaction. Quelle méthode est la plus efficace pour combiner ces lignes en une seule chaîne avec ; entre elles ?
2. Pourquoi la précompilation d'une expression régulière avec re.compile() est-elle souvent plus rapide que l'utilisation de re.match() avec un motif inline ?
Merci pour vos commentaires !
