Comment les énumérations en Python améliorent la lisibilité du code

Table des matières

Les énumérations représentent un type de données fréquemment utilisé dans divers langages de programmation, tels que C, C++ et Java. Elles facilitent l’écriture d’un code plus sûr et plus facile à comprendre.

En Python, la prise en charge des énumérations n’a pas toujours été native. Cependant, depuis la version 3.4, Python intègre désormais cette fonctionnalité. Cet article vous guidera à travers le processus de création et d’utilisation des énumérations, en mettant en lumière comment elles contribuent à améliorer la clarté de votre code.

Que sont les énumérations et quel est leur rôle ?

Une énumération, ou enum, est un type de données défini par l’ensemble spécifique de valeurs qu’il peut prendre. Cet ensemble de valeurs est désigné comme son ensemble de membres. Les énumérations vous permettent de définir de manière précise les valeurs autorisées pour une variable. Cela améliore la sûreté du typage de votre code, tout en augmentant sa lisibilité.

Quelques notions clés

Avant d’approfondir le sujet des énumérations, il est essentiel de définir certains termes que nous utiliserons fréquemment : les membres et les valeurs.

Membres : Ce sont les constantes nommées qui constituent l’ensemble des valeurs possibles pour l’énumération. Par exemple, une énumération appelée « Jours » pourrait avoir les membres suivants : dimanche, lundi, mardi, et ainsi de suite.
Valeurs : Il s’agit des valeurs utilisées en interne pour distinguer chaque membre de l’énumération. Ces valeurs permettent d’effectuer des comparaisons. Pour l’énumération « Jours », dimanche pourrait avoir la valeur 0, lundi la valeur 1, mardi la valeur 2, etc.

Nous allons maintenant explorer les avantages qu’apportent les énumérations à votre code.

Comment les énumérations optimisent votre code

Les énumérations contribuent à améliorer votre code en le rendant plus lisible et moins sujet aux erreurs. Voici quelques raisons pour lesquelles leur utilisation est recommandée :

Les énumérations vous permettent de spécifier clairement les valeurs attendues pour un argument de variable ou de fonction. En exprimant clairement vos intentions, vous facilitez la compréhension de votre code pour les autres développeurs.
Les énumérations rendent également votre code auto-documenté. Cela signifie que vous n’avez pas besoin d’ajouter des commentaires ou une documentation détaillée pour préciser les valeurs attendues par une fonction. L’énumération elle-même sert de spécification.
Elles permettent également aux environnements de développement intégrés (IDE) de détecter les erreurs lorsque vous fournissez des valeurs incorrectes, et de proposer une auto-complétion pratique.
Par conséquent, votre code devient plus sûr et moins susceptible de générer des erreurs lors de l’exécution.

Nous allons maintenant voir comment créer des énumérations en Python.

Comment créer des énumérations en Python

Bien que Python ne prenne pas nativement en charge les énumérations, il fournit un module nommé ‘enum’ au sein de sa bibliothèque standard. Nous utiliserons ce module dans ce guide. Il existe deux approches pour créer des énumérations en Python : par le biais de classes ou en utilisant une API de fonction. Nous explorerons ces deux méthodes.

Prérequis

Pour suivre ce tutoriel, vous devez avoir installé Python 3.4 ou une version ultérieure. Cette version de Python inclut le module ‘enum’ dans sa bibliothèque standard. Si ce n’est pas le cas, voici un tutoriel pour vous aider :

Pour bénéficier pleinement de ce tutoriel, une connaissance de base de Python est recommandée, ainsi que des concepts de programmation orientée objet tels que les classes et l’héritage.

#1. La méthode par classes

La première approche pour créer des énumérations consiste à utiliser des classes. Commencez par importer la classe ‘Enum’ depuis le module ‘enum’. Ensuite, définissez votre énumération en créant une classe qui hérite de la classe ‘Enum’ précédemment importée.

from enum import Enum

class Direction(Enum):
    NORTH = 0
    EAST = 1
    SOUTH = 2
    WEST = 3

Vous pouvez également attribuer les valeurs de votre choix aux membres de l’énumération. Par exemple, au lieu d’attribuer 0, 1, 2 et 3 à notre énumération de directions, nous pouvons utiliser leurs valeurs angulaires correspondantes : 0, 90, 180 et 270.

from enum import Enum

class Direction(Enum):
    NORTH = 0
    EAST = 90
    SOUTH = 180
    WEST = 270

Une autre méthode plus concise consiste à utiliser la fonction ‘range’ pour générer les valeurs. Le code ci-dessous illustre cette technique :

from enum import Enum

class Direction(Enum):
    NORTH, EAST, SOUTH, WEST = range(0, 360, 90)

Dans cet exemple, nous utilisons la fonction ‘range’ pour générer des valeurs. Nous spécifions 0 comme valeur de départ, 360 comme valeur finale, et 90 comme incrément. Les valeurs résultantes sont ensuite déconstruites, de la même manière que lors de la déstructuration de tuples. Pour en savoir plus sur la déstructuration de tuples, vous pouvez consulter cet article sur les tuples en Python.

Les classes Enum sont des classes abstraites, ce qui signifie qu’elles ne sont pas conçues pour être instanciées directement. Au lieu de cela, leurs propriétés, qui représentent les membres de l’énumération, sont accessibles directement.

#2. La méthode fonctionnelle

La méthode fonctionnelle offre une alternative à la méthode par sous-classement.

from enum import Enum

Direction = Enum("Direction", ["NORTH", "EAST", "SOUTH", "WEST"])

Dans le code ci-dessus, nous avons créé une énumération appelée « Direction ». Elle est accessible via quatre membres, qui ont été fournis comme second argument. Par défaut, ces membres se voient attribuer des valeurs commençant par 1. Ainsi, Nord a la valeur 1, Est a la valeur 2, et ainsi de suite. Ce choix est motivé par le fait que 0 est interprété comme faux, alors que nous voulons que toutes les valeurs soient vraies. Par conséquent, les valeurs sont numérotées à partir de 1.

Vous pouvez également attribuer des valeurs spécifiques à vos membres en fournissant les membres sous forme de liste de tuples. Chaque tuple contient deux éléments : le nom du membre et sa valeur correspondante.

from enum import Enum

Direction = Enum(
    name = "Direction",
    values = [
        ("NORTH", "n"),
        ("EAST", "e"),
        ("SOUTH", "s"),
        ("WEST", "w"),
    ]
)

Vous noterez que, dans l’exemple ci-dessus, nous utilisons des chaînes de caractères au lieu d’entiers pour attribuer les valeurs aux membres. Cela montre que les chaînes sont aussi valides que les entiers pour ce faire.

Comment utiliser les énumérations

Dans la section précédente, nous avons abordé la création d’énumérations et l’attribution de valeurs à leurs membres. Cette section explore l’utilisation des énumérations pour accéder aux membres, les attribuer à des variables, et vérifier leur égalité.

Comment accéder aux membres

Il existe plusieurs manières d’accéder aux membres d’une énumération, notamment la notation par point, les parenthèses, et les crochets. Voici un exemple pour illustrer ces différentes méthodes :

from enum import Enum

# Création d'une énumération
class Day(Enum):
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY = range(1, 8)

# Accès aux membres de l'énumération
# 1. En utilisant la notation par point
print(Day.SUNDAY)

# 2. En utilisant les crochets
print(Day["MONDAY"])

# 3. En utilisant les parenthèses
print(Day(3))

Après avoir accédé à un membre de l’énumération, vous pouvez le stocker dans une variable. Il est important de noter que l’accès à un membre vous donne une référence à l’objet membre, et non à sa valeur ou son nom. Cette distinction est importante pour les sections suivantes.

Accéder au nom et à la valeur

Comme mentionné précédemment, l’accès à un membre d’une énumération crée une référence à l’objet membre. Si vous souhaitez accéder au nom ou à la valeur de cet objet, vous pouvez utiliser les propriétés ‘name’ et ‘value’ :

print(Day.SUNDAY.name, Day.SUNDAY.value)

Vérification de l’égalité

N’oubliez pas que l’attribution d’un membre d’une énumération à une variable crée une référence à l’objet membre. Par conséquent, pour vérifier si une variable correspond à un membre spécifique d’une énumération, nous utilisons l’opérateur ‘is’ pour vérifier si les deux références pointent vers le même objet.

Voici un exemple pour illustrer cette méthode :

today = Day.WEDNESDAY

if today is Day.MONDAY:
    print("C'est lundi, :(")

if today is Day.WEDNESDAY:
    print("Joyeux mercredi")

Vous pouvez également utiliser l’opérateur ‘==’. Pour les superclasses de la classe ‘Enum’, l’opérateur ‘==’ est un alias de l’opérateur ‘is’. Cela est réalisé grâce à la surcharge d’opérateurs. Pour en savoir plus sur ce sujet, vous pouvez consulter cet article sur les méthodes magiques. Voici un exemple qui utilise ‘==’ au lieu de ‘is’ :

today = Day.WEDNESDAY

if today == Day.MONDAY:
    print("C'est lundi, :(")

if today == Day.WEDNESDAY:
    print("Joyeux mercredi")

Pour réitérer, les comparaisons d’énumération vérifient l’identité de l’objet, et non ses valeurs.

Conclusion

Cet article a abordé la définition des énumérations, leurs avantages et les méthodes pour les créer, que ce soit en utilisant la sous-classe de la classe ‘Enum’ ou en employant l’API fonctionnelle.

De plus, nous avons expliqué comment manipuler les énumérations, accéder à leurs valeurs et effectuer des comparaisons. Vous pourriez ensuite être intéressé par notre article sur les énumérations en TypeScript.

0 Partages