Les développeurs issus de langages comme C/C++ ou Java savent qu'il existe une instruction conditionnelle appelée Boîtier de commutation . Ce Cas de correspondance est le cas Switch de Python qui a été introduit dans Python 3.10. Ici, nous devons d'abord transmettre un paramètre, puis essayer de vérifier dans quel cas le paramètre est satisfait. Si nous trouvons une correspondance, nous exécuterons du code et s'il n'y a aucune correspondance, une action par défaut aura lieu.

Syntaxe de l'instruction Python Match Case

L'instruction match case en Python est initialisée avec le correspondre mot-clé suivi du paramètre à rechercher. Ensuite, différents cas sont définis à l'aide de la cas mot-clé et le modèle correspondant au paramètre. Le _ est le caractère générique qui s'exécute lorsque tous les cas ne correspondent pas à la valeur du paramètre.

match parameter: case pattern1: # code for pattern 1 case pattern2: # code for pattern 2 . . case patterN: # code for pattern N case _: # default code block>

Table des matières

java convertir un caractère en entier

• Déclaration de cas de correspondance simple
• Faire correspondre l'instruction de cas avec l'opérateur OR
• Faire correspondre l'instruction de cas avec la condition Python If
• Faire correspondre la casse avec le modèle de séquence
• Faire correspondre l'instruction de cas avec le dictionnaire Python
• Faire correspondre l'instruction de cas avec la classe Python
• FAQ sur les déclarations de cas de correspondance Python

Voyons maintenant quelques exemples pour savoir comment fonctionne l'instruction match case en Python.

Déclaration de cas de correspondance simple

Dans une simple instruction Python match case, la valeur exacte est comparée et mise en correspondance avec la valeur du modèle de cas. Il existe différents cas de test et leur code correspondant qui ne s'exécutera que lorsqu'un cas correspondra. Sinon, il existe un cas par défaut qui s'exécute lorsque tous les cas définis ne correspondent pas.

Exemple: Dans cet exemple, nous demanderons à l'utilisateur de saisir une valeur comprise entre 1 et 3 et d'afficher le numéro correspondant en mots à l'aide de la simple instruction match case.

# simple match case statement def runMatch(): num = int(input('Enter a number between 1 and 3: ')) # match case match num: # pattern 1 case 1: print('One') # pattern 2 case 2: print('Two') # pattern 3 case 3: print('Three') # default pattern case _: print('Number not between 1 and 3') runMatch()>

Sortir:

Enter a number between 1 and 3: 5 Number not between 1 and 3>

Faire correspondre l'instruction de cas avec l'opérateur OR

Cas de correspondance Les instructions en Python sont destinées uniquement à faire correspondre les modèles et les mots-clés ou paramètres spécifiques. Mais nous pouvons également utiliser l'instruction match case en python lorsqu'il y a plusieurs cas qui aboutissent au même résultat. Dans ce cas, nous pouvons utiliser l'opérateur pipe, également connu sous le nom d'opérateur OR dans l'instruction match case.

Exemple: Dans cet exemple, nous demanderons à l'utilisateur de saisir une valeur comprise entre 1 et 6. Ensuite, en utilisant le cas de correspondance avec l'opérateur OR, nous avons matraqué les paires d'un 1 cas chacune, ce qui affichera son numéro correspondant en mots.

# python match case with OR operator def runMatch(): num = int(input('Enter a number between 1 and 6: ')) # match case match num: # pattern 1 case 1 | 2: print('One or Two') # pattern 2 case 3 | 4: print('Three or Four') # pattern 3 case 5 | 6: print('Five or Six') # default pattern case _: print('Number not between 1 and 6') runMatch()>

Sortir:

Enter a number between 1 and 6: 4 Three or Four>

Faire correspondre l'instruction de cas avec la condition Python If

Nous pouvons également utiliser le Python Si condition avec l'instruction match case lorsqu'au lieu de faire correspondre la valeur exacte, nous utilisons une condition. En fonction de la condition, si la valeur est True et correspond au modèle de casse, le bloc de code est exécuté.

Exemple: Dans cet exemple, nous utiliserons la condition if avec l'instruction match case pour vérifier si un nombre saisi par l'identifiant utilisateur est positif, négatif ou zéro.

# python match case with if condition def runMatch(): num = int(input('Enter a number: ')) # match case match num: # pattern 1 case num if num>0 : print('Positive') # motif 2 case num if num< 0: print('Negative') # default pattern case _: print('Zero') runMatch()>

Sortir:

Enter a number: -15 Negative>

Faire correspondre la casse avec le modèle de séquence

Les instructions de cas de correspondance Python sont couramment utilisées pour faire correspondre des modèles de séquence tels que des listes et des chaînes. C'est assez simple et peut utiliser des arguments de position pour vérifier les modèles.

Exemple: Dans cet exemple, nous utilisons une chaîne python pour vérifier si un caractère est présent dans le chaîne ou ne pas utiliser la casse. Nous fournissons la chaîne ainsi que l'index du caractère que nous voulons vérifier dans la chaîne à la casse. Ensuite, nous avons défini les cas de correspondance quant à ce que pourrait être ce personnage.

# match case to check a character in a string def runMatch(): myStr = 'Hello World' # match case match (myStr[6]): case 'w': print('Case 1 matches') case 'W': print('Case 2 matches') case _: print('Character not in the string') runMatch()>

Sortir:

Case 2 matches>

Exemple: Dans cet exemple, nous utilisons un liste python pour la correspondance de motifs. Nous faisons correspondre le premier élément des arguments de position perdus et utilisons également des arguments de position pour faire correspondre le reste de la liste.

# python match case with list def runMatch(mystr): # match case match mystr: # pattern 1 case ['a']: print('a') # pattern 2 case ['a', *b]: print(f'a and {b}') # pattern 3 case [*a, 'e'] | (*a, 'e'): print(f'{a} and e') # default pattern case _: print('No data') runMatch([]) runMatch(['a']) runMatch(['a', 'b']) runMatch(['b', 'c', 'd', 'e'])>

Sortir:

No data a a and ['b'] ['b', 'c', 'd'] and e>

Faire correspondre l'instruction de cas avec le dictionnaire Python

Les instructions de cas de correspondance Python peuvent gérer dictionnaire aussi. Il peut correspondre à une seule clé ou à plusieurs clés. Les clés et les valeurs doivent résider dans le dictionnaire. S'il y a une valeur égarée ou une clé qui n'existe pas et ne correspond pas au dictionnaire et à la valeur réels, ce cas sera ignoré.

Exemple: Dans cet exemple, nous utilisons un dictionnaire avec une instruction match case en python. Nous fournissons des dictionnaires avec des données différentes au cas de correspondance, et il fera correspondre les clés du dictionnaire avec les différents cas fournis.

# match case with python dictionaryu def runMatch(dictionary): # match case match dictionary: # pattern 1 case {'name': n, 'age': a}: print(f'Name:{n}, Age:{a}') # pattern 2 case {'name': n, 'salary': s}: print(f'Name:{n}, Salary:{s}') # default pattern case _ : print('Data does not exist') runMatch({'name': 'Jay', 'age': 24}) runMatch({'name': 'Ed', 'salary': 25000}) runMatch({'name': 'Al', 'age': 27}) runMatch({})>

Sortir:

ligne et colonne

Name:Jay, Age:24 Name:Ed, Salary:25000 Name:Al, Age:27 Data does not exist>

Faire correspondre l'instruction de cas avec la classe Python

Nous pouvons également utiliser Cours Python pour faire correspondre les cas à l'aide des instructions Python match case. Cela rendra le code très propre, soigné et, surtout, facilement lisible. Il utilise le module Python dataclasses.

Exemple: Dans cet exemple, nous avons créé deux classes appelées Person et Programmer. La première pensée après avoir vu l'instruction match serait que le programmeur et la personne à l'intérieur de l'instruction match créeraient une instance des classes respectives, mais ce n'est pas le cas. Il vérifiera l'instance avec les valeurs données. Ainsi, le cas Programmer(Om, language = Python, framework = Django) ne créera pas d'instance mais vérifiera que l'objet passé dont le nom est instance est une instance réelle de la classe Programmer, puis il vérifiera le nom qui est Om , un langage qui est Python puis un framework qui est Django. De cette façon, nous pouvons vérifier les valeurs dans l’instance de n’importe quelle classe.

# match case with python classes # import dataclass module from dataclasses import dataclass #Class 1 @dataclass class Person: name: str age: int salary: int # class 2 @dataclass class Programmer: name: str language: str framework: str def runMatch(instance): # match case match instance: # pattern 1 case Programmer('Om', language='Python', framework='Django'): print(f'Name: Om, Language:Python, Framework:Django') # pattern 2 case Programmer('Rishabh', 'C++'): print('Name:Rishabh, Language:C++') # pattern 3 case Person('Vishal', age=5, salary=100): print('Name:Vishal') # pattern 4 case Programmer(name, language, framework): print(f'Name:{name}, Language:{language}, Framework:{framework}') # pattern 5 case Person(): print('He is just a person !') # default case case _: print('This person is nothiing!') programmer1 = Programmer('Om', 'Python', 'Django') programmer2 = Programmer('Rishabh', 'C++', None) programmer3 = Programmer('Sankalp', 'Javascript', 'React') person1 = Person('Vishal', 5, 100) runMatch(programmer1) runMatch(programmer2) runMatch(person1) runMatch(programmer3)>

Sortir:

Name: Om, Language:Python, Framework:Django Name:Rishabh, Language:C++ Name:Vishal Name:Sankalp, Language:Javascript, Framework:React>

FAQ sur les déclarations de cas de correspondance Python

Q : Qu'est-ce que l'instruction match case en Python ?

R : L'instruction match-case, également connue sous le nom de correspondance de modèles, est une fonctionnalité introduite dans Python 3.10. Il fournit un moyen concis et expressif d'effectuer une correspondance de modèles sur des structures de données, telles que des tuples, des listes et des classes. Il vous permet de faire correspondre la valeur d'une expression à une série de modèles et d'exécuter le bloc de code correspondant pour le modèle correspondant.

Q : En quoi l'instruction match case diffère-t-elle des instructions if-elif-else ?

R : L'instruction match-case est une construction plus puissante et plus expressive que les instructions if-elif-else. Alors que les instructions if-elif-else reposent sur des expressions booléennes, les instructions match-case peuvent correspondre à des modèles basés sur la structure et la valeur des données. Les instructions match-case offrent un moyen plus structuré et plus lisible de gérer plusieurs conditions et d'effectuer différentes actions en fonction de ces conditions.

Q : Quels sont les avantages de l’utilisation de l’instruction match-case ?

R : La déclaration de cas de correspondance offre plusieurs avantages, notamment :

• Concision : les instructions de correspondance de casse vous permettent d'exprimer une logique de branchement complexe de manière concise et lisible.
• Lisibilité : la correspondance de modèles rend le code plus lisible et plus explicite, car il ressemble beaucoup au domaine du problème.
• Sécurité : les instructions Match-case fournissent une correspondance de modèles exhaustive, garantissant que tous les cas possibles sont traités.