Utilisation de 'match...case' dans Python 3.10

La syntaxe "match...case" est similaire à l'instruction switch dans d'autres langages orientés objet, et elle est conçue pour faciliter la correspondance des structures avec les cas.

Commençons.

Syntaxe

La syntaxe "match...case" est la suivante :

def greeting(message):
match message.split():
case ["hello"]:
print("this message says hello")
case ["hello", name]:
print("This message is a personal greeting to {name}")
case _:
print("The message didn’t match with anything")

Passons en revue la syntaxe pour voir comment elle fonctionne.

La fonction que nous avons créée accepte un paramètre appelé message. Le mot-clé match accepte un objet pour comparer les cas répertoriés.

Dans notre exemple, le mot-clé match reçoit une liste de chaînes, qui est le résultat de l'opération message.split(). Pour illustrer davantage, supposons que nous appelions la fonction comme ceci :

greeting("hello")

La fonction divise d'abord cette chaîne en tous les espaces et forme une liste. Pour l'entrée ci-dessus, l'opérateur de correspondance utilisera la liste ["hello"]. Il compare ensuite la liste avec chaque cas. Notre premier cas est :

case ["hello"]

Notre entrée correspond exactement à cela, donc le code continue de s'exécuter dans ce cas.

Sortie :

this message says hello

Que se passe-t-il si nous appelons la fonction comme ceci : Greeting("hello George") ?

Avec cette entrée, l'opérateur de correspondance utilisera la liste ["hello", "George"] pour comparer tous les cas. Le premier cas, le cas "bonjour", ne correspondra pas car il y a deux éléments dans la liste de comparaison, pas un.

Correspondance structurelle

L'opérateur de correspondance correspond à la structure de l'expression donnée, donc notre premier cas ne correspond pas en raison de la longueur de l'expression de cas, même si l'expression de comparaison correspond au premier élément de la liste.

Le deuxième cas est ["bonjour", nom]. C'est ce qui se passe lorsque notre entrée correspond. Si vous ne fournissez pas à Python une valeur littérale à laquelle correspondre, il liera toute valeur de l'expression de comparaison au nom de la variable dans l'expression de cas. Ainsi, dans notre exemple, le nom sera défini sur George. Et ce cas correspond (il a "hello" comme premier élément, et il y a aussi un élément, qui est lié au nom), donc le résultat est :

This message is a personal greeting to George

Essayons maintenant d'appeler la fonction comme ceci : Greeting(" hello George Johnson »).

L'expression de comparaison devient ["hello", "George", "Johnson"]. Examinons maintenant chaque cas. Le premier cas échoue car il y a 3 éléments dans l’expression de comparaison, et non 1. Le deuxième cas échoue de la même manière ; le deuxième cas s'attend à voir une liste de longueur 2 où le premier élément est "hello". Le premier élément est en fait "bonjour", mais l'expression de comparaison comporte 3 éléments, donc ce cas ne correspond pas.

La seule option restante est la casse de soulignement, qui est la casse par défaut qui correspond à tout. Pensez-y comme au cas par défaut dans une instruction switch. Si l’expression de comparaison ne correspond à rien d’autre, elle correspondra toujours à la casse _.

Souligner comme dernier cas Aucun cas dans ce cas ne sera exécuté car tous les cas correspondront au cas souligné. Ceci est similaire au mot-clé else dans if...else. _ case correspond à tout car Python reconnaît _ comme nom de variable valide. Ainsi, comme lorsque nous faisons correspondre case ["hello", name], l'expression de comparaison sera liée à _ name. Dans notre cas particulier, la variable _ contiendra les valeurs ["hello", "George", "Johnson"].

Donc, dans notre dernier appel de fonction Greeting("hello George Johnson"), le résultat sera :

The message didn’t match with anything

Utilisation avancée

La syntaxe "match...case" est un outil très puissant pour comparer de nombreuses expressions et valeurs différentes. . Si vous comparez les listes comme nous l'avons fait dans l'exemple ci-dessus, davantage de fonctionnalités de correspondance sont disponibles.

Dans une expression de cas, vous pouvez utiliser des opérateurs pour mettre tous les éléments restants dans des variables. Par exemple :

comparison_list = ["one", "two", "three"]
match comparison_list:
case [first]:
print("this is the first element: {first}")
case [first, *rest]:
print("This is the first: {first}, and this is the rest: {rest}")
case _:
print("Nothing was matched")

Dans cet extrait, le deuxième cas sera mis en correspondance et exécuté avec le résultat :

This is the first: one, and this is the rest: ["two", "three"]

Les branches de cas peuvent également être combinées à partir de deux ou plusieurs structures comme celle-ci :

match comparisonList:
 case [first] | [first, "two", "seven"]:
 print("this is the first element: {first}")
 case [title, "hello"] | ["hello", title]:
 print("Welcome esteemed guest {title}")
 case [first, *rest]:
 print("This is the first: {first}, and this is the rest: {rest}")
 case _:
 print("Nothing was matched")

Le premier cas et le deuxième cas sont constitués de plusieurs expressions différentes auxquelles une expression de comparaison peut être ajustée pour exécuter la branche case. Cela offre une certaine flexibilité dans la combinaison de branches.

Nous introduirons également la syntaxe "match...case" pour les dictionnaires. L'opérateur de correspondance vérifie si l'expression de comparaison contient les attributs de l'expression de cas. Par exemple :

comparisonDictionary = {
 "John": "boy",
 "Jack": "boy",
 "Jill": "girl",
 "Taylor": "girl"
}
match comparisonDictionary:
 case {"John": "boy", "Taylor": "boy"}:
 print("John and Taylor are both boys")
 case {"John": "boy", "Taylor": "girl"}:
 print("Taylor is a girl and John is a boy")
 case _:
 print("Nothing matches")

Sortie :

Taylor is a girl and John is a boy

L'opérateur de correspondance vérifiera si l'attribut case existe dans le dictionnaire d'entrée, puis vérifiera si les valeurs correspondent.

En résumé, le nouvel opérateur "match...case" est un outil puissant dont les développeurs Python peuvent profiter lors de la création de cas de branchement. Avec lui, vous pouvez vérifier de manière fiable la structure de n'importe quelle variable entrante et vous assurer que vous n'essayez pas d'accéder à quelque chose qui n'existe pas sur la variable.

Important Dans la correspondance de dictionnaire, la casse correspondra toujours même si le dictionnaire d'entrée a plus d'attributs que la casse ne le spécifie.

En conclusion, le nouvel opérateur "match...case" est un outil puissant dont les développeurs Python peuvent profiter lors de la création de cas de branchement. Avec lui, il est possible de vérifier de manière fiable la structure de n'importe quelle variable entrante et de s'assurer qu'aucune tentative n'est faite pour accéder à quelque chose qui n'existe pas sur la variable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!