Condições e lógica booleana em Python

Uma comparação faz uma pergunta sobre valores. Seu resultado é um valor booleano: True ou False. Esses são valores do tipo bool, escritos com a primeira letra maiúscula e sem aspas. "True" é texto; true em minúsculas é um nome e gera NameError quando não foi definido.

Escolha o operador que corresponde à regra

Os operadores de dois caracteres permanecem juntos, com = por último. Escreva <=, não =<. Um número inteiro e um de ponto flutuante podem ser iguais em uma comparação: 7 == 7.0 produz True porque seus valores numéricos coincidem.

Uma comparação é uma expressão, então você pode imprimir ou armazenar seu resultado:

x = 7
is_big = x > 5
print(is_big)

O Python avalia x > 5, obtém True e atribui esse valor a is_big. A saída é True. Um nome como is_big ou has_ticket faz uma variável booleana ser lida como uma pergunta de sim ou não.

Distinga atribuição de comparação

x = 5 armazena um novo valor em x. x == 5 verifica o valor atual sem alterá-lo. Escrever if x = 5: é um erro de sintaxe. O erro inverso pode ser mais difícil de perceber:

x = 7
x == 5
print(x)

Em um script, o resultado da comparação não é usado. A saída continua sendo 7; a linha do meio nunca atribui 5.

Calcule as operações aritméticas antes de comparar

Em 2 + 3 > 4, o Python primeiro soma e obtém 5, depois compara 5 > 4. O resultado é True. Um teste útil para números inteiros é n % 2 == 0: % produz o resto da divisão, e números pares deixam resto 0 quando divididos por 2.

Para n = 10, os passos são 10 % 2 e depois 0 == 0, produzindo True. Para n = -7, -7 % 2 é 1, então o teste de paridade é False. Com o divisor positivo 2, o resto do Python para um inteiro ímpar é 1, inclusive para um inteiro ímpar negativo.

Decida se o limite está incluído

“Pelo menos 18” inclui 18: age >= 18. “Mais de 18” o exclui: age > 18. Da mesma forma, “menos de 13” é age < 13, e “no máximo 3” é bags <= 3. Teste o próprio limite ao escolher um operador. Em age = 18, o primeiro teste de idade é verdadeiro e o segundo é falso.

Considere pequenas diferenças entre números de ponto flutuante

Muitas frações decimais têm apenas representações binárias aproximadas. O Python armazena 0.1 + 0.2 como 0.30000000000000004, então 0.1 + 0.2 == 0.3 é False.

Para uma comparação com tolerância absoluta de 1e-9, use:

print(abs((0.1 + 0.2) - 0.3) < 1e-9)

abs() fornece a magnitude da diferença sem seu sinal. Essa diferença é menor que um bilionésimo, então esse teste imprime True. A tolerância estabelece quanta diferença essa verificação aceita; ela não é uma igualdade exata.

Os valores nos dois lados de uma comparação importam tanto quanto o operador. Um texto pode parecer um número e ainda assim seguir as regras das strings.

Compare textos exatamente

A igualdade de strings verifica cada caractere, incluindo maiúsculas, minúsculas e espaços. "yes" == "Yes" é False, e "yes" == "yes " também é False. Para aceitar diferenças comuns de capitalização e espaços nas extremidades, compare uma cópia normalizada:

answer = " Yes "
print(answer.strip().lower() == "yes")

strip() remove caracteres em branco das duas extremidades. lower() transforma letras em minúsculas. O texto normalizado é "yes", então o resultado é True. O valor armazenado em answer permanece inalterado, a menos que você atribua a ele o valor normalizado.

Entenda a ordem das strings

O Python compara strings da esquerda para a direita usando pontos de código Unicode, os números atribuídos aos caracteres. Ele para no primeiro par diferente. Com letras inglesas sem acentos e com a mesma capitalização, isso segue a ordem alfabética: "apple" < "banana" é True. Quando uma string é o início da outra, a mais curta vem primeiro: "cat" < "catalog" é True.

Essa não é uma regra completa de ordenação de dicionário. A a Z têm pontos de código de 65 a 90, e a a z têm de 97 a 122. Assim, "Zebra" < "apple" é True. O é acentuado também vem depois de z, então "zebra" < "éclair" é True.

Dígitos em strings seguem a mesma regra de caracteres. "10" < "9" é True: a primeira comparação é entre "1" e "9", não entre os números dez e nove.

Converta a entrada para decisões numéricas

input() retorna uma string. Se alguém digitar 5, "5" == 5 produz False; a igualdade não converte o texto. A comparação de ordem é diferente: "5" < 10 gera TypeError porque o Python não consegue ordenar essa string e esse inteiro juntos.

age = int(input("Age: "))
print(age >= 18)

Para o texto digitado "18", int() produz o inteiro 18, e o teste imprime True. Use float() quando a entrada representar um valor decimal.

Use uma cadeia para um intervalo

0 <= score <= 100 exige que ambas as comparações entre valores vizinhos sejam verdadeiras. Isso significa 0 <= score and score <= 100. Para score = 105, o teste do limite inferior passa, mas o do limite superior falha, então toda a cadeia é False.

Uma cadeia compara apenas valores vizinhos. 1 < 3 > 2 é True porque 1 < 3 e 3 > 2 são ambos verdadeiros; ela não compara 1 diretamente com 2.

Use pertencimento ou identidade quando necessário

Os operadores de pertencimento testam se um texto ocorre dentro de outro. "nan" in "banana" é True; "Ban" in "banana" é False. "x" not in "banana" é True.

None representa a ausência de valor. Verifique-o com result is None ou result is not None. O operador is pergunta se é exatamente o mesmo objeto, enquanto == pergunta se os valores são iguais. Use == para igualdade de números e strings: um teste de identidade como x is 5 não é confiável para essa finalidade e produz um SyntaxWarning.

Uma instrução if executa um bloco somente quando sua condição é verdadeira. O cabeçalho começa com if, apresenta a condição e termina com dois-pontos. As linhas abaixo são indentadas para mostrar que pertencem ao corpo.

Acompanhe uma decisão de uma alternativa

temperature = 31
if temperature > 30:
    print("Hot day")
    print("Drink water")
print("Done")

No cabeçalho, o Python lê o valor atual de temperature. A comparação 31 > 30 é True, então ambas as linhas indentadas são executadas. O programa chega à linha fora do bloco. Sua saída é:

Hot day
Drink water
Done

Altere a primeira linha para temperature = 25. Agora 25 > 30 é False, então o Python ignora todo o corpo. Apenas Done é impresso. A condição é testada uma vez quando o Python chega ao cabeçalho; um if não continua a verificá-la.

Use a indentação para mostrar quais linhas pertencem ao bloco

Por convenção, use 4 espaços para cada nível de indentação. Linhas no mesmo nível pertencem ao mesmo bloco. Retornar ao nível externo encerra o bloco. Se você indentar print("Done") em 4 espaços, ela passa para o corpo do if e só é executada quando a condição é verdadeira.

Um fluxograma mostra a mesma escolha com um losango. O caminho verdadeiro entra no corpo, o caminho falso o contorna, e os caminhos se encontram na próxima instrução fora do bloco.

O Python pode informar SyntaxError, IndentationError ou TabError para esses problemas. Comece pelo cabeçalho e pela indentação ao redor da linha indicada. Parênteses em torno da condição são opcionais; if temperature > 30: é a forma usual.

Um corpo não pode estar vazio. Para reservar um lugar para uma ação, escreva um pass indentado. É uma instrução válida que não faz nada:

if temperature > 30:
    pass

Verificações separadas são independentes

score = 95
if score >= 50:
    print("Pass")
if score >= 90:
    print("Excellent")

O Python chega aos dois cabeçalhos. Ambas as condições são verdadeiras, então ele imprime as duas mensagens. Instruções if separadas são adequadas para regras cujas ações podem se aplicar à mesma entrada.

Forneça um valor que o código posterior possa usar

Um nome ao qual se atribui um valor apenas no corpo pode nunca ser criado:

x = 0
if x > 0:
    message = "positive"
print(message)

Em um script recém-iniciado, o corpo é ignorado e message não tem valor, então a última linha gera NameError. Uma correção fornece um valor inicial antes da escolha:

x = 0
message = "not positive"
if x > 0:
    message = "positive"
print(message)

Agora a linha posterior tem um valor nos dois caminhos. Para zero, ela imprime not positive; para um x positivo, o corpo substitui esse texto por positive.

Uma instrução if–else escolhe um de dois blocos. Quando a condição é verdadeira, o Python executa o corpo do if. Caso contrário, executa o corpo do else. Exatamente um é executado quando a execução chega a essa decisão.

Alinhe as alternativas

number = int(input("Enter a whole number: "))
if number % 2 == 0:
    print(number, "is even")
else:
    print(number, "is odd")

Para a entrada 14, o resto é 0, então a saída é 14 is even. Para a entrada -7, o resto é 1, então a saída é -7 is odd. O else pertence ao if no mesmo nível de indentação. Seu corpo tem indentação própria.

Não há condição depois de else: ele significa que a condição anterior foi falsa. else number < 0: é um erro de sintaxe. Mantenha a cláusula diretamente após o corpo do if; uma instrução sem indentação e sem relação com ele entre os dois quebra a estrutura.

Verifique o que “todo o restante” inclui

Com if answer == "yes":, um else não significa apenas "no". Ele também aceita "maybe", "Yes" e "", pois nenhum deles é igual a "yes". Isso é útil quando todas as entradas restantes merecem a mesma ação. Se várias entradas rejeitadas precisarem de respostas diferentes, serão necessários outros testes.

Atribua valores nos dois caminhos

Uma regra de frete oferece frete grátis para totais de pelo menos 50 reais e cobra 5,99 reais nos demais casos:

total = 42.50
if total >= 50:
    shipping = 0
else:
    shipping = 5.99
print(total + shipping)

Primeiro, 42.50 >= 50 produz False. O Python ignora a atribuição de 0, executa o else e armazena 5.99. A última linha está fora dos dois corpos e imprime 48.49. Altere total para 60: o primeiro corpo armazena 0, o outro é ignorado e a última linha imprime 60. Ambos os caminhos definem shipping antes de seu uso.

Escolha um valor com uma expressão condicional

Quando a única diferença é o valor a atribuir, uma expressão condicional pode expressar isso em uma linha:

shipping = 0 if total >= 50 else 5.99

Sua forma é value_if_true if condition else value_if_false. Embora o valor verdadeiro apareça primeiro na página, o Python avalia primeiro a condição. Ele avalia apenas o valor escolhido e depois atribui o resultado a shipping.

Outro exemplo é label = "even" if n % 2 == 0 else "odd". Para n = 14, ele seleciona "even". Para n = -7, seleciona "odd".

A expressão exige ambos os valores. x = 1 if flag está incompleta e gera SyntaxError porque não há valor para else. Uma instrução if completa pode omitir else porque pode simplesmente não executar nenhuma ação no caminho falso; uma expressão ainda precisa produzir um valor.

Use elif, abreviação de “else if”, para adicionar outro teste a uma decisão. O Python testa as condições de cima para baixo. A primeira condição verdadeira prevalece, e o restante da cadeia é ignorado.

Rastreie uma decisão de notas

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"
print(grade)

O primeiro teste, 85 >= 90, é falso. O segundo, 85 >= 80, é verdadeiro, então o Python armazena "B". Ele não testa as condições restantes nem entra em else. A saída é B.

Use o que as falhas anteriores informam

Chegar a elif score >= 80: já informa que a pontuação é inferior a 90. Para pontuações inteiras, esse ramo abrange de 80 a 89. Adicionar and score < 90 repetiria uma verificação que o programa já resolveu.

A ordem importa porque esses intervalos se sobrepõem. Se score >= 60 vier primeiro, ele abrange 85 e 95 antes que os testes para notas mais altas sejam alcançados. Para testes de limite inferior com >=, coloque o maior valor limiar primeiro. Para testes de limite superior com <, comece pelo menor valor limiar.

Mantenha uma escolha em uma cadeia

Substituir as palavras reservadas elif por if altera o comportamento. Com uma pontuação de 85, o teste para 80 atribui "B", o teste para 70 atribui "C" e o teste para 60 atribui "D". O valor final é "D". Cada novo if inicia uma decisão independente.

Essa distinção também afeta else. Em um grupo de instruções if separadas, um else final pertence apenas ao seu if correspondente, não ao grupo inteiro. Mantenha os ramos ligados quando representarem uma única classificação.

Considere os limites e as entradas sem correspondência

Uma cadeia elif pode ter qualquer número de testes adicionais, e seu else final é opcional. Sem um ramo para os demais casos, ela pode não executar nenhum corpo:

temp = 20
if temp < 18:
    print("Cool")
elif temp > 24:
    print("Warm")

Nenhuma das condições é verdadeira. Adicione else: com um print("Comfortable") indentado se toda temperatura precisar de uma mensagem. Da mesma forma, t < 18 seguido de t > 18 deixa exatamente 18 sem correspondência. Nos valores limiares das notas, escrever score > 90 enviaria 90 ao ramo "B".

Menus de texto usam a mesma estrutura: teste choice == "1", depois choice == "2" e dê a qualquer outra entrada uma resposta "Unknown option". Essas verificações comparam strings porque input() retorna texto. Quando muitos testes comparam um valor com opções fixas, match oferece outra maneira de organizar a decisão.

Os operadores booleanos and, or e not permitem que você construa uma condição a partir de condições mais simples. O Python os escreve como palavras em minúsculas.

Leia todas as possibilidades

Para entradas booleanas, and produz True somente quando ambas as entradas são verdadeiras. or produz True quando pelo menos uma é verdadeira, inclusive quando ambas são verdadeiras. Este é um ou inclusivo.

not inverte um valor lógico: not True produz False, e not False produz True. Uma tabela-verdade lista todas as combinações de entradas booleanas. Duas entradas precisam de quatro linhas; três precisam de oito. Cada entrada booleana independente adicional dobra as combinações.

Para A and not B, primeiro inverta B e depois combine-o com A. Na linha A = True, B = False, not B é True, então o resultado é True. As outras três linhas produzem False.

Traduza uma regra em testes completos

Um museu dá desconto na entrada para visitantes com menos de 12 anos ou com 65 anos ou mais:

has_discount = age < 12 or age >= 65

Na idade 10, a primeira comparação é verdadeira. Aos 65, a segunda é verdadeira. As idades 30 e 64 não passam em nenhuma das duas. Usar and exigiria que a mesma idade fosse menor que 12 e de pelo menos 65, o que não pode acontecer.

Um brinquedo exige uma altura de pelo menos 120 centímetros e ausência de problema cardíaco:

can_ride = height >= 120 and not has_heart_condition

As duas exigências devem ser atendidas juntas. Na altura mínima com has_heart_condition = False, ambas as partes são verdadeiras. Se qualquer uma das exigências falhar, can_ride é False.

Distinga dentro de fora de um intervalo

O teste para dentro exige ambos os limites. O teste para fora exige que pelo menos um deles não seja atendido. score < 0 and score > 100 nunca pode ser verdadeiro para um número.

Cada comparação precisa dos dois lados. score >= 0 and <= 100 é uma sintaxe incompleta. Um problema mais sutil é executado sem erro:

if answer == "y" or "yes":
    print("Accepted")

O Python vê (answer == "y") or "yes". Quando a comparação é falsa, a string não vazia "yes" ainda faz com que a condição seja considerada verdadeira. Repita a comparação: answer == "y" or answer == "yes".

A linguagem cotidiana exige o mesmo cuidado. “Fechado no sábado e no domingo” significa day == "Saturday" or day == "Sunday"; um dia não precisa ter os dois nomes ao mesmo tempo. Para uma variável booleana, negue-a diretamente com not is_member. Uma comparação negada como not (age >= 18) também pode ser escrita de forma mais simples como age < 18. Os operadores do Python aqui são palavras, não &&, || ou !.

Uma condição mais longa tem duas questões a resolver: como suas partes são agrupadas e quais partes o Python realmente avalia. A precedência de operadores responde à primeira. A avaliação de curto-circuito responde à segunda.

Leia primeiro o agrupamento

Para os operadores usados aqui, a precedência vai da maior para a menor:

1. Potenciação: **.
2. Multiplicação, divisão, divisão com arredondamento para baixo, resto: *, /, //, %.
3. Adição e subtração: +, -.
4. Comparações, incluindo in, not in, is e is not.
5. not, depois and, depois or.
6. A expressão condicional: a if condition else b.

Parênteses alteram o agrupamento. Por exemplo, x > 3 or x < 0 and x != 5 é agrupado como x > 3 or (x < 0 and x != 5). Em x = 5, a comparação à esquerda é verdadeira e todo o grupo à direita é ignorado. O resultado é True.

Com (x > 3 or x < 0) and x != 5, os parênteses fazem do primeiro grupo um operando de and. Em x = 5, esse grupo é verdadeiro, mas x != 5 é falso, então o resultado é False.

É por isso que is_weekend or is_holiday and is_sunny aceita todo fim de semana, mesmo com chuva. Para a regra “um dia de folga que também esteja ensolarado”, escreva (is_weekend or is_holiday) and is_sunny.

Acompanhe a avaliação da esquerda para a direita

Para and, uma primeira parte falsa já descartou toda a exigência. Para or, uma primeira parte verdadeira já a satisfez. A precedência não obriga o Python a calcular um operando ignorado só porque ele contém operadores de precedência maior.

Você pode usar isso para colocar uma verificação de proteção antes de uma operação que falharia:

count = 0
total = 50
is_large_average = count != 0 and total / count > 10
print(is_large_average)

count != 0 é falso, então o Python nunca tenta 50 / 0. Ele armazena e imprime False. Inverter os operandos faz com que a divisão seja tentada primeiro e gera ZeroDivisionError; a verificação posterior não pode proteger o trabalho anterior.

Passe not por um teste agrupado

As leis de De Morgan reescrevem uma negação invertendo cada parte e trocando o operador que as une:

“Não é adolescente” pode ser testado como not (age >= 13 and age <= 19). O teste direto equivalente é age < 13 or age > 19. As idades 12 e 20 passam; 13, 16 e 19 não passam.

Manter and depois de negar ambas as partes altera a regra. Em A = True, B = False, not (A and B) é verdadeiro, mas not A and not B é falso. Compare cada linha da tabela-verdade ao verificar a equivalência de duas formas booleanas.

Para uma variável que já contém um booleano, escreva if is_valid: ou if not is_valid:. Compará-la com True ou False acrescenta um teste de que a condição não precisa.

Uma condicional aninhada coloca uma decisão dentro de um ramo de outra. A decisão interna só é alcançada quando a execução entra nesse ramo externo. Cada nível de aninhamento acrescenta 4 espaços de indentação.

Rastreie a escolha externa antes da interna

has_ticket = True
age = 15
if has_ticket:
    if age >= 13:
        print("Enjoy the movie")
    else:
        print("This movie needs an adult")
else:
    print("Please buy a ticket first")

Primeiro, has_ticket é verdadeiro, então o Python entra no corpo externo. Depois testa 15 >= 13, obtém verdadeiro e imprime Enjoy the movie. Os corpos dos else interno e externo são ambos ignorados.

Altere a idade para 10 mantendo o ingresso. O Python ainda entra no corpo externo, mas a condição interna falha, então ele imprime This movie needs an adult. Com has_ticket = False, o teste de idade nunca é alcançado; o else externo imprime Please buy a ticket first.

Associe cada else pela indentação

Um else pertence ao if no seu próprio nível de indentação. Movê-lo pode alterar o comportamento mesmo que o script continue válido. Considere esta variante menor:

if has_ticket:
    if age >= 13:
        print("Enter")
else:
    print("Buy a ticket")

O else pertence a if has_ticket:. Uma pessoa de 10 anos com ingresso não recebe mensagem. Mova esse else e seu corpo um nível para dentro, e ele passará a pertencer a if age >= 13:. Agora a mesma criança recebe Buy a ticket, enquanto alguém sem ingresso não recebe mensagem. A disposição alterada expressa uma regra diferente.

No exemplo completo do filme, o if interno já tem um else. Mover o else externo para dentro ali criaria duas alternativas para o mesmo if e causaria um erro de sintaxe.

Reduza o aninhamento de duas exigências

Quando há apenas uma ação e nenhum dos níveis tem else, and muitas vezes elimina um nível de aninhamento:

if is_member and total >= 50:
    print("Free shipping")

Isso executa a mesma ação que um if is_member: externo contendo um if total >= 50: interno. Ambas as exigências devem ser atendidas, e a segunda só é alcançada depois que a primeira é atendida. Mantenha o aninhamento quando os ramos externos precisarem de ações próprias e diferentes, como na compra de um ingresso.

Um else cuja única ação é outro if–else pode se tornar uma cadeia elif. Para positivo, negativo e zero, a forma sem aninhamento é if x > 0:, depois elif x < 0: e depois else:. Ela mantém os mesmos três resultados com menos indentação.

Valide antes de classificar

Uma decisão de notas precisa rejeitar pontuações fora do intervalo permitido antes de atribuir uma letra:

if 0 <= score <= 100:
    if score >= 90:
        print("A")
    else:
        print("Below A")
else:
    print("Score must be between 0 and 100")

Em score = 150, a verificação externa falha, então nenhuma nota é atribuída. O aninhamento também revela caminhos impossíveis: um if x < 5: interno sob if x > 10: nunca pode ser verdadeiro. Quando a indentação se tornar profunda, procure exigências combinadas, uma cadeia elif ou uma verificação de validação anterior que torne os caminhos restantes mais claros.

O Python pode testar um valor diretamente em uma condição. Seu valor lógico em contexto determina se o corpo será executado. Isso dispensa comparações, mas o valor lógico em contexto pode diferir do que seu texto parece dizer.

Reconheça valores considerados falsos

Para os tipos embutidos aqui, False, None, zero numérico, strings vazias e coleções vazias são considerados falsos. Números diferentes de zero e strings ou coleções não vazias são considerados verdadeiros.

bool() converte um valor em seu valor lógico booleano. Em uma condição, if value: escolhe o mesmo ramo que if bool(value):. Isso não transforma o valor armazenado em um booleano.

Teste uma entrada vazia sem interpretá-la incorretamente

name = input("Name: ")
if name:
    print("Hello", name)
else:
    print("No name entered")

Pressionar Enter sem digitar produz "", então o segundo corpo é executado. Um nome formado inteiramente por espaços não está vazio e passa no primeiro teste. if name.strip():, por sua vez, testa o texto após remover os caracteres em branco das extremidades, então uma resposta formada apenas por espaços também falha.

Uma resposta de sim ou não exige uma pergunta diferente. if answer: executa o bloco para "no" e "False" porque ambos contêm caracteres. Para reconhecer uma resposta afirmativa, compare o texto, por exemplo, answer == "yes". O valor lógico em contexto verifica se a string está vazia, não o significado de uma palavra.

Distinga um zero válido de dados ausentes

Suponha que quantity seja None antes de um valor ser fornecido e possa legitimamente ser 0. if quantity: rejeita ambos. Use quantity is not None para perguntar se há um valor; isso aceita zero.

Para uma variável realmente booleana, o teste direto é claro. Para outros valores, x == True faz algo diferente de if x:. Com x = 5, o teste do valor lógico em contexto passa, mas 5 == True é falso; a igualdade numérica considera True igual a 1, não a todo número diferente de zero.

and e or retornam um valor que examinam

Esses operadores retornam um operando, que pode não ser um booleano:

Para or, o Python retorna o valor à esquerda se ele for considerado verdadeiro; caso contrário, avalia e retorna o valor à direita. Para and, ele retorna o valor à esquerda se ele for considerado falso; caso contrário, avalia e retorna o valor à direita.

display_name = name or "Guest" fornece um valor padrão para entrada vazia. O mesmo padrão com quantity or 1 substitui um zero real por 1. Use um valor padrão dessa forma apenas quando todo valor considerado falso significar ausência. not comporta-se de outra maneira: ele sempre retorna True ou False. Se uma variável sinalizadora armazenada precisar ser booleana, has_name = bool(name or nickname) converte o texto selecionado em um valor lógico.

Um script pode ser executado sem erro de sintaxe e ainda assim escolher o ramo errado. O rastreamento acompanha uma execução manualmente. O teste executa entradas escolhidas e compara o resultado observado com o resultado exigido pela regra.

Planeje e rastreie um caminho

Antes de escrever código, apresente as escolhas em passos de linguagem comum, ou pseudocódigo. Um fluxograma coloca cada condição em um losango com setas para verdadeiro e falso. Ambos os caminhos precisam de um próximo passo ou fim claro.

Para rastrear o código, anote os valores iniciais, avalie cada condição alcançada, registre as atribuições e copie a saída exatamente. Para a cadeia de notas com score = 72:

“Não avaliado” é diferente de falso. O Python já selecionou um ramo, então não precisa das comparações posteriores.

Cubra cada ramo e cada limite

Uma cadeia com quatro ramos precisa de pelo menos quatro entradas para executar cada ramo uma vez. Escolha-as pelos caminhos pretendidos, não pela variedade aparente dos números. Várias pontuações altas podem exercitar o mesmo primeiro corpo.

A cobertura de ramos, por si só, pode deixar passar um limite incorreto. Para age >= 18, teste 17, 18 e 19. Um > incorreto passa nos dois testes externos como esperado, mas rejeita o valor exato do limite. Para um valor limiar de nota de 90, compare 89, 90 e 91; faça o mesmo nos outros valores limiares. Para entradas decimais, escolha valores próximos adequados à precisão da medida.

Encontre ramos que não podem ser executados

if score >= 60:
    print("Pass")
elif score >= 90:
    print("Excellent")

O segundo ramo é inalcançável. Qualquer pontuação de pelo menos 90 já passou no primeiro teste. Coloque o valor limiar mais restritivo primeiro ou altere os intervalos para corresponder à regra pretendida.

Uma lacuna deixa um caso pretendido sem tratamento: t < 0 seguido de t > 0 ignora zero. Uma sobreposição pode fazer várias ações independentes serem executadas: os testes separados t >= 0 e t <= 10 são ambos verdadeiros para 5. Uma cadeia permite apenas seu primeiro ramo verdadeiro, mas sua ordem ainda determina qual condição sobreposta prevalece.

Inclua entradas difíceis

Teste valores negativos, zero, texto vazio e respostas em maiúsculas quando o script espera minúsculas. Se apenas "y" e "n" forem aceitos, dê a qualquer outro texto uma resposta clara, como "Please answer y or n".

Quando um teste se comportar de maneira inesperada, inspecione o valor e seu tipo antes de avaliar a comparação suspeita:

print(repr(age), type(age))

Para age = "18", isso imprime '18' <class 'str'>. Converta o texto antes de tentar age >= 18; colocar a comparação incorreta nesse mesmo print() de depuração geraria TypeError antes de a saída de diagnóstico aparecer. Para problemas estruturais, inspecione a indentação e a mensagem de erro de sintaxe.

Por fim, uma comparação pode definir uma variável sinalizadora booleana diretamente: is_adult = age >= 18. Ela substitui dois ramos cujas únicas atribuições são True e False. Use bool() quando a expressão original puder retornar outro tipo de valor.

Uma instrução match, disponível no Python 3.10 e posteriores, compara um valor com uma série de padrões. Esse valor é o valor sujeito. Cada case fornece um padrão e um corpo indentado.

Acompanhe o primeiro caso correspondente

command = "stop"
match command:
    case "start":
        print("Starting")
    case "stop":
        print("Stopping")
    case _:
        print("Unknown command")
print("Ready")

O valor sujeito é "stop". Ele não corresponde a "start", então o Python tenta o próximo caso. "stop" corresponde, e o corpo imprime Stopping. O Python sai de toda a instrução match e imprime Ready. Apenas um corpo de caso é executado; a execução não passa para o próximo corpo e não é necessário break.

Um valor sujeito "jump" chega ao padrão curinga final, _, que aceita qualquer valor. A saída é Unknown command e depois Ready. Sem esse caso, um valor sujeito sem correspondência simplesmente não executa nenhum corpo de caso e continua após a instrução.

Mantenha a disposição e o caso para os demais em ordem

Os cabeçalhos case são indentados 4 espaços abaixo de match, e seus corpos, mais 4 espaços. Cada cabeçalho termina com dois-pontos. Um case _: sem condição de guarda deve ser o último, pois aceita tudo. Colocar mais casos depois dele gera SyntaxError: esses padrões posteriores nunca poderiam ser alcançados.

Um curinga com condição de guarda pode aparecer antes porque sua condição extra pode falhar. Uma instrução match em um script de execução sequencial também não pode conter break; essa instrução exige um laço ao seu redor.

Entenda como os literais correspondem

Um padrão literal usa um número fixo, uma string, True, False ou None. Padrões de string exigem correspondência exata e distinguem maiúsculas de minúsculas: "stop" não corresponde a "Stop". Padrões numéricos usam igualdade, então case 1: corresponde a 1, 1.0 e True, que é igual a 1.

Os padrões True, False e None usam identidade. Assim, case True: corresponde ao booleano True, mas não ao inteiro 1. A ordem dos padrões importa se um caso numérico e um caso booleano puderem aceitar o valor sujeito.

Una alternativas fixas com uma barra

Um padrão de alternativas une alternativas com |:

day = int(input("Day number: "))
match day:
    case 6 | 7:
        print("Weekend")
    case 1 | 2 | 3 | 4 | 5:
        print("Weekday")
    case _:
        print("Not a day number")

Para 6, o primeiro corpo é executado; para 3, o segundo é executado; para 9, o curinga é executado. Sem int(), o "6" digitado continua sendo uma string e não corresponde ao número 6.

Use o separador de padrões |, não a palavra booleana or. case "y" or "yes": é inválido; case "y" | "yes": é válido.

Para comandos fixos, uma cadeia if–elif baseada em igualdade pode produzir as mesmas saídas. Escolha a disposição que torne os casos mais fáceis de ler.

Padrões podem fazer mais do que verificar um literal fixo. Um padrão pode dar um nome ao valor sujeito, e uma condição de guarda pode verificar uma condição extra antes de o caso ser aceito.

Capture primeiro e depois verifique a condição de guarda

Um padrão de captura é um nome isolado como n. Ele aceita qualquer valor sujeito e o atribui ao nome. Uma condição de guarda vem após o padrão com if condition; o corpo só é executado se o padrão corresponder e a condição de guarda for verdadeira.

temperature = -5
match temperature:
    case 0:
        print("Exactly freezing")
    case t if t < 0:
        print("Below freezing by", -t, "degrees")
    case _:
        print("Above freezing")

Em -5, o primeiro literal não corresponde. O próximo padrão captura -5 em t e depois testa t < 0. A condição de guarda é verdadeira, então a saída é Below freezing by 5 degrees.

Em 0, o caso literal prevalece antes de a captura ser tentada. Em 12, a captura tem sucesso, mas a condição de guarda falha, então o Python tenta o curinga e imprime Above freezing. Uma condição de guarda falsa não encerra a busca por um caso.

Um nome isolado não consulta uma constante

Suponha que QUIT = "q". É tentador escrever case QUIT: para verificar se o valor sujeito é igual a esse valor. Mas um nome isolado é sempre uma captura, mesmo em maiúsculas. O caso aceita qualquer valor sujeito e sobrescreve QUIT com ele.

Se outros casos vierem após uma captura sem condição de guarda, o Python informa um erro de sintaxe porque a captura os torna inalcançáveis. Se a captura for a última, o erro pode passar despercebido durante a execução. Compare explicitamente com uma condição de guarda:

QUIT = "q"
key = "x"
match key:
    case k if k == QUIT:
        print("Quit")
    case _:
        print("Keep working")

Aqui k captura "x". A condição de guarda o compara com o "q" existente, falha e permite que o curinga imprima Keep working. Um literal case "q": é mais simples quando o valor fixo pode ser escrito diretamente.

Distinga um padrão de valor com ponto

Um nome com ponto, como math.pi, é um padrão de valor, não uma captura. Ele consulta um valor existente e compara o valor sujeito com ele usando ==. Constantes nomeadas fornecidas por módulos ou classes podem usar essa forma. A distinção a reconhecer é o ponto: case n: atribui um nome; um padrão com ponto verifica um valor existente.

Nomeie uma correspondência específica com as

answer = "y"
match answer:
    case "y" | "yes" as accepted:
        print("Accepted:", accepted)
    case _:
        print("Please answer y or yes")

O padrão de alternativas verifica as strings permitidas, e as armazena em accepted o valor sujeito que correspondeu. Para "y", a saída é Accepted: y. Ele não substitui a entrada por uma palavra padrão: "yes" armazenaria "yes". "Yes" não corresponde a nenhuma das duas strings porque maiúsculas e minúsculas ainda importam.

Uma ou duas condições de guarda podem se encaixar naturalmente entre casos fixos. Quando quase todo caso é um teste de intervalo ou usa variáveis diferentes, uma cadeia if–elif costuma ser mais clara. Qualquer uma das estruturas precisa de um caso final para os demais quando toda entrada deve receber uma resposta.