Comment utiliser Switch Case en Python

Généralement, la programmation vise à rendre un problème complexe aussi simple que possible. De cette manière, les cas de commutation peuvent être très utiles pour exécuter du code spécifique en fonction de la valeur ou de la variable en question. En Python, il n’y a pas de cas de commutation, nous devons donc utiliser une alternative. Découvrez comment implémenter le switch case en Python dès aujourd’hui.

Qu’est-ce que Switch Case ?

En termes simples, les instructions switch case permettent à votre programme d’exécuter différentes fonctions en fonction de la valeur d’une variable ou d’une instruction. De cette façon, l’instruction switch case évalue la valeur et compare le résultat avec certaines règles prédéfinies que vous avez mises en place. Dans chaque cas, des actions spécifiques doivent être effectuées si la valeur correspond à la casse du commutateur. Vous pouvez également définir un code par défaut à exécuter si aucun des cas de commutation ne correspond.

Bien que Python n’ait pas de cas de commutation, de nombreux autres langages de programmation en ont. En tant que tel, illustrons le fonctionnement d’un switch case en C :

switch (expression) {

case value1: #code to execute if expression = value1
break;

case value2: #code to execute if expression = value2
break;

case value3: #code to execute if expression = value3
break;

default: #code to execute if expression matches none of the above cases
break;

Relativement simple, non ? Malheureusement, nous devons faire un peu plus de travail pour implémenter cela en Python. Il existe en fait différentes manières d’implémenter une fonction similaire au changement de casse, alors allons-y.

Comment implémenter Switch Case à l’aide d’instructions If-elif-else

Une façon consiste à utiliser les instructions « if » et « else » pour exécuter une fonction spécifique basée sur l’entrée. Cela peut en fait être décrit de deux manières. La première méthode ressemble à ceci :

color="Blue"

if color == 'Red':
print('color is Red')

elif color == 'Green':
print('color is Green')

elif color == 'Yellow':
print('color is Yellow')

elif color == 'Blue':
print('color is Blue')

else:
print('Color is undetermined')

L’entrée, ou « couleur », est testée par rapport à chacune de ces conditions pour voir à laquelle elle correspond. Dans ce cas, la couleur est clairement bleue, donc la sortie attendue est « la couleur est bleue ». Et c’est exactement ce que nous voyons lorsque nous essayons ce code.

Comment implémenter Switch Case à l’aide du mappage de dictionnaire

Un dictionnaire est simplement un ensemble non structuré de valeurs de données et possède des paires clé:valeur. Ceux-ci sont similaires aux en-têtes d’une feuille de calcul, tels que « Nom », « Taille » et « Poids ». Chaque clé est associée à des valeurs de données. De cette façon, nous pouvons utiliser une sorte de fonction de changement de cas pour renvoyer des valeurs spécifiques à partir d’un dictionnaire. Ceci est illustré ci-dessous :

def switch_case(argument):
switcher = {
"Red": "RED",
"Blue": "BLUE",
"Green": "GREEN"
}
return switcher.get(argument, "Invalid argument")

if__name__ =="__main__":
argument= "Green"
print(switch_case(argument))

Dans cette situation, nous définissons la fonction « switch_case » comme une fonction qui prend l’argument.

Le dictionnaire est défini comme « switcher » et contient des paires clé:valeur. Les clés représentent les noms de couleurs en majuscules, les valeurs représentent les noms de couleurs en majuscules.

La valeur qui correspond à la clé de l’argument est renvoyée du dictionnaire à l’aide de la fonction « get ». Sinon, l’argument « argument invalide » est renvoyé.

Puisque l’argument d’entrée était « Green », nous obtenons « GREEN » comme sortie.

La ligne « if__name == « __main__ » » signifie simplement que le code n’est exécuté que lors de l’exécution directe du script.

Comment implémenter Switch Case à l’aide d’une classe

La dernière façon d’implémenter le cas de commutation en Python consiste à utiliser une classe. Il s’agit essentiellement d’un modèle pour créer des objets avec des attributs et des méthodes définis. Par exemple, une classe appelée « ID » peut avoir deux attributs, « Height » et « Weight », et des méthodes pour obtenir ces valeurs, comme « get_height() » et « get_weight() ». Par exemple, nous pouvons définir la classe comme « switchcase » et implémenter le processus comme suit :

class switch_case:
    def month(self, year):
        default = "Incorrect month"

        return getattr(self, 'case_' + str(year), lambda: default)()

    def case_1(self):
        return "2001"

    def case_2(self):
        return "2002"

    def case_3(self):
        return "2003"

my_switch = switch_case()

print(my_switch.month(1))

print(my_switch.month(3))

Tout d’abord, nous définissons « switch_case » comme une fonction qui implémente switch case.

Suite à cela, la méthode s’appelle « mois () », qui prend le paramètre « année » et appelle la méthode « mois » en utilisant différents arguments, « 1 » et « 3 ». Lorsque la méthode est appelée avec l’argument « 1 », elle correspond à la méthode de la classe « case_1() », produisant le résultat « 2001 ». Lorsque l’argument de « 3 » est appelé, la sortie est la valeur de chaîne « 2003 ».

Voir la capture d’écran pour savoir comment ce code fonctionne dans la pratique.

Emballer

Bien que la casse du commutateur ne soit pas explicitement incluse dans Python, il existe plusieurs façons de recréer ce processus. Dans l’ensemble, cela inclut l’utilisation du mappage de dictionnaire, l’implémentation d’une fonction de classe ou l’utilisation d’instructions if-elif-else. Dans tous les cas, un code spécifique est exécuté en fonction de l’argument donné et des valeurs spécifiques sont renvoyées en fonction des instructions switch.

Comment utiliser Switch Case dans la FAQ Python (Foire aux questions)

Quels langages de programmation prennent en charge les instructions switch case ?

De nombreux langages de programmation prennent en charge les instructions switch case, telles que C, C++, Java, JavaScript, Ruby, Swift et Python. Cependant, Python n’a pas de fonction explicite de changement de cas, mais la fonction peut être implémentée avec les différentes méthodes décrites ici.

Les instructions switch case sont-elles plus efficaces que les instructions if-else ?

Pas toujours. L’efficacité d’une instruction switch case dépend du nombre de cas ainsi que de la manière dont le code est implémenté. S’il n’y a que quelques valeurs possibles pour une expression donnée, les instructions if-else peuvent être plus efficaces.

Que se passe-t-il si la valeur ne peut correspondre à aucun des cas ?

Un bloc de code par défaut est exécuté si aucun des cas ne correspond à la valeur en question.

Quelles expressions pouvez-vous utiliser dans une instruction switch case ?

Cela dépend du langage de programmation que vous utilisez, mais il est certainement possible d’utiliser des expressions de types autres que des entiers ou des valeurs de chaîne, telles que des caractères ou des énumérations.

Pouvez-vous utiliser plusieurs cas pour le même code ?

Dans la plupart des cas, oui. Cela peut être utile lorsque vous souhaitez utiliser le même code pour plusieurs valeurs d’une expression.