Les compréhensions Python pour un code plus performant

Les compréhensions Python permettent de créer une séquence à partir d’une autre, généralement avec des modifications en cours de route.

Les compréhensions Python fournissent une syntaxe simple et compacte pour créer une séquence en effectuant une opération sur chaque élément. C’est un moyen plus rapide que l’utilisation d’une boucle for.

Utilisez les compréhension là où elles sont faciles à appliquer. Cependant, l’utilisation des compréhensions présente un avantage substantiel en termes de performances. une fonction map() est environ deux fois plus rapide qu’une boucle for. Une compréhension est généralement légèrement plus rapide que l’utilisation de map().

compréhensions Python

Les compréhension de liste

En plus d’être plus concis et lisibles que les boucles, les compréhensions de listes sont plus rapides.
On obtient un résultat similaire à celui d’une boucle for ou d’une fonction map(). Elles sont plus pratiques lorsque nous devons appliquer une expression à une séquence.

Supposons que nous voulions créer une liste contenant chaque lettre à partir d’une chaîne de caractère. Nous pouvons le faire en utilisant une boucle for :

lettres=[]
for i in 'python':
    lettres.append(i)
print(lettres)

L’exécution de ce code nous donne :

['p', 'y', 't', 'h', 'o', 'n']

En fait, l’utilisation d’une compréhension de liste vous donnera le même résultat.

lettres = [i for i in 'python']
print(lettres)

Nous allons créer une liste de tous les nombres pairs entre 1 et 20.

Avec un code classique nous écrirons.

pairs=[]
for i in range(1,21):
    if i % 2 == 0:
        pairs.append(i)
print(pairs)

Le résultat :

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Cependant, avec une compréhension de liste nous aurons un code meilleur.

pairs = [x for x in range(1, 21) if x % 2 == 0]
print(pairs)

Ce qui nous donne :

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

De plus, nous pouvons utiliser des conditions imbriquées dans les compréhension Python.

pairs = [x for x in range(1, 21) if x % 2 == 0 if x % 4 == 0]
print(pairs)

Ce qui nous donne :

[4, 8, 12, 16, 20]

Ou encore, des compréhensions imbriquées avec des boucles for.

ma_list = []
for lettre in 'abc':
    for nombre in range(1, 4):
        ma_list.append((lettre, nombre))
print(ma_list)

Ce code nous donne :

[('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2), ('b', 3), ('c', 1), ('c', 2), ('c', 3)]

Si nous utilisons une compréhension Python, nous aurons besoin d’une seule ligne de code :

ma_list = [(lettre, nombre) for lettre in 'abc' for nombre in range(1, 4)]
print(ma_list)

Une compréhension de liste avec if/else

Ce code va ajouter à la liste un nombre s’il est pair ou son carré s’il est impair.

nombres = [1, 2, 3, 4, 5, 6, 7]
ma_list = []
for x in nombres:
    if x % 2 == 0:
        ma_list.append(x)
    else:
        ma_list.append(x * x)
print(ma_list)

L’exécution de ce code nous donne :

[1, 2, 9, 4, 25, 6, 49]

Maintenant, nous allons utiliser une compréhension de liste avec cet exemple. Nous aurons le même résultat.

nombres = [1, 2, 3, 4, 5, 6, 7]
ma_list = [x if x % 2 == 0 else x * x for x in nombres ]
print(ma_list)

C’est génial, on a remplacé 6 lignes de codes avec une seule pour le même résultat, avec plus de rapidité et de performance.

Les compréhension de dictionnaire

En plus de créer des listes, nous pouvons créer des dictionnaires en utilisant la syntaxe des compréhensions Python. Nous avons découvert la fonction zip() dans un tutoriel précédent . Nous Allons l’utiliser pour associer les valeurs de deux listes afin de créer un dictionnaire de paires clé/valeur.

couleurs = ['rouge', 'jaune', 'orange']
fruits = ['fraise', 'banane', 'clémentine']
 
mon_dict = {}
for couleur, fruit in zip(couleurs, fruits):
    mon_dict[couleur] = fruit
print(mon_dict)

Le résultat :

{'rouge': 'fraise', 'jaune': 'banane', 'orange': 'clémentine'}

On peut avoir le même résultat avec une compréhension de dictionnaire en Python.

mon_dict = {couleur:fruit for couleur, fruit in zip(couleurs, fruits)}
print(my_dict)

Nous allons ajouter une instruction conditionnelle if pour avoir un dictionnaire contenant les fruits qui n’ont pas une couleure orange.

couleurs = ['rouge', 'jaune', 'orange']
fruits = ['fraise', 'banane', 'clémentine']

mon_dict = {}
for couleur, fruit in zip(couleurs, fruits):
    if couleur != 'orange':
        mon_dict[couleur] = fruit
print(mon_dict)

Le résultat :

{'rouge': 'fraise', 'jaune': 'banane'}

Voici la version de compréhension de dictionnaire qui utilise une instruction if.

mon_dict = {couleur:fruit for couleur, fruit in zip(couleurs, fruits) if couleur != 'orange'}

print(mon_dict)

Les compréhensions d’ensemble

Un ensemble en Python est une séquence qui ne contient pas d’élément en double.
À partir d’une liste de nombres contenant plusieurs valeurs en double, nous allons créer un ensemble en utilisant une boucle for, puis une compréhension d’ensemble.

nombres = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
mon_set = set()
for nombre in nombres:
    mon_set.add(nombre)
print(mon_set)

Résultat :

{1, 2, 3, 4, 5}

En utilisant une compréhension :

nombres = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
mon_set = {nombre for nombre in nombres}

print(mon_set)

Conclusion sur les compréhensions Python

Les compréhensions sont une manière très élégante, pour créer un code efficace en Python. Elles vous permettent de réduire le code de plusieurs lignes à une seule ligne. Une fois que vous êtes habitués à leur syntaxe, elles seront une meilleure option que d’utiliser les boucles for, les fonctions map() et filter().

Les compréhensions Python pour un code plus performant

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.

Retour en haut