match-case Python

Ah, Python a enfin son switch-case !

Détrompez-vous, le pattern matching introduit depuis Python 3.10 va bien au-delà…

Là où d’autres langages proposent un switch basique sur des valeurs scalaires, Python offre un système sophistiqué capable de :

• Déconstruire des structures de données complexes

• Appliquer des gardes conditionnelles

• Capturer des portions spécifiques de données

Ce n'est pas clair ? Alors commençons par les bases :

def analyser_donnee(valeur):
	match valeur:
		case 0:
			return "Zéro détecté"
		case 1 | 2 | 3:
			return "Petit nombre"
		case 42 as answer:
			return f"La réponse à tout : {answer}"
		case n if n > 100:
			return f"Grand nombre : {n}"
		case _:
			return "Autre valeur"

Notez déjà :

• Le pipe | permet de regrouper plusieurs conditions

• Le mot-clé as (que l’on retrouve aussi dans le contexte du with)

• La garde, avec if, ajoute une logique conditionnelle

• L’utilisation de variables (answer et n) permet de stocker la valeur matchée

• le wildcard _ capture tout le reste

Pratique et lisible, fini les if-elif-else très verbeux !

Continuons avec un autre exemple : la déconstruction de listes

def analyser_coordonnees(p):
	match p:
		case (0,0):
			return "Origine"
		case (x, 0):
			return f"Point sur l'abscisse, {x=}"
		case [0, y]:
			return f"Point sur l'ordonnée, {y=}"
		case [x, y]:
			return f"Point aux coordonnées ({x}, {y})"
		case _ as other:
      return f"Point invalide : {other}"

Notez ici :

• L’ordre de matching : du plus spécifique au plus générique

• L’utilisation de variables pour stocker les valeurs matchées

• Aucune différence ici entre un tuple et une liste. En effet, seules les valeurs sont testées

Enfin, le pattern matching fonctionne avec n’importe quel objet dont les valeurs peuvent être testées (à condition de spécifier à Python les arguments à tester)

class Point:
    __match_args__ = ("x", "y") # pour aider le pattern matching
    def __init__(self, x, y):
        self.x, self.y = x, y
        
def analyser_coordonnees(p):
    match p:
        case Point(0, 0):
            return "Origine"
        case Point(x, 0):
            return f"Point sur l'abscisse, {x=}"
        case Point(0, y):
            return f"Point sur l'ordonnée, {y=}"
        case Point(x, y):
            return f"Point aux coordonnées ({x}, {y})"
        case _ as other:
            return f"Point invalide : {other}"

Excepté le __match_args__ qui permet à un objet d’être matché, rien de nouveau.

Au passage, un rappel d’un ancien article sur les f-strings avec la syntaxe {x=} 🙂

Pour finir, quelques subtilités :

• L’ordre est important : un case trop générique capturera tout sur son passage

• Les gardes utilisent les expressions d’un if. Soyez créatifs ;)

• Le case ne compare que les literals : case x ne compare pas la valeur à x mais capture dans x

Le match-case est une fonctionnalité puissante et flexible qui peut grandement simplifier votre code Python. Cela offre une syntaxe claire et concise et mérite qu’on s’y intéresse.

Alors, la prochaine fois que vous hésitez entre un if de trop ou un elif bancal, pensez match ;)