[Explained] Comment implémenter Switch-Case en Python

Vous cherchez à mettre en œuvre une structure switch-case en Python ? Découvrez les différentes méthodes que vous pouvez utiliser pour simuler le fonctionnement d’un switch-case.

Si vous avez déjà programmé en C ou en JavaScript, vous avez probablement utilisé l’instruction switch-case. Mais pourquoi aurait-on besoin d’une structure de type switch-case ?

Imaginez que vous ayez un ensemble d’actions distinctes (ou blocs de code). L’action que vous réalisez (le bloc de code à exécuter) dépend de la valeur d’une variable ou d’une expression.

Voici quelques exemples :

• Attribuer des notes aux étudiants en fonction de leurs résultats.
• Sélectionner des méthodes de manipulation de chaînes de caractères selon le choix de l’utilisateur.
• Effectuer des opérations arithmétiques sur deux nombres en fonction de la saisie de l’utilisateur.

Ainsi, la structure switch-case offre un moyen pratique d’implémenter une telle logique. Elle est utile lorsque vous devez exécuter l’une des nombreuses actions possibles, en fonction de la valeur d’une variable ou d’une expression.

Bien que Python ne possède pas de structure switch-case native, il existe plusieurs approches que vous pouvez utiliser pour obtenir des fonctionnalités similaires. Dans cet article, nous allons explorer ces différentes approches.

Émulation du comportement de Switch-Case en Python

Voyons comment nous pouvons simuler le comportement d’un switch-case en Python en prenant un exemple concret.

Nous allons écrire un programme simple qui effectue les opérations suivantes :

• Choisir un mot, une chaîne de caractères Python, aléatoirement dans une liste de mots.
• Fournir le contexte et inviter l’utilisateur à choisir des opérations sur les chaînes (manipulation de chaînes) à appliquer au mot sélectionné.
• Prendre en compte les opérations de changement de casse (minuscules, majuscules, casse de titre, etc.), en incluant un comportement par défaut. Utiliser les méthodes de chaînes de caractères Python intégrées lorsque c’est nécessaire.
• Demander à l’utilisateur de saisir une donnée. Étant donné que l’entrée, par défaut, est une chaîne de caractères, la convertir en entier par un transtypage.

Les chaînes de caractères en Python sont immuables. Les méthodes de chaînes ne modifient donc pas la chaîne de caractères d’origine. Elles renvoient plutôt une copie de la chaîne avec les modifications requises. Voici les méthodes de chaînes que nous utiliserons :

L’extrait de code suivant sélectionne un mot au hasard dans `word_list` et récupère l’entrée de l’utilisateur :

import random

# Liste de mots parmi lesquels choisir
word_list = ["Python", "programmation", "Bonjour", "monde", "contexte", "Switch"]

# Sélection aléatoire d'un mot de la liste
word = random.choice(word_list)

# Fournir le contexte et les options disponibles à l'utilisateur
print("Bienvenue ! Vous avez un mot sélectionné aléatoirement.")
print("Choisissez une option pour manipuler le mot :")
print("1. Minuscule")
print("2. Majuscule")
print("3. Casse de titre")
print("4. Inverser la casse")
print("5. Comportement par défaut")

# Obtenir l'option de l'utilisateur
option = int(input("Entrez votre option : "))
  

Voici un exemple illustrant comment la chaîne ‘Python’ est modifiée en fonction du choix de l’utilisateur :

Lorsque vous exécutez le programme, vous devriez être invité à entrer une valeur comme celle-ci :

Bienvenue ! Vous avez un mot sélectionné aléatoirement.

Choisissez une option pour manipuler le mot :
1. Minuscule
2. Majuscule
3. Casse de titre
4. Inverser la casse
5. Comportement par défaut

Entrez votre option :
  

Passons maintenant à la mise en œuvre des différentes approches.

Utiliser la structure If-Elif-Else

Dans cette approche, nous utilisons une série d’instructions if-elif-else pour comparer le choix de l’utilisateur aux différentes options possibles. Nous exécutons ensuite le bloc de code correspondant en fonction de la saisie de l’utilisateur.

# if-elif-else

if option == 1:
    result = word.lower()
elif option == 2:
    result = word.upper()
elif option == 3:
    result = word.title()
elif option == 4:
    result = word.swapcase()
else:
    result = word

print(f"Votre mot aléatoire est {word} et le résultat est {result}")
    

Ici :

• Nous comparons l’entrée de l’utilisateur à chaque option à l’aide des instructions if-elif.
• Lorsqu’une correspondance est trouvée, nous exécutons le bloc de code correspondant.
• Si aucune des conditions if-elif n’est satisfaite, nous exécutons le bloc else pour le comportement par défaut.

Vous pouvez exécuter le script maintenant, saisir le choix et vérifier le résultat :

Bienvenue ! Vous avez un mot sélectionné aléatoirement.

Choisissez une option pour manipuler le mot :
1. Minuscule
2. Majuscule
3. Casse de titre
4. Inverser la casse
5. Comportement par défaut

Entrez votre option : 2

Votre mot aléatoire est Switch et le résultat est SWITCH.
  

La structure if-elif-else est facile à mettre en œuvre. Cependant, sa maintenance peut s’avérer complexe. Dans cet exemple, nous avons cinq cas (y compris le comportement par défaut). Toutefois, en pratique, nous pouvons avoir beaucoup plus de cas. De longues suites d’instructions if-elif-else sont un signe d’un code qui pourrait être amélioré.

Passons donc à une implémentation plus maintenable.

Utilisation du mappage de dictionnaire et des fonctions de première classe

Vous pouvez utiliser les dictionnaires et les fonctions Python pour simuler le comportement d’un switch-case.

📑 Les fonctions en Python sont des objets de première classe

En Python, les fonctions sont des objets de première classe. Vous pouvez faire bien plus que simplement définir et appeler des fonctions :

• Après avoir défini une fonction, vous pouvez l’affecter à une autre variable, utiliser des fonctions comme éléments de listes, valeurs dans un dictionnaire, et plus encore.
• Vous pouvez également les transmettre : les fonctions peuvent être passées comme arguments à d’autres fonctions, et les fonctions peuvent retourner des fonctions.

Dans cette approche, nous allons utiliser un dictionnaire pour associer les choix de l’utilisateur aux fonctions ou actions correspondantes. C’est un moyen plus efficace de gérer plusieurs choix, car cela évite une longue suite d’instructions if-elif.

Commençons par définir les fonctions pour les différentes opérations sur les chaînes de caractères :

# Définir les fonctions pour chaque option
def lower_case(word):
    return word.lower()

def upper_case(word):
    return word.upper()

def title_case(word):
    return word.title()

def swap_case(word):
    return word.swapcase()
  

Ensuite, nous allons :

• Créer un dictionnaire appelé `options`, où les clés sont les choix de l’utilisateur et les valeurs sont les fonctions ou actions à réaliser.
• Utiliser la méthode `get()` du dictionnaire pour récupérer l’action sélectionnée en fonction du choix de l’utilisateur. Si le choix n’est pas trouvé dans le dictionnaire, nous fournissons une action par défaut spécifiée par une fonction lambda.
• Exécuter l’action sélectionnée sur le mot aléatoire.

# Stocker les fonctions dans un dictionnaire
options = {
    1: lower_case,
    2: upper_case,
    3: title_case,
    4: swap_case,
}

# Utiliser le dictionnaire pour sélectionner et appeler la fonction appropriée
result = options.get(option, lambda x: x)(word)

print(f"Votre mot aléatoire est {word} et le résultat est {result}")
  

Voici un exemple de résultat :

Bienvenue ! Vous avez un mot sélectionné aléatoirement.

Choisissez une option pour manipuler le mot :
1. Minuscule
2. Majuscule
3. Casse de titre
4. Inverser la casse
5. Comportement par défaut

Entrez votre option : 4

Votre mot aléatoire est Hello et le résultat est hELLO.
  

Utiliser Match-Case

📝 Note : Vous avez besoin de Python 3.10 ou d’une version ultérieure pour utiliser les instructions `match-case`.

À partir de Python 3.10, vous pouvez utiliser l’instruction `match` pour implémenter une structure de type switch-case. L’instruction `match`, avec sa syntaxe simple, offre un moyen plus intuitif de gérer plusieurs cas. Le caractère `_` (tiret bas) sert de cas par défaut.

Voici comment nous pouvons réécrire notre exemple en utilisant `match-case` :

• Nous utilisons l’instruction `match` pour comparer les entrées de l’utilisateur avec différents cas.
• Chaque `case` spécifie un choix et le code à exécuter si ce choix correspond.
• Le caractère `_` (tiret bas) sert de cas par défaut, exécutant le code lorsqu’aucun des autres cas ne correspond.

match option:
    case 1:
        result =  word.lower()
    case 2:
        result = word.upper()
    case 3:
        result = word.title()
    case 4:
        result = word.swapcase()
    case _:
        result = word  # Comportement par défaut, retourne la chaîne telle quelle

print(f"Votre mot aléatoire est {word} et le résultat est {result}.")
    

Vous pouvez maintenant exécuter le script et vérifier le résultat :

Bienvenue ! Vous avez un mot sélectionné aléatoirement.

Choisissez une option pour manipuler le mot :
1. Minuscule
2. Majuscule
3. Casse de titre
4. Inverser la casse
5. Comportement par défaut

Entrez votre option : 2
Votre mot aléatoire est world et le résultat est WORLD.
    

⚙ Bien que l’instruction `match` offre un moyen pratique d’implémenter une structure switch-case, elle est destinée à des utilisations plus larges, notamment la correspondance de motifs structurels, allant au-delà de la simple simulation d’un switch-case.

Conclusion

Résumons les différentes approches pour obtenir la fonctionnalité switch-case en Python :

• La structure if-elif-else est facile à mettre en œuvre, mais difficile à maintenir. Il faut donc l’utiliser avec parcimonie, uniquement lorsque vous n’avez pas trop d’options à vérifier.
• Vous pouvez utiliser les dictionnaires et les fonctions Python pour simuler le comportement d’un switch-case. Incluez les différents choix et les fonctions correspondantes comme clés et valeurs du dictionnaire, respectivement.
• L’instruction `match-case`, introduite dans Python 3.10, permet d’implémenter une structure switch-case avec une syntaxe simple et intuitive. Cependant, l’instruction `match-case` est un excellent choix pour des cas d’utilisation de correspondance de motifs structurels plus intéressants.

Vous pouvez retrouver les exemples de code de ce tutoriel sur GitHub. Si vous vous préparez à des entretiens techniques, consultez cette compilation de questions d’entretien Python importantes.