DESCRIPTION.

Exécute une séquence d'instructions selon la valeur de l'objet évalué.

SYNTAXE.

match objet : 

match ⇨ appel de l’instruction [ OBLIGATOIRE ]

objet ⇨ expression à évaluer [ OBLIGATOIRE ]

: ⇨ début du bloc selon que expression vaut [ OBLIGATOIRE ]

case valeur : 

case ⇨ appel de l’instruction [ OBLIGATOIRE ]

valeur ⇨ valeur donnant accès au blocs à exécuter [ OBLIGATOIRE ]

: ⇨ début de la partie du script à exécuter si objet vaut valeur [ OBLIGATOIRE ]

case valeur if expression : 

case ⇨ appel de l’instruction [ OBLIGATOIRE ]

valeur ⇨ valeur donnant accès au blocs à exécuter [ OBLIGATOIRE ]

if ⇨ appel de l’instruction [ OBLIGATOIRE ]

expression ⇨ expression à évaluer [ OBLIGATOIRE ]

: ⇨ début de la partie du script à exécuter si objet vaut valeur et si expression vaut True [ OBLIGATOIRE ]

case _ : 

case _ ⇨ appel de l’instruction [ OBLIGATOIRE ]

: ⇨ début de la partie du script à exécuter si objet ne correspond à aucune valeur [ OBLIGATOIRE ]

PRÉSENTATION GÉNÉRALE D'UNE EXECUTION SELON QUE.

match objet : (débute une séquence selon que l'objet vaut : ) 

case valeurA : (test si l'objet à la vaut valeurA) 

ligne A1 (partie du script à exécuter si objet vaut valeurA) 

ligne A2

ligne An (après cette ligne de code sortie du bloc selon que, reprendre l'exécution à ligne S1 ) 

case valeurB : (test si l'objet à la vaut valeurB) 

ligne B1 (partie du script à exécuter si objet vaut valeurB) 

ligne B2

ligne Bn (après cette ligne de code sortie du bloc selon que, reprendre l'exécution à ligne S1 ) 

case valeurC if expression :  (test si l'objet à la vaut valeurC et si expression vaut True) 

ligne C1 (partie du script à exécuter si objet vaut valeurC et si expression vaut True) 

ligne C2

ligne Cn (après cette ligne de code sortie du bloc selon que, reprendre l'exécution à ligne S1 ) 

case valeurN : (test si l'objet à la vaut valeurN) 

ligne N1 (partie du script à exécuter si objet vaut valeurN) 

ligne N2

ligne Nn (après cette ligne de code sortie du bloc selon que, reprendre l'exécution à ligne S1 ) 

case _ : ( l'objet n'a aucune des valeurs tester, avec ou sans gardien) 

ligne _ (partie du script à exécuter si objet n'a aucune des valeurs tester) 

ligne _

ligne _ (après cette ligne de code sortie du bloc selon que, reprendre l'exécution à ligne S1 ) 

ligne S1 (suite du script) 

ligne S2

ligne Sn

REMARQUES.

match est une instruction composée (de plusieurs lignes), ce qui implique le symbole : (2 points) terminant l'appel de match et l'indentation des lignes de script composant le bloc. Mais aussi que chaque case est une instruction composée (de plusieurs lignes), ce qui implique le symbole : (2 points) terminant l'appel de case et l'indentation des lignes de script composant le bloc.

La clause case _ est facultative. Mais si on peut effectuer autant de tests case que l'on souhaite, on ne peut placer qu'une seule clause case _ par instruction match.

Les instructions match et case ne sont disponibles qu'à partir de Python 3.10. Elles permettent de réaliser des blocs séquentiels "selon que". Elles sont identifiées dans la terminaison Python comme filtrage par motif.

Les instructions match, case et case _ ne sont pas retenues comme mots clés du langage. Elles sont appelées mots-clés ad hoc et ne sont considérées comme réservées que dans des cas bien particuliers. Bien que ceci soit déconseillé, elles pourront donc être utilisées comme nom de variable, sauf dans les contextes de filtrage dans un bloc "selon que", où elles seront réservées.  

CAS GENERAL.

Notez qu'il n'est pas obligatoire de déclarer une variable avant de l'utiliser dans un bloc case. Et que, si une variable est déclarée dans un bloc case, la valeur qui lui a été affectée est toujours accessible à la sortie du bloc match. La portée, globale ou locale, d'une telle variable est celle qu'elle aurait eu si elle avait été déclaré juste avant l'entrée du bloc match.

kht = int ( input ( "Prix de l'article ? " ) ) # Saisie d'une valeur numérique

ktaux = input ( "taux de la taxe ( A = 3%, B = 7%, C = 15%, D = 33% ) ? " ) # Saisie d'une valeur dans une liste de choix

match ktaux.upper ( ) : # Déclaration d'un bloc selon que "la valeur de ktaux en majuscule" vaut 

case "A" : # Si "la valeur de ktaux en majuscule" vaut A alors faire

ktaxe = ( kht / 100 ) * 3 # Calculer le montant de la taxe de 3% et sortir du bloc selon que

case "B" : # Si "la valeur de ktaux en majuscule" vaut B alors faire

ktaxe = ( kht / 100 ) * 7 # Calculer le montant de la taxe de 7% et sortir du bloc selon que

case "C" : # Si "la valeur de ktaux en majuscule" vaut C alors faire

ktaxe = ( kht / 100 ) * 15 # Calculer le montant de la taxe de 15% et sortir du bloc selon que

case "D" : # Si "la valeur de ktaux en majuscule" vaut D alors faire

ktaxe = ( kht / 100 ) * 33 # Calculer le montant de la taxe de 33% et sortir du bloc selon que

case _ :  # Si "la valeur de ktaux en majuscule" n'est ni A, ni B, ni C, ni D, alors faire

ktaxe = 0 # Affecter 0 à la variable ktaxe

print ( "Ce taux de taxe n'existe pas." ) # Afficher un message

if ktaxe != 0 :

print ( "Montant de la taxe :" , ktaxe )

print ( "Prix de facturation :" , kht + ktaxe )

Si un bloc case ne se compose que d'une unique fonction, il est possible, pour condenser le code, de l'écrire à la suite de deux points. Par exemple :

kht = int ( input ( "Prix de l'article ? " ) ) 

ktaux = input ( "taux de la taxe ( A = 3%, B = 7%, C = 15%, D = 33% ) ? " ) 

match ktaux.upper ( ) : 

case "A" : ktaxe = ( kht / 100 ) * 3

case "B" : ktaxe = ( kht / 100 ) * 7 

case "C" : ktaxe = ( kht / 100 ) * 15 

case "D" : ktaxe = ( kht / 100 ) * 33 

case _ :  ktaxe = 0

if ktaxe != 0 :

print ( "Montant de la taxe :" , ktaxe )

print ( "Prix de facturation :" , kht + ktaxe )

else :

print ( "Ce taux de taxe n'existe pas." )

FILTRER UN OBJET SEQUENCE.

Si objet, associé à une instruction match, est une collection, un objet séquence, tel que une list ( ) ou un tuple ( ), valeur filtré par les instructions case doivent être un objet de même type, et comporter le même nombre d'éléments, même si celui-la peut varier selon les besoins du script, et à la condition que cette variation dans le nombre d'éléments soit connue, sinon il faudra utiliser le déballage étendu, décrit plus bas.

LST_Menu = [ ]

print ( "Bonjour, le Plat du jour est à 8€." )

if input ( "Prendrez-vous une entrée ( 3€ ) ( O ou N) ? " ).upper ( ) != "N" : LST_Menu.append ( "E" )

LST_Menu.append ( "P" )

if input ( "Prendrez-vous du fromage ( 2€ ) ( O ou N) ? " ).upper ( ) != "N" : LST_Menu.append ( "F" )

if input ( "Prendrez-vous un dessert ( 4€ ) ( O ou N) ? " ).upper ( ) != "N" : LST_Menu.append ( "D" )

match LST_Menu : 

case [ "P" ] : print ( "Cela vous fera 8€." )

case  [ "E" , "P" ] : print ( "Cela vous fera 11€." )

case  [ "P" , "F" ] : print ( "Cela vous fera 10€." )

case  [ "P" , "D" ] : print ( "Cela vous fera 12€." )

case  [ "E" , "P" , "F" ] : print ( "Cela vous fera 13€." )

case  [ "E" , "P" , "D" ] : print ( "Cela vous fera 15€." )

case  [ "P" , "F" , "D" ] : print ( "Cela vous fera 14€." )

case  [ "E" , "P" , "F" , "D" ] : print ( "Cela vous fera 17€." )

case _ : print ( "Vous préférez la carte. Cela fera 25€." )

print ( "Merci et bon appétit." )

UTILISATION DU FILTRE | ( OU ).

Dans certains cas, un objet peut être affecté de valeurs différentes pour un même résultat. Par exemple False, 0 , ( ) , [ ] sont des expression équivalente dont kvaleur = False, kvaleur = 0, kvaleur = ( ), ou kvaleur = [ ], seront des expressions équivalentes, dans un test conditionnel if. Pour indiquer qu'une clause case doit être exécuter avec plusieurs valeurs, équivalente ou même différentes, de l'objet on utilisera le symbole | (une barre verticale) entre les valeurs qui devront être prise en considération.

kcouleur = input ( "Valeur de la couleur primaire. " )

match kcouleur : 

case "red" | "RED" | (255 , 0 , 0) | "ff0000"  : print ( "C'est du rouge." )

case "lime" | "LIME" | (0 , 255 , 0) | "00ff00"  : print ( "C'est du vert." )

case "blue" | "BLUE" | ( 0 , 0 , 255) | "0000ff"  : print ( "C'est du bleu." )

case _ :  print ( "Python ne peut pas associer une couleur primaire à votre demande." )

Bien entendu, il est tout à fait possible associer directement une méthode input ( ) à une instruction match, mais toujours avec prudence, car, alors, il deviendra peut aisé d'intercepter et/ou de controler la saisie de l'utilisateur, pour la convertir en un autre type de donnée, par exemple.

match input ( "Valeur de la couleur primaire " ) : 

case "red" | "RED" | (255 , 0 , 0) | "ff0000"  : print ( "C'est du rouge." )

case "lime" | "LIME" | (0 , 255 , 0) | "00ff00"  : print ( "C'est du vert." )

case "blue" | "BLUE" | ( 0 , 0 , 255) | "0000ff"  : print ( "C'est du bleu." )

case _ :  print ( "Python ne peut pas associer une couleur primaire à votre demande." )

UTILISATION DU FILTRE | ( OU ) DANS UNE COLLECTIONS.

Le filtre | pourra aussi être utilisé pour rechercher n'importe quelle éléments dans un tuple ( ) qui sera donné comme l'une des valeurs de l'instruction case. Dans ce cas il suffira que l'un des éléments du tuple ( ) corresponde à la valeur recherchée pour valider le code du bloc.

print ( "Epreuves : course - saut - lancer." )

print ( "Catégories : P pour Poussin, B pour Benjamin, C pour Cadet, J pour Junior, S pour Senior." )

kcandidat = input ( "Votre épreuve et votre catégorie (ex. course B) ? " )

match kcandidat.split ( ) : 

case [ "course" , ( "P" | "B" | "C" ) ] :

print ( "Votre course aura lieu samedi matin." )

case [ "course" , ( "J" | "S" ) ] : 

print ( "Votre course aura lieu dimanche après-midi." )

case [ "saut" , ( "P" | "J" ) ] : 

print ( "Votre saut aura lieu samedi après-midi." )

case [ "saut" , ( "B" | "C" | "S" ) ] : 

print ( "Votre saut aura lieu dimanche matin." )

case [ "lancer" , ( "J" | "S" ) ] : 

print ( "Votre lancer aura lieu samedi après-midi." )

case [ "lancer" , ( "P" | "B" | "C" ) ] : 

print ( "Votre lancer aura lieu dimanche matin." )

case _ :  

print ( "Votre demande n'a pas pu être correctement analysée." )

UTILISATION DU FILTRE | ( OU ) DANS UNE COLLECTIONS AVEC CAPTURE D'UN ALIAS.

Dans le cas où il serait nécessaire de savoir quelle valeur a été retenue dans la collection de valeurs, pour la suite du traitement, Python offre la possibilité d'affecter cette valeur à une variable. Par exemple, dans le script précédent, on pourra intercepter la catégorie du candidat, qui a été retenue, et fournir un complément d'information pertinant.

print ( "Epreuves : course - saut - lancer." )

print ( "Catégories : P pour Poussin, B pour Benjamin, C pour Cadet, J pour Junior, S pour Senior." )

kcandidat = input ( "Votre épreuve et votre catégorie (ex. course B) ? " )

match kcandidat.split ( ) : 

case [ "course" , ( "P" | "B" | "C" ) as kcategorie ] : print ( "Votre course aura lieu samedi matin." )

case [ "course" , ( "J" | "S" ) as kcategorie ] : print ( "Votre course aura lieu dimanche après-midi." )

case [ "saut" , ( "P" | "J" ) as kcategorie ] : print ( "Votre saut aura lieu samedi après-midi." )

case [ "saut" , ( "B" | "C" | "S" ) as kcategorie ] : print ( "Votre saut aura lieu dimanche matin." )

case [ "lancer" , ( "J" | "S" ) as kcategorie ] : print ( "Votre lancer aura lieu samedi après-midi." )

case [ "lancer" , ( "P" | "B" | "C" ) as kcategorie ] : print ( "Votre lancer aura lieu dimanche matin." )

case _ :  print ( "Votre demande n'a pas pu être correctement analysée." )

match kcategorie : 

case "P"  : print ( "Les Poussins doivent obligatoirement être accompagnés d'un parent." )

case "B" | "C" : print ( "Les benjamins et les Cadets doivent être sous la responsabilité d'un adulte." )

case "J" : print ( "Les Juniors mineurs non accompagnés devront avoir une autorisation signée." )

case "S" : print ( "Les Seniors devront présenter une pièce d’identité en plus de leur licence." )

UTILISATION D'UN GARDIEN.

Un branchement case peut être placé sous la condition d'un gardien. Un gardien est un test conditionnel if, dont l'expression doit être évaluée à True pour valider l'exécution de la séquence associée à l'instruction case. Cela permet de réaliser des actions selon la valeur de objet mais aussi en fonction d'une ou de plusieurs autres valeurs.

Si un ou des gardiens sont utilisés, il faudra faire attention à l'ordre dans le quel ils sont placés, car dès qu'un des gardiens aura autorisé l'accès à sa séquence, le script se poursuivra sur la ligne sous le bloc match après l'exécution de cette séquence, la validation d'un bloc case étant exclusive.

kscore = 0

for ktirage in ( "1ère" , "2ème" ) :

kcarte = input ( f"Valeur de la { ktirage } carte retournée ? " )

match kcarte :

case "V" | "D" | "R" :

kscore += 10

case "A" | "1" if kscore != 11 : # test si la carte est un as et si la première carte n'était pas un as

kscore += 11

case "A" | "1" :

kscore += 10

case _ : 

kscore += int ( kcarte )

print ( f"Nombre de points après le { ktirage } tirage : { kscore } .\n" )

UTILISATION DU DEBALLAGE ETENDU.

Si objet est un objet séquence, tel que list ( ) ou tuple ( ), dont on ne connait pas à l'avance le nombre d'items, il est possible de d'utiliser le caractère générique * (étoile) pour précisée que les éléments qui terminent cette séquence sont considérés comme un unique objet séquence. Il ne peut y avoir qu'un seul objet séquence étoilé par instruction case.

print (  "Entrez A pour Additionner, S pour Soustraire, ou M pour Moyenne, puis un espace " )

print (  "suivie de tous les termes de l'opération séparé par un espace, sans virgule ni point." )

print (  "Exemple 1 :  A 34 67 56 2 (pour additionner 34, 67, 56 et 2)." )

print (  "Exemple 2 :  S 1254 54 132 36 (pour Soustraire 54 132 36 de 1254)." )

print (  "Exemple 3 :  M 13 7 9 16 14 (pour calculer la moyenne des notes 13 7 9 16 14)." )

while True : 

kresultat = 0

ksaisie = input ( "Entrez votre demande ... " )

match ksaisie.split ( ) : # décompose ksaisie entre les espaces et retourne une list ( ) de str ( ) de longueur inconnue

case [ "A" | "a" , *ktermes ] : # L'utilisateur a demandé une addition de toutes les valeurs

for kterme in ktermes : kresultat += int ( kterme )

print ( "La somme de :" , ktermes , "est" , kresultat )

case [ "S" | "s" , *ktermes ] : # L'utilisateur a demandé une soustraction de toutes les valeurs

kcapital = ktermes.pop ( 0 )

kresultat = int ( kcapital )

for kterme in ktermes : kresultat -= int ( kterme )

print ( "Les valeurs :" , ktermes , "retirées de" , kcapital , "donnent" , kresultat )

case [ "M" | "m" , *ktermes ] : # L'utilisateur a demandé de calculer la moyenne de toutes les valeurs

for kterme in ktermes : kresultat += int ( kterme )

kmoyenne = kresultat / len ( ktermes )

print ( "Le total des valeurs :" , ktermes , "est de" , kresultat )

print ( "il y a" , len ( ktermes ) , "valeurs dans votre demande." )

print ( "La moyenne des valeurs :" , ktermes , "est de" , kmoyenne )

case _ : 

print ( "Désolé je ne comprend pas votre requête." )

if input ( "Une autre demande (O ou N) ? " ) in ( "N" , "n" ) : break