---
title: "Condicional: O que É e Como Funciona | Python Brasil"
url: "https://python.dev.br/glossario/condicional/"
markdown_url: "https://python.dev.br/glossario/condicional.MD"
description: "Aprenda condicionais em Python: if, elif, else, operadores logicos, ternario, match-case e boas praticas para controlar o fluxo do seu programa."
date: "2025-06-25"
author: ""
---

# Condicional: O que É e Como Funciona | Python Brasil

Aprenda condicionais em Python: if, elif, else, operadores logicos, ternario, match-case e boas praticas para controlar o fluxo do seu programa.


## O que e um Condicional?

Um **condicional** em Python e uma estrutura de controle de fluxo que permite executar diferentes blocos de codigo com base em condicoes logicas. A estrutura principal e o `if/elif/else`, que avalia expressoes booleanas e direciona a execucao do programa de acordo com o resultado. Condicionais sao fundamentais para criar programas que tomam decisoes e respondem de formas diferentes a situacoes variadas.

## Estrutura if/elif/else

```python
# if simples
idade = 18
if idade >= 18:
    print('Maior de idade')

# if/else
temperatura = 35
if temperatura > 30:
    print('Esta quente')
else:
    print('Temperatura agradavel')

# if/elif/else
nota = 7.5
if nota >= 9:
    conceito = 'A'
elif nota >= 7:
    conceito = 'B'
elif nota >= 5:
    conceito = 'C'
else:
    conceito = 'D'
print(f'Conceito: {conceito}')  # Conceito: B
```

## Operadores de Comparacao

```python
a, b = 10, 20

print(a == b)   # False — igualdade
print(a != b)   # True  — diferenca
print(a < b)    # True  — menor que
print(a > b)    # False — maior que
print(a <= b)   # True  — menor ou igual
print(a >= b)   # False — maior ou igual

# Comparacao encadeada (exclusividade do Python)
x = 15
print(10 < x < 20)    # True
print(1 <= x <= 100)   # True
```

## Operadores Logicos

```python
idade = 25
renda = 3000

# and — ambas condicoes devem ser verdadeiras
if idade >= 18 and renda >= 2000:
    print('Elegivel para o credito')

# or — pelo menos uma condicao deve ser verdadeira
dia = 'sabado'
if dia == 'sabado' or dia == 'domingo':
    print('Fim de semana')

# not — inverte o valor logico
usuario_ativo = True
if not usuario_ativo:
    print('Conta desativada')

# Combinando operadores
tem_ingresso = True
idade = 16
acompanhado = True
if tem_ingresso and (idade >= 18 or acompanhado):
    print('Entrada permitida')
```

## Valores Truthy e Falsy

Em Python, qualquer objeto pode ser avaliado como booleano. Valores considerados **falsy** sao: `False`, `None`, `0`, `0.0`, `''` (string vazia), `[]` (lista vazia), `{}` (dict vazio), `set()` e `()` (tupla vazia). Todo o resto e **truthy**.

```python
# Aproveitando truthy/falsy
nome = input('Seu nome: ')
if nome:
    print(f'Ola, {nome}')
else:
    print('Nome nao informado')

# Lista vazia
itens = []
if not itens:
    print('Lista vazia')

# Valor None
resultado = None
if resultado is None:
    print('Sem resultado')

# IMPORTANTE: use 'is' para comparar com None, nao '=='
if resultado is None:    # correto
    pass
if resultado == None:    # funciona, mas nao e Pythonico
    pass
```

## Operador Ternario

O Python permite condicionais em uma unica linha usando a sintaxe de expressao condicional.

```python
# Sintaxe: valor_se_verdadeiro if condicao else valor_se_falso
idade = 20
status = 'maior' if idade >= 18 else 'menor'
print(status)  # 'maior'

# Em atribuicoes
desconto = 0.1 if cliente_vip else 0.0

# Em chamadas de funcao
print('Par' if numero % 2 == 0 else 'Impar')

# Aninhado (evitar — prejudica legibilidade)
classificacao = 'A' if nota >= 9 else 'B' if nota >= 7 else 'C'
```

## match/case (Python 3.10+)

O structural pattern matching, introduzido no Python 3.10, oferece uma alternativa poderosa a cadeias longas de `if/elif`.

```python
# Pattern matching basico
comando = 'sair'
match comando:
    case 'iniciar':
        print('Iniciando...')
    case 'pausar':
        print('Pausando...')
    case 'sair':
        print('Encerrando...')
    case _:
        print('Comando desconhecido')

# Com desestruturacao
ponto = (3, 4)
match ponto:
    case (0, 0):
        print('Origem')
    case (x, 0):
        print(f'No eixo X: {x}')
    case (0, y):
        print(f'No eixo Y: {y}')
    case (x, y):
        print(f'Ponto ({x}, {y})')

# Com guardas (guard clauses)
match idade:
    case n if n < 0:
        print('Idade invalida')
    case n if n < 18:
        print('Menor de idade')
    case n if n < 65:
        print('Adulto')
    case _:
        print('Idoso')
```

## Condicionais em Comprehensions

```python
# Filtro com if
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pares = [n for n in numeros if n % 2 == 0]
print(pares)  # [2, 4, 6, 8, 10]

# if/else em comprehension (note a posicao diferente)
rotulos = ['par' if n % 2 == 0 else 'impar' for n in numeros]
print(rotulos)  # ['impar', 'par', 'impar', 'par', ...]

# Filtro com multiplas condicoes
especiais = [n for n in numeros if n % 2 == 0 and n > 4]
```

## Padroes Comuns

```python
# Guard clause (retorno antecipado)
def processar_pedido(pedido):
    if not pedido:
        return None
    if pedido.get('status') != 'ativo':
        return None
    if pedido.get('total', 0) <= 0:
        return None
    # logica principal aqui
    return calcular_frete(pedido)

# Operador walrus (:=) com condicionais (Python 3.8+)
import re
texto = 'Meu email e ana@email.com'
if match := re.search(r'[\w.]+@[\w.]+', texto):
    print(f'Email encontrado: {match.group()}')

# Dicionario como alternativa a if/elif
def calcular_imposto(estado):
    impostos = {
        'SP': 0.18,
        'RJ': 0.20,
        'MG': 0.17,
    }
    return impostos.get(estado, 0.15)  # 0.15 como padrao
```

## Erros Comuns

O erro mais frequente e usar `=` (atribuicao) em vez de `==` (comparacao), embora o Python levante um `SyntaxError` na maioria dos casos, evitando bugs silenciosos. Outro erro e encadear condicionais desnecessariamente quando um dicionario de mapeamento seria mais limpo. Tambem e comum esquecer que `and` e `or` em Python fazem avaliacao de curto-circuito e retornam o ultimo valor avaliado, nao necessariamente `True` ou `False`.

## Boas Praticas

Use guard clauses para retornar cedo e reduzir aninhamento. Aproveite valores truthy e falsy em vez de comparacoes explicitas como `if len(lista) > 0`. Use `is` para comparar com `None`, `True` e `False`. Prefira dicionarios de mapeamento a longas cadeias de `if/elif`. Evite condicionais ternarios aninhados. Para Python 3.10 ou superior, considere `match/case` para logica de despacho complexa.

## Quando Usar

Condicionais sao usados em qualquer situacao onde o programa precisa tomar decisoes: validacao de dados, controle de acesso, tratamento de casos especiais, roteamento de logica e muito mais. A escolha entre `if/elif`, dicionario de mapeamento ou `match/case` depende da complexidade e legibilidade desejada.