5 conseils d’optimisation pour de meilleures performances Python | de Dmytro Khmelenko | décembre 2022

Élevez l’efficacité de votre code au niveau supérieur

Python est devenu célèbre en tant que langage de programmation au cours de la dernière décennie. C’est un excellent instrument qui aide non seulement au développement backend mais aussi à la science des données et à l’automatisation.

La simplicité de la langue permet à n’importe qui de commencer à l’apprendre. Python a une syntaxe simple et cela aide beaucoup dans la construction de logiciels.

Cependant, il existe de nombreux pièges et un code inefficace peut ralentir considérablement les performances.

La bonne nouvelle est qu’il est possible d’éviter de tels problèmes. Python a des recommandations sur la façon de rendre votre code plus rapide. Quels sont ces? Explorons.

Les développeurs Python essaient d’obtenir les meilleures performances sur les actions les plus courantes. Ils ont implémenté les fonctions pour couvrir ces actions. Par exemple, nous avons min(), max(), sum() et bien d’autres fonctions pratiques.

Ils sont intégrés et disponibles sans aucune importation supplémentaire. Et ils démontrent de bonnes performances.

Ainsi, chaque fois que vous devez additionner tous les éléments du tableau, pensez à utiliser une fonction intégrée sum() au lieu d’implémenter votre propre algorithme.

Set est une autre structure de données souvent oubliée. Les ingénieurs logiciels utilisent activement des listes et des dictionnaires, mais rarement des ensembles.

Pourtant, lorsqu’il s’agit de trouver des éléments uniques dans la collection ou de vérifier rapidement l’inclusion, un ensemble fait preuve d’une performance extrême.

collection = [x for x in range(100_000)]
exists = 1000 in collection
>> Duration: 0.000015020
collection = set(x for x in range(100_000))
exists = 1000 in collection
>> Duration: 0.000001907

Dans l’exemple ci-dessus, nous voyons que vérifier la présence d’un élément dans un ensemble est ~7x plus rapide que dans une liste.

Si vous avez besoin de parcourir la collection et d’avoir des index, la meilleure façon d’y parvenir est d’utiliser enumerate.

Cette option est plus rapide que de parcourir le range. De plus, nous n’avons pas besoin d’accéder à l’élément par index car enumerate fait ça pour nous.

collection = range(0, 1_000_000)
for i in range(len(collection)):
print(collection[i])
>> Duration: 0.114128828
collection = range(0, 1_000_000)
for i, number in enumerate(collection):
print(number)
>> Duration: 0.062491894

On voit que le cas avec enumerate est presque deux fois plus rapide que le cas avec range dans cet exemple. C’est parce qu’à l’intérieur enumerate génère un objet spécial pour l’énumération. Il renvoie efficacement l’élément et l’index en une seule fois.

La compréhension de liste est une fonctionnalité largement utilisée dans Python. La boucle dans la liste et la conversion des éléments ne peuvent se faire que sur une seule ligne.

Mais un point supplémentaire est qu’il a de bonnes performances. Comparons-le avec le régulier for boucle.

collection = range(0, 1_000_000)
newlist = []
for item in collection:
newlist.append(item)
>> Duration: 0.065476894
collection = range(0, 1_000_000)
newlist = [item for item in collection]
>> Duration: 0.024003267

Cet exemple montre que la compréhension de liste est trois fois plus rapide.

Les débutants ont généralement du mal avec la syntaxe de cette fonctionnalité, en particulier lorsqu’il y a quelques niveaux imbriqués. Mais une fois qu’ils le maîtriseront, ils l’appliqueront partout.

Lorsque nous pensons ensemble à la concaténation de chaînes, le premier qui nous vient à l’esprit est un opérateur +. Parce que c’est intuitif. Lorsque la première chaîne est 'hello,' et la deuxième chaîne est 'world'. Pour les combiner, il faut écrire 'hello,' + 'world'.

Le problème avec cette façon de concaténation de chaînes est la performance. Sur tout + opération, une nouvelle chaîne sera créée. Combiner deux cordes de cette manière n’est pas un gros problème. Mais en ce qui concerne le plus grand nombre de chaînes, vous constaterez une dégradation des performances.

Le moyen efficace de concaténer des chaînes consiste à utiliser join() fonction.

strings = ["Python", "is", "amazing", "when", "you", "follow", "pro", "tips", "and", "advice"]
string_concat = ""
for s in strings:
string_concat += s
>> Duration: 0.000010014
strings = ["Python", "is", "amazing", "when", "you", "follow", "pro", "tips", "and", "advice"]
string_concat = "".join(strings)
>> Duration: 0.000002861

La performance est déjà visible sur un petit nombre de cordes. Mais la différence deviendra plus grande avec l’augmentation du nombre de chaînes à concaténer.

La liste pour améliorer les performances de votre code Python peut s’allonger. Certains des conseils ne peuvent appartenir qu’à un scénario spécifique.

Les conseils que nous avons couverts dans cet article sont considérés comme les meilleures pratiques en Python. Vous ne remarquerez probablement aucune différence sur les petits ensembles de données. Mais lorsque le nombre de données que vous devez traiter est suffisamment important, vous constaterez des gains de performances significatifs.