Python: Lógica Booleana

Última atualização: 2026-09-22

Na Lição 03, aprendemos sobre operadores, incluindo os operadores lógicos and, or, not. Nesta lição, vamos focar em julgamentos de verdadeiro/falso — o conceito mais fundamental da ciência da computação. A lógica booleana é a base de todas as declarações condicionais, controles de loop e verificações de permissão.

Palavras-chave / Instruções relacionadas：strip() False True None int

1. Valores Booleanos: True e False

Existem apenas dois valores booleanos: True e False. Eles recebem o nome do matemático britânico George Boole, que fundou a álgebra booleana — a base teórica do "0 e 1" da computação moderna.

print(True)    # Saída: True
print(False)   # Saída: False
print(type(True))   # <class 'bool'>

Operadores de comparação produzem resultados booleanos:

print(5 > 3)      # True
print(10 == 5)    # False
print(7 <= 7)     # True
print(3 != 3)     # False

(1) Booleanos também são números

Em Python, True e False são, na verdade, subclasses de int — True é equivalente a 1, False a 0:

print(True + True)      # 2 (True=1, dois True = 2)
print(True * 10)        # 10
print(False * 100)      # 0

Aviso: Embora True == 1 e False == 0 sejam válidos em Python (então True + True é igual a 2), nunca use-os dessa forma. Valores booleanos servem para julgamento lógico, não para aritmética. Escrever código como score + True deixará os leitores confusos.

▶ Exemplo: Resultados da Verificação de Saúde (Dificuldade ⭐)

Output:

Adult: True
Tall: True
Overweight: False
Adult AND Tall: True

2. not: Negação

not significa "inverter" — preto vira branco, branco vira preto.

print(not True)      # False
print(not False)     # True
print(not (5 > 3))   # False (5>3 é True, negado vira False)

not é comumente usado em dois cenários:

Cenário 1: Verificando "não atender a uma condição"

# Não é admin — não pode entrar no backend
is_admin = False
if not is_admin:
    print("You do not have admin access.")
# Saída: You do not have admin access.

Cenário 2: Verificando se uma variável está vazia

# Verifica se o usuário não forneceu um nome
username = ""
if not username:
    print("Username cannot be empty!")
# Saída: Username cannot be empty!

Aqui há um truque de "conversão booleana implícita" do Python — a string vazia "" é equivalente a False em verificações de condição. Portanto, not username é True quando username é uma string vazia. Veremos quais valores são "falsy" mais adiante.

Dica: not significa "negação." No código, if not is_admin: se lê como "se não for admin."

3. and: Ambos devem ser True

and significa "ambos" — ambas as condições devem ser verdadeiras para que o resultado seja True. Se qualquer uma for falsa, o resultado é False.

age = 22
has_id = True

# Ambas as condições devem ser atendidas
can_buy_alcohol = age >= 18 and has_id
print(can_buy_alcohol)   # True (tem idade e tem documento)

# Outro cenário: solicitar cartão de crédito exige renda >= 50 mil E score de crédito >= 600
income = 80  # milhares
credit_score = 650
qualified = income >= 50 and credit_score >= 600
print(f"Credit card application: {qualified}")   # True

▶ Exemplo: Verificação de Login (Dificuldade ⭐)

Output:

Login result: False
Final result: False

4. or: Pelo menos um True

or significa "qualquer um" — se pelo menos uma condição for verdadeira, o resultado é True. Somente quando ambas são falsas o resultado é False.

# Pode descansar nos fins de semana ou feriados
is_weekend = True
is_holiday = False
can_rest = is_weekend or is_holiday
print(can_rest)   # True (é fim de semana)

# Segurança do metrô: se você tem água OU uma bebida, precisa de verificação
has_water = True
has_drink = False
need_check = has_water or has_drink
print(f"Security check needed: {need_check}")   # True

(1) Exercício: Verificação completa da tabela-verdade

# Verifica a tabela-verdade com código — todas as combinações de and e or
a = True
b = True
print(f"{a} and {b} = {a and b}")
print(f"{a} or  {b} = {a or b}")

a = True
b = False
print(f"{a} and {b} = {a and b}")
print(f"{a} or  {b} = {a or b}")

a = False
b = True
print(f"{a} and {b} = {a and b}")
print(f"{a} or  {b} = {a or b}")

a = False
b = False
print(f"{a} and {b} = {a and b}")
print(f"{a} or  {b} = {a or b}")

Output:

True and True = True
True or  True = True
True and False = False
True or  False = True
False and True = False
False or  True = True
False and False = False
False or  False = False

5. Avaliação de Curto-Circuito

Mencionamos isso na Lição 03, mas é tão importante que vamos nos aprofundar. Os operadores lógicos do Python param de avaliar imediatamente assim que o resultado é determinado, sem executar a expressão restante.

(1) Curto-circuito do and: Esquerda é False -> Direita não é executada

def check_right():
    print("-> check_right was called!")
    return True

print("False and check_right():")
result = False and check_right()   # check_right NÃO será executada
print(f"Result: {result}\n")

print("True and check_right():")
result = True and check_right()    # check_right será executada
print(f"Result: {result}")

Output:

False and check_right():
Result: False

True and check_right():
-> check_right was called!
Result: True

(2) Curto-circuito do or: Esquerda é True -> Direita não é executada

print("True or check_right():")
result = True or check_right()    # check_right NÃO será executada
print(f"Result: {result}")

(3) Usos clássicos da avaliação de curto-circuito

1. Acesso seguro: prevenindo erros de None

# Suponha que user possa ser None (o usuário não existe)
user = None
# user.get("name") daria erro — None não tem o método get

# Use curto-circuito para proteger:
name = user and user.get("name")
print(name)   # None — user é falsy, ocorreu curto-circuito, user.get() não foi chamado

# Se o usuário existir:
user = {"name": "Xiao Ming"}
name = user and user.get("name")
print(name)   # Xiao Ming

2. Definindo valores padrão

# Se o usuário não digitou um nome, use um padrão
user_input = ""           # String vazia (falsy)
name = user_input or "guest"
print(f"Welcome, {name}")   # Welcome, guest

user_input = "Zhang San"
name = user_input or "guest"
print(f"Welcome, {name}")   # Welcome, Zhang San

Dica: O padrão user_input or "default" é muito "pythonico" — se o lado esquerdo for falsy (string vazia), use o direito; se for truthy (tem conteúdo), use o esquerdo. Ele aproveita o comportamento de curto-circuito do or.

6. Valores Truthy e Falsy

Em Python, qualquer valor pode ser usado como booleano em uma condição. Alguns valores são considerados "falsy", e todo o resto é "truthy".

(1) Valores falsy comuns

# Esses valores são equivalentes a False em condições
print(bool(False))      # False — booleano falso
print(bool(0))          # False — zero
print(bool(0.0))        # False — zero de ponto flutuante
print(bool(""))         # False — string vazia
print(bool([]))         # False — lista vazia (abordada mais adiante)
print(bool(None))       # False — valor nulo

Todo o resto é truthy:

print(bool(1))          # True — número diferente de zero
print(bool(-5))         # True — números negativos também são truthy!
print(bool("Python"))   # True — string não vazia
print(bool(" "))        # True — um espaço é um caractere, não vazio é truthy
print(bool([1, 2]))     # True — lista não vazia

Aviso: -5 e " " (espaço) são ambos truthy, o que pode surpreender você. -5 é um inteiro diferente de zero, então é truthy. Um espaço é um caractere, tornando a string não vazia, então é truthy. Apenas a string vazia "" é falsy.

(2) Usando truthiness para simplificar o código

# Não recomendado (verboso)
name = "Xiao Ming"
if name != "":
    print(f"Hello, {name}")

# Recomendado (conciso)
name = "Xiao Ming"
if name:
    print(f"Hello, {name}")

# Não recomendado
score = 85
if score != 0:
    print(f"Score: {score}")

# Recomendado
score = 85
if score:
    print(f"Score: {score}")

Dica: Aproveitar a truthiness deixa o código mais limpo. if name: é mais "pythonico" do que if name != "":. Mas cuidado para não exagerar — if score: não será executado quando score=0. Se você precisa distinguir entre "score é 0" e "sem score", use is not None.

7. is e is not: Comparação de identidade

is compara se duas variáveis apontam para o mesmo objeto (o mesmo espaço na memória), não se seus valores são iguais. Mencionamos isso na Lição 03; aqui estão mais exemplos para reforçar.

# == compara valores, is compara identidade
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)     # True — mesmos valores
print(a is b)     # False — mas não é o mesmo objeto de lista
print(a is c)     # True — c é a, aponta para a mesma lista

# Cache de inteiros pequenos (otimização interna do Python)
x = 256
y = 256
print(x is y)     # Pode ser True — inteiros pequenos são armazenados em cache

x = 1000
y = 1000
print(x is y)     # Pode ser False — inteiros grandes não são armazenados em cache

Aviso: Nunca use is para comparar inteiros ou strings por valor. Embora inteiros pequenos às vezes possam retornar True com is devido à otimização interna do Python, isso é um detalhe de implementação e não é confiável. Sempre use == para comparação de valores.

(1) O uso correto: verificando None

A comunidade Python tem uma convenção — ao verificar se um valor é None, sempre use is, nunca ==:

# Abordagem correta
result = None
if result is None:
    print("No result")

# Não recomendado
if result == None:
    print("No result")

▶ Exemplo: Validação de Condições de Cadastro (Dificuldade ⭐⭐)

Output:

Registration result: True
Reason: Registration successful
Registration result: False
Reason: Underage

8. Casos de uso comuns

• Controle de permissão: is_admin or (is_logged_in and has_permission) — combine várias condições para decidir o que um usuário pode fazer.
• Validação de entrada: username and password — verifique se o usuário forneceu ambos.
• Padrões de parâmetros opcionais: timeout or 30 — se o timeout não estiver definido, use o padrão de 30 segundos.
• Cadeia de acesso seguro: user and user.address and user.address.city — acesso seguro camada por camada; curto-circuito em qualquer etapa falsy.
• Controle de alternância: is_enabled and is_connected — ambas as condições devem ser atendidas para a operação prosseguir.

Palavras-chave / Instruções relacionadas：strip() False True None int

❓ Perguntas Frequentes

📖 Resumo

• Booleanos têm apenas dois valores: True e False; eles são subclasses de int (True=1, False=0), mas não os use para aritmética
• not nega: verdadeiro vira falso, falso vira verdadeiro
• and exige que ambos sejam verdadeiros
• or exige que pelo menos um seja verdadeiro
• Os valores falsy do Python incluem: False, 0, 0.0, "", [], None — todo o resto é truthy
• Curto-circuito: and com a esquerda falsa -> direita não executada; or com a esquerda verdadeira -> direita não executada
• O curto-circuito permite dois padrões clássicos: "acesso seguro" e "valores padrão"
• is compara identidade, == compara valor; use is para verificações de None

📝 Exercícios

1. Iniciante (Dificuldade ⭐): Preveja os valores dessas expressões e depois verifique:

   • not (10 > 5)
   • True and False or True
   • not False and True
   • (5 > 3) or (2 > 10) and (8 == 8) — Dica: Atenção à precedência — and é maior que or

2. Intermediário (Dificuldade ⭐⭐): Escreva código para validar a string de entrada de um usuário:

   • Se a entrada estiver vazia, imprima "Input cannot be empty"
   • Se a entrada for só espaços, trate também como "Input cannot be empty" (Dica: use strip())
   • Se o comprimento da entrada for menor que 6, imprima "Input must be at least 6 characters"
   • Caso contrário, imprima "Input is valid"

3. Avançado (Dificuldade ⭐⭐⭐): Escreva um "verificador de número de três dígitos". Dado um número de 3 dígitos num (ex.: 153), determine:

   • Ele é par? (use %)
   • Ele é divisível por 3 e por 5?
   • Ele é um palíndromo? (o dígito das centenas é igual ao das unidades, ex.: 121, 353)
   • Quantas das condições acima são atendidas? Imprima a contagem.

   Use apenas expressões booleanas para todas as verificações — sem declarações if (guarde isso para a próxima lição).

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós