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

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.