A correspondência de padrões estruturais é um recurso poderoso do Python que permite tomar decisões com base na estrutura de dados complexos e extrair deles os valores desejados. Ele fornece uma maneira concisa e declarativa de expressar lógica condicional e pode melhorar muito a legibilidade e a manutenção do código. Neste artigo, exploraremos alguns exemplos de estudos de caso reais do uso de correspondência de padrões estruturais em Python.

1. Analisando respostas da API
Um caso de uso comum para correspondência de padrões estruturais é a análise de respostas de API. Imagine que você está trabalhando com uma API meteorológica que retorna dados no seguinte formato:

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

Para extrair a temperatura desta resposta, você pode usar a correspondência de padrões estruturais da seguinte maneira:

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.")

Este padrão corresponde a qualquer dicionário com uma chave "clima_atual" e, dentro dessa chave, corresponde ao valor de "temperatura" e o extrai como a variável temp. Isso permite que você acesse facilmente os dados desejados sem ter que escrever várias instruções if para verificar a existência de chaves.

2. Processamento de dados
A correspondência de padrões estruturais também pode ser útil ao trabalhar com grandes conjuntos de dados. Imagine que você tem um conjunto de dados contendo informações sobre diferentes produtos, incluindo nome, categoria e preço. Você deseja filtrar o conjunto de dados para incluir apenas produtos abaixo de um determinado limite de preço. Você pode usar a correspondência de padrões para extrair os dados desejados e filtrá-los da seguinte maneira:

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.")

Neste exemplo, os padrões correspondem e extraem os valores com base nas restrições de categoria e preço. Isso permite uma abordagem mais concisa e legível para filtrar o conjunto de dados.

3. Validando a entrada do usuário
A correspondência de padrões estruturais também pode ser útil para validar a entrada do usuário. Imagine que você está criando um formulário de inscrição para um site e deseja garantir que o e-mail do usuário esteja no formato correto e que sua senha atenda a determinados requisitos. Você poderia usar a correspondência de padrões para realizar essas validações da seguinte maneira:

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) 



Este padrão corresponde e valida o formato do e-mail usando uma expressão regular e o comprimento da senha usando uma verificação de comprimento. Esta abordagem pode ser facilmente estendida para incluir validações adicionais conforme necessário.

4. Funções de despacho dinâmico

Outro caso de uso interessante para correspondência de padrões estruturais é o despacho dinâmico de funções com base em parâmetros de entrada. Imagine que você está trabalhando com um programa de calculadora onde o usuário pode inserir uma operação e dois números, e o programa realizará o cálculo para eles. Você pode usar a correspondência de padrões para executar a função correta com base na operação especificada da seguinte maneira:


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





Este padrão corresponde ao operador especificado e executa a função correspondente do módulo do operador. Isso fornece uma abordagem compacta e extensível para lidar com diferentes operações sem a necessidade de escrever várias instruções if.

Conclusão

A correspondência de padrões estruturais é um recurso poderoso do Python que permite código conciso, declarativo e seletivo. Ele pode ser usado em vários cenários, desde a análise de respostas da API até a validação da entrada do usuário e o envio dinâmico de funções. Ao aproveitar os padrões estruturais, você pode melhorar a legibilidade e a manutenção do seu código e tornar a lógica complexa mais gerenciável.