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

0 Partages

Les énumérations sont un type de données populaire dans les langages de programmation tels que C, C++ et Java. Ils vous aident à écrire du code sécurisé et plus lisible.

En Python, les énumérations n’étaient pas toujours prises en charge. Cependant, depuis la version 3.4, Python prend désormais en charge les énumérations. Cet article est un guide sur la façon de créer des énumérations, comment les utiliser et comment elles améliorent la lisibilité du code.

Table des matières

Que sont les énumérations et à quoi servent-elles ?

Une énumération ou énumération est un type de données défini par l’ensemble de valeurs qu’il peut prendre. Cet ensemble de valeurs est appelé son ensemble de membres. Les énumérations vous permettent de définir plus précisément les valeurs qu’une variable peut avoir. Cela vous aide à écrire du code de type sécurisé. Cela améliore également la lisibilité.

Quelques termes à connaître

Lorsque nous discutons des énumérations, il y a des termes que je devrais d’abord définir, car nous les utiliserons beaucoup. Ce sont des membres et des valeurs.

Membres : ce sont les constantes nommées qui forment l’ensemble de valeurs qui appartiennent à l’énumération. Par exemple, l’énumération Days pourrait contenir les membres suivants : dimanche, lundi, mardi, etc.
Valeurs : ce sont les valeurs utilisées en interne pour représenter distinctement chaque membre de l’énumération. Cela permettra de faire des comparaisons. Par exemple, dans l’énumération Jours, dimanche pourrait avoir une valeur de 0, lundi une valeur de 1, mardi une valeur de 2, etc.

Nous allons maintenant discuter de la manière dont les Enums améliorent votre code.

Comment les énumérations améliorent votre code

Les énumérations améliorent votre code et le rendent plus lisible et moins sujet aux erreurs. Voici quelques-unes des raisons pour lesquelles vous devriez les utiliser :

Les énumérations vous permettent de définir clairement les valeurs attendues par un argument de variable ou de fonction. Exprimer clairement vos intentions avec un argument de variable ou de fonction permet aux gens de comprendre facilement votre code.
Les énumérations rendent également votre code auto-documenté. Cela signifie que vous n’avez pas besoin d’ajouter des commentaires ou des documents pour spécifier les valeurs attendues par une fonction. Au lieu de cela, votre énumération spécifie les valeurs attendues.
Cela permet également aux IDE de mettre en évidence les erreurs lorsque vous transmettez des valeurs incorrectes et de fournir une prise en charge de la saisie semi-automatique.
En conséquence, votre code devient sécurisé et moins susceptible de produire des erreurs d’exécution.

Ensuite, nous verrons comment créer des énumérations en Python.

Comment créer des énumérations en Python

Python ne prend pas en charge nativement les énumérations. Mais il fournit un module enums dans la bibliothèque standard. Nous utiliserons ce module dans ce tutoriel. Il existe également deux méthodes pour créer des énumérations en Python : les classes ou l’API de fonction. Je couvrirai les deux dans cette section.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin de Python 3.4 installé. Cette version de Python est livrée avec le module enum dans la bibliothèque standard. Si vous ne l’avez pas fait, voici un tutoriel pour vous aider :

Pour suivre le tutoriel, vous aurez besoin de connaître un peu Python. Cela inclut Python de base et des concepts de programmation orientée objet plus avancés tels que les classes et l’héritage.

#1. La méthode de classe

La première méthode pour créer des énumérations consiste à utiliser des classes. Vous importez d’abord la classe enum à partir du module enum. Ensuite, vous créez votre énumération en créant une classe. Cette classe héritera de la classe Enum que vous avez importée précédemment.

from enum import Enum

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

Vous pouvez également attribuer toutes les valeurs souhaitées aux membres d’une énumération. Voici un exemple : au lieu d’attribuer 0, 1, 2 et 3 à notre énumération de directions, nous attribuons leurs valeurs de titre correspondantes de 0, 90, 180 et 270.

from enum import Enum

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

Alternativement, l’utilisation de la fonction range est une manière plus concise de générer ce qui précède. L’extrait de code ci-dessous montre comment :

from enum import Enum

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

Dans ce cas, nous générons des valeurs à l’aide de la fonction range. Nous spécifions 0 comme valeur de départ, 360 comme valeur finale et 90 comme valeur incrémentielle. Nous déstructurons les valeurs de l’itérable, de la même manière que nous déstructurons les tuples. Si vous souhaitez en savoir plus sur la déstructuration des tuples, voici un article sur les tuples en Python.

Les classes Enum sont des classes abstraites. Cela signifie qu’ils ne sont pas destinés à être instanciés. Au lieu de cela, leurs propriétés, représentant les membres de l’énumération dans ce cas, sont accessibles directement.

#2. La méthode fonctionnelle

La méthode des fonctions est une alternative à la méthode des sous-classements.

from enum import Enum

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

Dans l’extrait de code ci-dessus, nous avons créé une énumération appelée Direction. Il est accessible via quatre membres, ce que nous avons fourni comme deuxième argument. Par défaut, ces membres reçoivent des valeurs à partir de 1. Ainsi, le Nord vaut 1, l’Est vaut 2, et ainsi de suite. C’est le cas et non un index de base zéro comme prévu car 0 est faux. Ainsi, pour que toutes les valeurs soient vraies, les valeurs sont numérotées à partir de 1.

Vous pouvez également attribuer des valeurs à vos membres en transmettant les membres sous forme de liste de tuples. Chaque tuple comprend deux éléments : le nom du membre et la valeur de ce membre.

from enum import Enum

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

Vous remarquerez également que j’ai utilisé des chaînes au lieu d’entiers lors de l’attribution de valeurs aux membres dans l’exemple ci-dessus. Cela démontre que les chaînes sont aussi valides que les entiers lors de l’attribution de valeurs.

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 aux membres. Cette section couvrira l’utilisation des énumérations pour accéder et attribuer des membres et vérifier l’égalité.

Comment accéder aux membres

Il existe plusieurs méthodes pour accéder aux membres d’une énumération. Celles-ci incluent la syntaxe des points, les parenthèses et la syntaxe des crochets. Voici un exemple pour démontrer ce qui précède :

from enum import Enum

# Creating an enum
class Day(Enum):
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY = range(1, 8)

# Accessing enum members
# 1. Using dot syntax
print(Day.SUNDAY)

# 2. Using square brackets
print(Day["MONDAY"])

# 3. Using the parentheses
print(Day(3))

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

Accéder au nom et à la valeur

Comme mentionné précédemment, lorsque vous accédez à un membre enum, vous créez une référence à l’objet membre. Si vous souhaitez, pour une raison quelconque, accéder au nom ou à la valeur de l’objet enum, vous pouvez utiliser les propriétés name et value sur l’objet.

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

Vérification de l’égalité

Rappelez-vous que l’attribution d’un membre enum à une variable crée une référence à l’objet membre enum. Par conséquent, pour vérifier si une variable a un membre enum particulier, nous utilisons l’opérateur is pour vérifier si le membre enum et la variable pointent vers le même objet.

Voici un exemple pour démontrer :

today = Day.WEDNESDAY

if today is Day.MONDAY:
    print("It's a Monday, :(")

if today is Day.WEDNESDAY:
    print("Happy Wednesday")

Alternativement, vous pouvez utiliser l’opérateur ==. Sur les superclasses de la classe Enum, l’opérateur == est un wrapper pour l’opérateur is. Cela se fait en utilisant la surcharge des opérateurs. Vous pouvez en savoir plus à ce sujet dans cet article sur les méthodes magiques. Quoi qu’il en soit, voici un exemple qui utilise == au lieu de is.

today = Day.WEDNESDAY

if today == Day.MONDAY:
    print("It's a Monday, :(")

if today == Day.WEDNESDAY:
    print("Happy Wednesday")

Au risque d’être répétitif, les comparaisons d’énumération vérifient l’identité de l’objet, pas les valeurs.

Derniers mots

Cet article explique ce que sont les énumérations et pourquoi elles sont utiles. Nous avons également couvert les différentes méthodes pour créer des énumérations en sous-classant la classe Enum et en utilisant l’API fonctionnelle.

De plus, nous avons expliqué comment utiliser les énumérations, accéder aux valeurs et effectuer des comparaisons. Ensuite, vous souhaiterez peut-être lire notre article sur les énumérations TypeScript.