Switch Case en Python avec l'instruction match

Comment utiliser le match-case ? Pourquoi le préférer à des ifs ? À quoi cette instruction sert ? Découvrez tout sur le switch-case version Python !

Les instructions match-case sont arrivées avec la version 3.10 de Python et PEP 634. C’est l’équivalent du switch-case des autres langages de programmation. Cette instruction de “Filtrage par motif structurel” permet de vérifier qu’une variable correspond à une des valeurs définies.

match-case se présente comme ça en Python :

match valeur:
  case pattern_1:
    expression_1
  case pattern_2:
    expression_2
  case pattern_3:
    expression_3
  case _:
    expression_par_defaut

En apprendre plus sur l’instruction match case en vidéo :

Avant Python 3.10, on était obligé d’avoir des conditions if pour tester si le contenu d’une variable matchait un pattern.

def switch(jour):
  if jour == 1:
    return 'Lundi'
  elif jour == 2:
    return 'Mardi'
  elif jour == 3:
    return 'Mercredi'
  elif jour == 4:
    return 'Jeudi'
  elif jour == 5:
    return 'Vendredi'
  elif jour == 6:
    return 'Samedi'
  elif jour == 7:
    return 'Dimanche'
  else:
    return 'Pas un jour de la semaine'

Maintenant avec l’instruction match, on peut éviter les instruction if-elif-else pour avoir un code plus lisible.

match jour:
  case 1:
    return 'Lundi'
  case 2:
    return 'Mardi'
  case 3:
    return 'Mercredi'
  case 4:
    return 'Jeudi'
  case 5:
    return 'Vendredi'
  case 6:
    return 'Samedi'
  case 7:
    return 'Dimanche'
  case _:
    return 'Pas un jour de la semaine'

Comment implémenter un switch-case en Python ?

Si vous utilisez une version antérieure à Python 3.10, il peut être utile de créer sa propre instruction switch/match case. On peut faire ça en créant une fonction qui prend un paramètre et le test contre différents patterns.

def switch(valeur):
  if valeur == pattern_1:
    expression_1
  elif valeur == pattern_2:
    expression_2
  elif valeur == pattern_3:
    expression_3
  else:
    expression_par_defaut

• def est le mot clé qui permet de créer une fonction en python
• switch est le nom de la fonction
• valeur est le paramètre de la fonction
• if, elif et else sont des mots clés de condition
• pattern_x sont les valeurs avec lesquelles on compare notre variable valeur
• expression_x est le code qui sera exécuté ou retourné si la comparaison est vraie
• expression_par_defaut est ce qui sera exécuté si valeur ne correspondait à aucun pattern

Comment vérifier le code statut d’une requête en Python ?

On peut facilement vérifier le statut d’une réponse HTTP avec un match case en Python.

Prenons l’exemple ci-dessous où on a un code réponse (response_code) qu’on test contre plusieurs valeurs.

Ce code nous permettra de renvoyer de meilleurs messages à nos utilisateurs.

response_code = 200

match response_code:
  case 200:
    print("Tout s'est bien passé 🎉")
  case 300 | 301 | 302:
    print("Vous allez être redirigé 😅")
  case 400 | 404:
    print("Cette page ne semble pas exister 😭")
  case 500:
    print("Oops, quelque chose s'est mal passé 🤯")

Notre requête simple qui s’est bien passée avec un code 200 affichera Tout s'est bien passé 🎉 sur la sortie standard.

Cet exemple est très simple, il faudrait ajouter une meilleure gestion d’erreur avec plus de code d’erreur et plus de personnalisation.

Notez aussi l’utilisation des opérateurs | quand on veut passer plusieurs valeurs contre lesquelles tester notre variable !

Comment verifier l’intégrité d’une structure en Python ?

Il est possible de verifier la structure d’un objet en Python avec l’instruction switch case (match-case) en Python.

Prenons une liste de n éléments, on va print une phrase différente en fonction de la structure de cette liste.

liste = ['un', 'deux', 'trois', 'quatre', 'cinq', 'six']

match liste:
  case [a]:
    print(f'Une seule valeur : {a}')
  case [a, b]:
    print(f'Deux valeurs : {a} et {b}')
  case [a, b, c]:
    print(f'Trois valeurs : {a}, {b} et {c}')
  case [a, b, c, d]:
    print(f'Quatre valeurs : {a}, {b}, {c} et {d}')
  case [a, b, c, d, *reste]:
    print(f'Quatre valeurs {a}, {b}, {c}, {d} mais aussi {", ".join(reste)}')

Qui affichera la chaîne de caractères Quatre valeurs un, deux, trois, quatre mais aussi cinq, six sur la sortie standard.

Comment gérer les commandes en argument en Python ?

On peut aussi utiliser l’opérateur pipe (|) pour tester un ou plusieurs elements de la liste.

Imaginons un script qui prend des commandes pour ajouter ou soustraire un nombre à un nombre total.

En Python, on peut utiliser les valeurs passer en argument depuis la console avec la variable sys.argv.

sys.argv[0] est le nom du fichier donc on commence à sys.argv[1].

import sys

match sys.argv[1:]:
  case ['ajouter', valeur_a_ajouter, valeur_de_depart]:
    print(f'On a ajouté {valeur_a_ajouter} à {valeur_de_depart}, ce qui donne {int(valeur_de_depart) + int(valeur_a_ajouter)}')
  case ['soustraire', valeur_a_soustraire, valeur_de_depart]:
    print(f'On a soustrait {valeur_a_soustraire} à {valeur_de_depart}, ce qui donne {int(valeur_de_depart) - int(valeur_a_soustraire)}')
  case ['aide']:
    print('Ajouter un message d\'aide qui explique à l\'utilisateur comment utiliser le script')

Si on lance le script python comme ça python NOM_DU_SCRIPT.py ajouter 5 4, on aura On a ajouté 5 à 4, ce qui donne 9 en sortie standard.

Quelle est la différence entre if et match ?

L’instruction if évalue une valeur booléenne qui la suit alors que match fait du Filtrage par motif (Pattern matching en anglais). L’instruction match est donc mieux adaptée pour filter et aura des meilleures performances dans ce cas.