La correspondance de modèles structurels est une fonctionnalité puissante de Python qui vous permet de prendre des décisions basées sur la structure de données complexes et d'en extraire les valeurs souhaitées. Il fournit une manière concise et déclarative d’exprimer la logique conditionnelle et peut grandement améliorer la lisibilité et la maintenabilité du code. Dans cet article, nous explorerons quelques exemples d'études de cas réels d'utilisation de la correspondance de modèles structurels en Python.

1. Analyse des réponses de l'API
Un cas d’utilisation courant de la correspondance de modèles structurels consiste à analyser les réponses de l’API. Imaginez que vous travaillez avec une API météo qui renvoie des données au format suivant :

{
  "current_weather": {
    "location": "New York",
    "temperature": 25,
    "conditions": "Sunny"
  }
}

Pour extraire la température de cette réponse, vous pouvez utiliser la correspondance de modèles structurels comme suit :

response = {
  "current_weather": {
    "location": "New York",
    "temperature": 25,
    "conditions": "Sunny"
  }
}

match response:
    case {"current_weather": {"temperature": temp}}:
        print(f"The current temperature in {response['current_weather']['location']} is {temp} degrees Celsius.")
    case _:
        print("Invalid response.")

Ce modèle correspond à n'importe quel dictionnaire avec une clé "current_weather", et dans cette clé, il correspond à la valeur "température" et l'extrait en tant que variable temp. Cela vous permet d'accéder facilement aux données souhaitées sans avoir à écrire plusieurs instructions if pour vérifier l'existence des clés.

2. Informatique
La correspondance de modèles structurels peut également être utile lorsque vous travaillez avec de grands ensembles de données. Imaginez que vous disposez d'un ensemble de données contenant des informations sur différents produits, notamment leur nom, leur catégorie et leur prix. Vous souhaitez filtrer l'ensemble de données pour inclure uniquement les produits inférieurs à un certain seuil de prix. Vous pouvez utiliser la correspondance de modèles pour extraire les données souhaitées et les filtrer comme suit :

products = [
  {"name": "Smartphone", "category": "Electronics", "price": 500},
  {"name": "T-shirt", "category": "Clothing", "price": 20},
  {"name": "Headphones", "category": "Electronics", "price": 100},
  {"name": "Jeans", "category": "Clothing", "price": 50},
]

match products:
    case [{"category": "Electronics", "price": price} for price in range(200)] as electronics:
        print([product["name"] for product in electronics])
    case [{"category": "Clothing", "price": price} for price in range(40)] as clothing:
        print([product["name"] for product in clothing])
    case _:
        print("No products found.")

Dans cet exemple, les modèles correspondent et extraient les valeurs en fonction des contraintes de catégorie et de prix. Cela permet une approche plus concise et lisible du filtrage de l'ensemble de données.

3. Validation de la saisie utilisateur
La correspondance de modèles structurels peut également être utile pour valider les entrées de l'utilisateur. Imaginez que vous créez un formulaire d'inscription pour un site Web et que vous souhaitez vous assurer que l'adresse e-mail de l'utilisateur est au bon format et que son mot de passe répond à certaines exigences. Vous pouvez utiliser la correspondance de modèles pour effectuer ces validations comme suit :

import re

email = "[email protected]"
password = "12345"

match email:
    case _ if not re.match(r"^\w @[a-zA-Z_] ?\.[a-zA-Z]{2,3}$", email):
        print("Invalid email format.")
    case _ if len(password) 



Ce modèle correspond et valide le format de l'e-mail à l'aide d'une expression régulière et la longueur du mot de passe à l'aide d'une vérification de longueur. Cette approche peut être facilement étendue pour inclure des validations supplémentaires si nécessaire.

4. Fonctions de répartition dynamique

Un autre cas d’utilisation intéressant pour la mise en correspondance de modèles structurels consiste à répartir dynamiquement des fonctions basées sur des paramètres d’entrée. Imaginez que vous travaillez avec un programme de calculatrice dans lequel l'utilisateur peut saisir une opération et deux nombres, et le programme effectuera le calcul à leur place. Vous pouvez utiliser la correspondance de modèles pour exécuter la fonction correcte en fonction de l'opération spécifiée comme suit :


from operator import add, sub, mul, truediv as div

def calculate(operator, num1, num2):
    match operator:
        case " ":
            return add(num1, num2)
        case "-":
            return sub(num1, num2)
        case "*":
            return mul(num1, num2)
        case "/":
            return div(num1, num2)
        case _:
            print("Invalid operation.")

result = calculate("*", 5, 3)
print(f"The result is: {result}")
# Output: The result is: 15





Ce modèle correspond à l'opérateur spécifié et exécute la fonction correspondante à partir du module opérateur. Cela fournit une approche compacte et extensible pour gérer différentes opérations sans avoir à écrire plusieurs instructions if.

Conclusion

La correspondance de modèles structurels est une fonctionnalité puissante de Python qui permet un code concis, déclaratif et sélectif. Il peut être utilisé dans une variété de scénarios, de l'analyse des réponses API à la validation des entrées utilisateur et à la répartition dynamique des fonctions. En tirant parti des modèles structurels, vous pouvez améliorer la lisibilité et la maintenabilité de votre code et rendre la logique complexe plus gérable.