Dicionários no Pattern Matching em Python

O pattern matching permite verificar a presença de determinadas chaves e valores em um dicionário. Vamos ver um exemplo de como isso pode ser feito:

def look(colors):
    match colors:
        case {"red": "vermelho", "blue": "azul"}:  # se 'colors' contém 'red': 'vermelho' e 'blue': 'azul'
            print("As palavras 'red' e 'blue' estão no dicionário")
        case {"red": "vermelho"}:  # se 'colors' contém 'red': 'vermelho'
            print("A palavra 'red' está no dicionário")
        case {"blue": "azul"}:  # se 'colors' contém 'blue': 'azul'
            print("A palavra 'blue' está no dicionário")
        case dict():  # se 'colors' é um dicionário que não corresponde aos casos anteriores
            print("As palavras não estão no dicionário")
        case _:
            print("A entrada não é um dicionário")


look({"red": "vermelho", "blue": "azul", "green": "verde"})  # As palavras 'red' e 'blue' estão no dicionário
look({"red": "vermelho", "green": "verde"})                  # A palavra 'red' está no dicionário
look({"blue": "azul", "green": "verde"})                     # A palavra 'blue' está no dicionário
look({"green": "verde"})                                      # As palavras não estão no dicionário
look("yellow")                                                # A entrada não é um dicionário

Aqui, supõe-se que um objeto colors do tipo dicionário seja passado para a função look. O pattern matching verifica se o dicionário contém determinadas chaves com valores específicos:

Primeiro padrão: { "red": "vermelho", "blue": "azul" } corresponde se ambas as chaves e valores estão presentes.
Segundo padrão: { "red": "vermelho" } corresponde se apenas a chave 'red' com o valor 'vermelho' está presente.
Terceiro padrão: { "blue": "azul" } corresponde se apenas a chave 'blue' com o valor 'azul' está presente.
Quarto padrão: dict() captura qualquer dicionário que não corresponda aos padrões anteriores.
Último padrão: _ captura qualquer entrada que não seja um dicionário.

Usando valores alternativos

Podemos definir valores alternativos para uma chave usando o operador | (barra vertical):

def look(colors):
    match colors:
        case {"red": "vermelho" | "escarlate" | "rubro"}:  # se 'red' tem um dos valores especificados
            print("A palavra 'red' está no dicionário com um valor reconhecido")
        case dict():
            print("As palavras não estão no dicionário")
        case _:
            print("A entrada não é um dicionário")

look({"red": "vermelho", "green": "verde"}) # A palavra 'red' está no dicionário com um valor reconhecido
look({"red": "escarlate", "green": "verde"}) # A palavra 'red' está no dicionário com um valor reconhecido
look({"red": "rubro", "green": "verde"}) # A palavra 'red' está no dicionário com um valor reconhecido
look({"green": "verde"}) # As palavras não estão no dicionário
look("yellow") # A entrada não é um dicionário

Aqui, o padrão {"red": "vermelho" | "escarlate" | "rubro"} verifica se a chave 'red' possui um dos valores especificados.
Caso contrário, se for um dicionário que não corresponda aos padrões anteriores, o padrão dict() será correspondido.
Se não for um dicionário, captura com o padrão _ e informa que a entrada não é um dicionário.

Verificando apenas a presença das chaves

Se nos importamos apenas com a presença das chaves, independentemente dos valores, podemos usar o caractere _ como curinga:

def look(colors):
    match colors:
        case {"red": _, "blue": _}:
            print("As palavras 'red' e 'blue' estão no dicionário")
        case {"red": _}:
            print("A palavra 'red' está no dicionário")
        case {"blue": _}:
            print("A palavra 'blue' está no dicionário")
        case dict():
            print("As palavras não estão no dicionário")
        case _:
            print("A entrada não é um dicionário")

look({"red": "vermelho", "blue": "azul", "green": "verde"}) # As palavras 'red' e 'blue' estão no dicionário
look({"red": "vermelho", "green": "verde"}) # A palavra 'red' está no dicionário
look({"blue": "azul", "green": "verde"}) # A palavra 'blue' está no dicionário
look({"green": "verde"}) # As palavras não estão no dicionário
look("yellow") # A entrada não é um dicionário

Aqui, o curinga _ é usado para verificar apenas a presença das chaves, independentemente dos valores associados a elas.

Definindo padrões alternativos para dicionários

Também podemos definir padrões alternativos para estruturas de dicionários:

def look(colors):
    match colors:
        case {"red": _} | {"blue": _}:  # se 'colors' contém a chave 'red' ou 'blue'
            print("A palavra 'red' ou 'blue' está no dicionário")
        case dict():
            print("As palavras não estão no dicionário")
        case _:
            print("A entrada não é um dicionário")

look({"red": "vermelho", "green": "verde"})  # A palavra 'red' ou 'blue' está no dicionário
look({"blue": "azul", "green": "verde"})  # A palavra 'red' ou 'blue' está no dicionário
look({"green": "verde"})  # As palavras não estão no dicionário
look("yellow")  # A entrada não é um dicionário

Aqui, o padrão {"red": _} | {"blue": _} verifica se a chave 'red' ou 'blue' está presente no dicionário.

Capturando valores associados às chaves

Podemos capturar os valores associados às chaves em variáveis:

def look(colors):
    match colors:
        case {"red": red_value, "blue": blue_value}:
            print(f"Red é {red_value} e Blue é {blue_value}")
        case dict():
            print("As palavras não estão no dicionário")
        case _:
            print("A entrada não é um dicionário")

look({"red": "vermelho", "blue": "azul", "green": "verde"}) # Red é vermelho e Blue é azul
look({"red": "vermelho"}) # As palavras não estão no dicionário

Aqui, os valores associados às chaves 'red' e 'blue' são capturados em variáveis red_value e blue_value, respectivamente.

Obtendo os demais elementos do dicionário

Podemos usar ** para capturar os demais elementos do dicionário:

def look(colors):
    match colors:
        case {"red": red_value, **rest}:
            print(f"Red: {red_value}")
            for key, value in rest.items():
                print(f"{key}: {value}")
        case dict():
            print("As palavras não estão no dicionário")
        case _:
            print("A entrada não é um dicionário")


look({"red": "vermelho", "blue": "azul", "green": "verde"})
# Saída:
# Red: vermelho
# blue: azul
# green: verde

look({"blue": "azul", "green": "verde"})
# Saída:
# As palavras não estão no dicionário

Aqui, o padrão {"red": red_value, **rest} captura o valor associado à chave 'red' em red_value e os demais elementos do dicionário em rest.

Documentação oficial:

Match