Python match e case

Quando o programa precisa comparar um mesmo valor com uma lista de opções ("o cliente digitou 1, 2 ou 3?", "a resposta foi sim ou não?", "o comando foi listar, adicionar ou remover?"), uma escada elif resolve, mas repete opcao == em todo degrau. O Python tem um comando feito para isso: o match (em inglês, "combinar", "casar") com os seus case ("caso"). E ele vai além de comparar valores: consegue reconhecer o formato de um comando e separar as partes dele.

Todos os programas desta aula rodaram no Python 3.14 do computador fictício da Ana (usuária ana, computador notebook), na pasta pessoal dela, com python3 arquivo.py.

A ideia: o atendente da padaria

No balcão da padaria, a Ana recebe o pedido e compara com o cardápio: "é o número 1? Pão francês. É o 2? Pão de queijo. É o 3? Café. Qualquer outra coisa? 'Não temos essa opção'". Ela olha uma coisa (o número pedido) e procura o primeiro caso que combina.

O match é esse atendente: você diz qual valor olhar (match opcao:) e lista os casos (case "1":, case "2":…). O Python testa os casos de cima para baixo e roda o bloco do primeiro que combinar.

1. O primeiro match: o cardápio

print("1 - Pão francês   2 - Pão de queijo   3 - Café")
opcao = input("Escolha: ")
match opcao:
    case "1":
        print("Pão francês: R$ 0.80")
    case "2":
        print("Pão de queijo: R$ 4.50")
    case "3":
        print("Café: R$ 3.00")
    case _:
        print("Opção inválida.")
print("Obrigado!")

$ python3 menu.py
1 - Pão francês   2 - Pão de queijo   3 - Café
Escolha: 2
Pão de queijo: R$ 4.50             « combinou com o case "2"
Obrigado!
$ python3 menu.py
1 - Pão francês   2 - Pão de queijo   3 - Café
Escolha: 9
Opção inválida.                    « nenhum caso combinou: caiu no case _
Obrigado!

match opcao:

"Compare opcao com os casos abaixo". O valor depois do match se chama sujeito. A linha termina com dois-pontos.

case "1":

Um caso, recuado 4 espaços. O "1" é o padrão: aqui, um valor fixo. O caso combina quando opcao é igual a "1". Entre aspas porque o input() devolve texto.

o bloco do caso

Recuado mais 4 espaços (8 no total). Roda só se o caso combinar.

case _:

O sublinhado _ é o coringa: combina com qualquer coisa. É o "senão" do match, e por isso vem sempre por último.

print("Obrigado!")

De volta à margem: fora do match, roda sempre.

Para comparar, a mesma coisa com if/elif (que no lab deu exatamente a mesma saída, com a escolha 2):

print("1 - Pão francês   2 - Pão de queijo   3 - Café")
opcao = input("Escolha: ")
if opcao == "1":
    print("Pão francês: R$ 0.80")
elif opcao == "2":
    print("Pão de queijo: R$ 4.50")
elif opcao == "3":
    print("Café: R$ 3.00")
else:
    print("Opção inválida.")
print("Obrigado!")

Para comparar valores simples, os dois servem. O match deixa claro, logo na primeira linha, que todos os casos olham para o mesmo valor. A força dele aparece nas seções 4 e 5.

print("1 - Pão francês   2 - Pão de queijo   3 - Café")
opcao = input("Escolha: ")
match opcao:
    case "1":
        print("Pão francês: R$ 0.80")
    case "2":
        print("Pão de queijo: R$ 4.50")
    case _:
        print("Opção inválida.")

print("1 - Pão francês   2 - Pão de queijo   3 - Café")
opcao = input("Escolha: ")
match opcao:
    case "1":
        print("Pão francês: R$ 0.80")
    case "2":
        print("Pão de queijo: R$ 4.50")
    case "3":
        print("Café: R$ 3.00")
    case _:
        print("Opção inválida.")

2. Várias opções num caso: |

Quem responde "sim" pode escrever s, sim, S ou Sim. Em vez de um caso para cada, separe as opções com | (a barra vertical, que aqui quer dizer "ou"):

resposta = input("Confirma o pedido? ")
match resposta:
    case "s" | "sim" | "S" | "Sim":
        print("Pedido confirmado!")
    case "n" | "não" | "nao" | "N":
        print("Pedido cancelado.")
    case _:
        print("Não entendi. Responda sim ou não.")

$ python3 confirma.py
Confirma o pedido? Sim
Pedido confirmado!
$ python3 confirma.py
Confirma o pedido? nao
Pedido cancelado.
$ python3 confirma.py
Confirma o pedido? talvez
Não entendi. Responda sim ou não.

O caso combina se o valor for igual a qualquer uma das opções. A barra fica no teclado brasileiro (ABNT2) na tecla à esquerda do Z, com Shift.

Sem case _: pode não rodar nada

Como o else da escada elif, o case _ é opcional. Sem ele, se nenhum caso combinar, o match não faz nada:

dia = input("Dia da semana: ")
match dia:
    case "sábado" | "domingo":
        print("Fim de semana: a padaria abre às 7h.")
    case "segunda" | "terça" | "quarta" | "quinta" | "sexta":
        print("Dia útil: a padaria abre às 6h.")

$ python3 dia.py
Dia da semana: domingo
Fim de semana: a padaria abre às 7h.
$ python3 dia.py
Dia da semana: feriado             « nenhum caso combinou: nenhuma mensagem

resposta = input("Confirma o pedido? ")
match resposta:
    case "sim":
        print("Pedido confirmado!")
    case _:
        print("Não entendi.")

resposta = input("Confirma o pedido? ")
match resposta:
    case "s" | "sim" | "S" | "Sim":
        print("Pedido confirmado!")
    case _:
        print("Não entendi.")

3. Capturar o valor numa variável

No lugar de um valor fixo, um caso pode ter um nome sem aspas. Esse caso combina com qualquer coisa (como o _), e ainda guarda o valor numa variável com esse nome, para você usar no bloco:

cor = input("Cor do semáforo: ")
match cor:
    case "verde":
        print("Pode seguir.")
    case "vermelho":
        print("Pare!")
    case outra:
        print(f"Não conheço a cor {outra}.")

$ python3 captura.py
Cor do semáforo: azul
Não conheço a cor azul.            « o case outra guardou "azul" em outra

Aqui não faria diferença usar cor no bloco, porque é o mesmo valor. A captura fica útil de verdade quando ela pega só um pedaço do valor, como você vai ver na próxima seção.

4. Padrões de sequência: entender comandos

A Ana quer um programinha de lista de compras que entenda comandos como listar, adicionar manteiga e remover leite. O primeiro passo é separar as palavras com o método split() ("dividir"), da aula Métodos de Texto, que devolve uma lista de palavras (as listas têm aula própria no Nível 2: Listas):

>>> "adicionar manteiga".split()
['adicionar', 'manteiga']
>>> "listar".split()
['listar']
>>> "".split()
[]
>>> "adicionar ovos queijo presunto".split()
['adicionar', 'ovos', 'queijo', 'presunto']

Agora o match pode olhar o formato da lista: quantas palavras ela tem e qual é a primeira.

comando = input("Comando: ")
match comando.split():
    case ["listar"]:
        print("Lista: pão, leite, café")
    case ["adicionar", item]:
        print(f"{item} foi para a lista.")
    case ["adicionar", *itens]:
        print(len(itens), "itens foram para a lista:", itens)
    case ["remover", item]:
        print(f"{item} saiu da lista.")
    case []:
        print("Você não digitou nada.")
    case _:
        print("Comando desconhecido.")

$ python3 comandos.py
Comando: listar
Lista: pão, leite, café
$ python3 comandos.py
Comando: adicionar manteiga
manteiga foi para a lista.
$ python3 comandos.py
Comando: adicionar ovos queijo presunto
3 itens foram para a lista: ['ovos', 'queijo', 'presunto']
$ python3 comandos.py
Comando: remover leite
leite saiu da lista.
$ python3 comandos.py
Comando:                           « a Ana só apertou Enter
Você não digitou nada.
$ python3 comandos.py
Comando: comprar pão
Comando desconhecido.

match comando.split():

O sujeito é a lista de palavras, e não o texto.

case ["listar"]:

Combina com uma lista de exatamente uma palavra, que tem de ser "listar".

case ["adicionar", item]:

Lista de exatamente duas palavras: a primeira tem de ser "adicionar"; a segunda pode ser qualquer uma e é capturada na variável item.

case ["adicionar", *itens]:

O * quer dizer "o resto, quantas forem". Combina com "adicionar" seguido de qualquer número de palavras, que vão todas para itens, uma lista. Com uma palavra só, o caso de cima já tinha combinado antes: a ordem dos casos importa, como no elif.

case []:

A lista vazia: a pessoa não digitou nenhuma palavra.

case _:

Todo o resto, como comprar pão (a primeira palavra não bate com nenhum caso).

Com if/elif, cada caso precisaria conferir o tamanho da lista, a primeira palavra e depois separar a segunda. O match faz as três coisas num padrão só.

comando = input("Comando: ")
match comando.split():
    case ["listar"]:
        print("Lista: pão, leite, café")
    case ["adicionar", item]:
        print(f"{item} foi para a lista.")
    case ["adicionar", *itens]:
        print(len(itens), "itens foram para a lista:", itens)
    case ["remover", item]:
        print(f"{item} saiu da lista.")
    case []:
        print("Você não digitou nada.")
    case _:
        print("Comando desconhecido.")

5. Padrões de dicionário

Um dicionário guarda valores com etiquetas (as chaves): {"tipo": "pizza", "sabor": "calabresa"}. Ele tem aula própria no Nível 2 (Dicionários); aqui basta saber que é assim que muitos programas recebem pedidos, cadastros e dados da internet. O match reconhece um dicionário pelas chaves e valores que ele tem:

pedido = {"tipo": "pizza", "sabor": "calabresa", "tamanho": "G"}
match pedido:
    case {"tipo": "pizza", "sabor": sabor}:
        print(f"Uma pizza de {sabor} saindo!")
    case {"tipo": "suco", "fruta": fruta}:
        print(f"Um suco de {fruta}.")
    case _:
        print("Pedido estranho.")
pedido = {"tipo": "suco", "fruta": "caju"}
match pedido:
    case {"tipo": "pizza", "sabor": sabor}:
        print(f"Uma pizza de {sabor} saindo!")
    case {"tipo": "suco", "fruta": fruta}:
        print(f"Um suco de {fruta}.")
    case _:
        print("Pedido estranho.")

$ python3 pedido.py
Uma pizza de calabresa saindo!
Um suco de caju.

{"tipo": "pizza", …}

O dicionário precisa ter a chave "tipo" com o valor "pizza".

"sabor": sabor

…e também a chave "sabor", com qualquer valor, que é capturado na variável sabor.

a chave "tamanho"

Não aparece no padrão, e mesmo assim o primeiro pedido combinou: no padrão de dicionário, chaves a mais não atrapalham. Só as chaves escritas no padrão são conferidas. (Na sequência é diferente: o tamanho da lista tem de bater.)

6. Uma condição a mais: o guarda if

Depois do padrão, você pode acrescentar if condição. O caso só combina se o padrão combinar e a condição for verdadeira. Esse if se chama guarda (em inglês, guard):

temperatura = int(input("Temperatura: "))
match temperatura:
    case t if t < 0:
        print("Abaixo de zero: está congelando!")
    case 0:
        print("Exatamente zero grau.")
    case t if t >= 30:
        print("Calor! Beba água.")
    case _:
        print("Temperatura agradável.")

$ python3 guarda.py
Temperatura: -5
Abaixo de zero: está congelando!
$ python3 guarda.py
Temperatura: 0
Exatamente zero grau.
$ python3 guarda.py
Temperatura: 33
Calor! Beba água.
$ python3 guarda.py
Temperatura: 22
Temperatura agradável.

case t if t < 0: se lê: "captura o valor em t, se t for menor que zero". O case 0: é um valor fixo (um número, sem aspas, porque a temperatura foi convertida com int()). Um exemplo em que o guarda combina melhor com o match: o caixa eletrônico por comandos.

saldo = 200.0
comando = input("Comando: ")
match comando.split():
    case ["saldo"]:
        print(f"Saldo: R$ {saldo:.2f}")
    case ["sacar", valor] if float(valor) <= saldo:
        saldo = saldo - float(valor)
        print(f"Saque feito. Saldo: R$ {saldo:.2f}")
    case ["sacar", valor]:
        print(f"Saldo insuficiente para sacar R$ {float(valor):.2f}.")
    case _:
        print("Comando desconhecido.")

$ python3 saque.py
Comando: saldo
Saldo: R$ 200.00
$ python3 saque.py
Comando: sacar 50
Saque feito. Saldo: R$ 150.00
$ python3 saque.py
Comando: sacar 500
Saldo insuficiente para sacar R$ 500.00.   « o guarda deu False: caiu no caso de baixo

Os dois casos ["sacar", valor] têm o mesmo padrão. O primeiro só vale quando o guarda é verdadeiro; quando não é, o Python continua procurando e encontra o segundo.

Formas diferentes: match × if/elif

Quando dá errado

resposta = "não"
match resposta:
    case sim:
        print("Confirmado!")
    case _:
        print("Cancelado.")

$ python3 sem_aspas.py
  File "/home/ana/sem_aspas.py", line 3
    case sim:
         ^^^
SyntaxError: name capture 'sim' makes remaining patterns unreachable

VERDE = "verde"
cor = "vermelho"
match cor:
    case VERDE:
        print("Pode seguir.")
    case "vermelho":
        print("Pare!")

$ python3 captura_errada.py
  File "/home/ana/captura_errada.py", line 4
    case VERDE:
         ^^^^^
SyntaxError: name capture 'VERDE' makes remaining patterns unreachable

VERDE = "verde"
cor = "vermelho"
match cor:
    case VERDE:
        print("Pode seguir.")
print("cor agora vale:", cor, "/ VERDE agora vale:", VERDE)

$ python3 captura_errada2.py
Pode seguir.                                            « com o sinal vermelho!
cor agora vale: vermelho / VERDE agora vale: vermelho   « e a "constante" foi trocada

opcao = "1"
match opcao:
    case _:
        print("Opção inválida.")
    case "1":
        print("Pão francês")

$ python3 coringa_antes.py
  File "/home/ana/coringa_antes.py", line 3
    case _:
         ^
SyntaxError: wildcard makes remaining patterns unreachable

resposta = "s"
match resposta:
    case "s" or "sim":
        print("Confirmado!")

$ python3 com_or.py
  File "/home/ana/com_or.py", line 3
    case "s" or "sim":
             ^^
SyntaxError: invalid syntax

opcao = int(input("Escolha: "))
match opcao:
    case "1":
        print("Pão francês")
    case _:
        print("Opção inválida.")

$ python3 numero_texto.py
Escolha: 1
Opção inválida.                    « o número 1 não é igual ao texto "1"

opcao = "1"
match opcao
    case "1":
        print("Pão francês")

opcao = "1"
match opcao:
case "1":
    print("Pão francês")

opcao = "1"
case "1":
    print("Pão francês")

$ python3 sem_dois_pontos.py
  File "/home/ana/sem_dois_pontos.py", line 2
    match opcao
               ^
SyntaxError: expected ':'
$ python3 case_sem_recuo.py
  File "/home/ana/case_sem_recuo.py", line 3
    case "1":
    ^^^^
IndentationError: expected an indented block after 'match' statement on line 2
$ python3 case_sozinho.py
  File "/home/ana/case_sozinho.py", line 2
    case "1":
         ^^^
SyntaxError: invalid syntax

Referência rápida

Exercícios

fruta = "caju"
match fruta:
    case "maçã" | "pera":
        print("Fruta de clima frio")
    case "caju" | "manga":
        print("Fruta tropical")
    case _:
        print("Não sei")

Missão final: depósito no caixa

saldo = 200.0
comando = input("Comando: ")
match comando.split():
    case ["saldo"]:
        print(f"Saldo: R$ {saldo:.2f}")
    case ["sacar", valor] if float(valor) <= saldo:
        saldo = saldo - float(valor)
        print(f"Saque feito. Saldo: R$ {saldo:.2f}")
    case ["sacar", valor]:
        print("Saldo insuficiente.")
    case _:
        print("Comando desconhecido.")

saldo = 200.0
comando = input("Comando: ")
match comando.split():
    case ["saldo"]:
        print(f"Saldo: R$ {saldo:.2f}")
    case ["sacar", valor] if float(valor) <= saldo:
        saldo = saldo - float(valor)
        print(f"Saque feito. Saldo: R$ {saldo:.2f}")
    case ["sacar", valor]:
        print("Saldo insuficiente.")
    case ["depositar", valor]:
        saldo = saldo + float(valor)
        print(f"Depósito feito. Saldo: R$ {saldo:.2f}")
    case _:
        print("Comando desconhecido.")

Para ir além: acrescente um guarda para recusar depósitos de valor zero ou negativo (case ["depositar", valor] if float(valor) > 0:) e um caso logo abaixo dele com a mensagem de valor inválido.

Resumo

• match valor: compara um valor (o sujeito) com vários case, de cima para baixo, e roda só o bloco do primeiro que combinar. Não existe break, nem "escorregar" para o caso seguinte.
• Só existe a partir do Python 3.10; num Python mais antigo, é SyntaxError.
• case "x": compara com um valor fixo; case "a" | "b": aceita várias opções; case _: é o "senão", sempre por último.
• Um nome sem aspas no case captura o valor (e combina com tudo): textos fixos vão sempre entre aspas.
• Padrões de sequência (["adicionar", item], *itens, []) conferem o formato de uma lista e separam as partes; padrões de dicionário conferem chaves e valores (chaves a mais não atrapalham).
• case padrão if condição: acrescenta um guarda: o caso só vale se a condição também for verdadeira.
• Para faixas de valores ou condições sobre coisas diferentes, o if/elif continua sendo a escolha.