Python Academy · Aula

Noções básicas de match e case

Crie ramificações com base em padrões de valores

Noções básicas de match e case é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Correspondência estrutural de padrões

O Python 3.10 introduziu a correspondência estrutural de padrões com a instrução match. Ela compara um valor com uma série de padrões e executa o primeiro que corresponder, sendo muito mais poderosa do que condicionais if/elif encadeadas.

Sintaxe básica

Escreva match seguido do assunto e, depois, um ou mais blocos case. O primeiro caso correspondente é executado.

command = 'start'

match command:
    case 'start':
        print('Starting up')
    case 'stop':
        print('Shutting down')

# prints: Starting up

Correspondência com literais

Os padrões mais simples são valores literais: números, strings, True, False e None. Eles correspondem quando o assunto é igual ao literal.

code = 404

match code:
    case 200:
        print('OK')
    case 404:
        print('Not Found')
    case 500:
        print('Server Error')

O curinga _

O sublinhado _ é um padrão curinga que corresponde a qualquer coisa. Coloque-o por último como um padrão abrangente padrão, como else.

code = 418

match code:
    case 200:
        print('OK')
    case _:
        print('Unknown status')

Combinação com OR

Use o operador | dentro de um caso para corresponder a qualquer um de vários padrões.

code = 301

match code:
    case 200 | 201 | 204:
        print('Success')
    case 301 | 302:
        print('Redirect')
    case _:
        print('Other')

Capturando o valor

Um nome isolado em um padrão captura o assunto nessa variável. Use-o quando você tiver feito uma correspondência abrangente, mas ainda quiser o valor.

value = 42

match value:
    case 0:
        print('zero')
    case other:
        print('got', other)

A ordem importa

Os casos são testados de cima para baixo, e a primeira correspondência vence. Um padrão de captura abrangente colocado cedo demais ocultará casos posteriores e mais específicos.

x = 5

match x:
    case n:           # matches everything first!
        print('caught by capture')
    case 5:
        print('this never runs')

A correspondência não retorna nada

match é uma instrução, não uma expressão, portanto não retorna um valor. Defina uma variável dentro dos casos se precisar de um resultado.

day = 6
label = ''

match day:
    case 0 | 6:
        label = 'weekend'
    case _:
        label = 'weekday'

print(label)

Correspondência com None

Você pode corresponder diretamente a None. Isso é mais claro do que uma verificação explícita com is None dentro de uma cadeia.

def describe(value):
    match value:
        case None:
            return 'nothing'
        case _:
            return 'something: ' + str(value)

print(describe(None))
print(describe(7))

Um distribuidor prático

A correspondência de padrões é especialmente útil como distribuidor de comandos, transformando uma longa cadeia de condicionais em uma tabela clara de casos.

def handle(cmd):
    match cmd:
        case 'help':
            return 'Showing help'
        case 'quit' | 'exit':
            return 'Goodbye'
        case _:
            return 'Unknown command'

print(handle('exit'))
print(handle('foo'))

Correspondência com True, False e None

As constantes True, False e None são comparadas por identidade, não por igualdade. Isso faz delas instâncias únicas confiáveis para ramificar a lógica.

def report(flag):
    match flag:
        case True:
            return 'enabled'
        case False:
            return 'disabled'
        case None:
            return 'unset'

print(report(True))
print(report(None))

Verificação rápida

O que o padrão curinga _ faz em uma instrução de correspondência?

Recapitulação

Você aprendeu a ramificar com base em padrões de valores.

match testa os casos de cima para baixo; a primeira correspondência vence.
Faça correspondência com literais, use _ como padrão abrangente e combine padrões com |.
Um nome isolado captura o valor.
match é uma instrução, não uma expressão.

Perguntas Frequentes

A aula “Noções básicas de match e case” é grátis?

Sim — o texto completo de “Noções básicas de match e case” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Noções básicas de match e case”?

Crie ramificações com base em padrões de valores Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Noções básicas de match e case”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Noções básicas de match e case
Correspondência de sequências e mapeamentos
Padrões de classes
Guardas e curingas

← Voltar para Python Academy