English 中文 العربية 日本語 Português

Python: Lógica Booleana

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.

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.

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

Operadores de comparação produzem resultados booleanos:

PYTHON 
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:

PYTHON 
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 ⭐)

PYTHON 
# Gera valores booleanos com operadores de comparação
age = 25
height = 175
weight = 70

is_adult = age >= 18          # True
is_tall = height > 170        # True
is_heavy = weight > 80        # False

print(f"Adult: {is_adult}")
print(f"Tall: {is_tall}")
print(f"Overweight: {is_heavy}")

# Imprime valores booleanos diretamente — eles são valores, não texto
print(f"Adult AND Tall: {is_adult and is_tall}")
▶ Experimente

Output:

TEXT 📖 Somente leitura 
Adult: True
Tall: True
Overweight: False
Adult AND Tall: True

2. not: Negação

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

PYTHON 
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"

PYTHON 
# 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

PYTHON 
# 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.

Esquerda Direita Resultado
True True True
True False False
False True False
False False False
PYTHON 
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 ⭐)

PYTHON 
# Simula login — nome de usuário correto E senha correta
username_correct = True
password_correct = False

can_login = username_correct and password_correct
print(f"Login result: {can_login}")   # False — senha errada

# Adiciona outra camada: a conta não deve estar bloqueada
account_locked = True
can_login = username_correct and password_correct and not account_locked
print(f"Final result: {can_login}")   # False — a conta está bloqueada
▶ Experimente

Output:

TEXT 📖 Somente leitura 
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.

Esquerda Direita Resultado
True True True
True False True
False True True
False False False
PYTHON 
# 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

PYTHON 
# 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:

TEXT 📖 Somente leitura 
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

PYTHON 
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:

TEXT 📖 Somente leitura 
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

PYTHON 
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

PYTHON 
# 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

PYTHON 
# 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

PYTHON 
# 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:

PYTHON 
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

PYTHON 
# 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.

PYTHON 
# == 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 ==:

PYTHON 
# 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 ⭐⭐)

PYTHON 
username = "alice2026"
password = "abc123"
age = 20
agreed_terms = True

is_valid = (
    bool(username) and
    len(password) >= 6 and
    age >= 18 and
    agreed_terms
)

reason = (
    (not username and "Username is empty") or
    (len(password) < 6 and "Password too short") or
    (age < 18 and "Underage") or
    (not agreed_terms and "Terms not agreed") or
    "Registration successful"
)

print(f"Registration result: {is_valid}")
print(f"Reason: {reason}")

age = 16
is_valid2 = bool(username) and len(password) >= 6 and age >= 18 and agreed_terms
reason2 = (
    (not username and "Username is empty") or
    (len(password) < 6 and "Password too short") or
    (age < 18 and "Underage") or
    (not agreed_terms and "Terms not agreed") or
    "Registration successful"
)
print(f"Registration result: {is_valid2}")
print(f"Reason: {reason2}")
▶ Experimente

Output:

TEXT 📖 Somente leitura 
Registration result: True
Reason: Registration successful
Registration result: False
Reason: Underage

8. Casos de uso comuns

❓ Perguntas Frequentes

P: Qual é a diferença entre True e "True"? R: True (sem aspas) é um valor booleano; "True" (com aspas) é uma string. Eles são diferentes: type(True) é <class 'bool'>, type("True") é <class 'str'>. Em uma condição, if "True": é sempre True (string não vazia é truthy), e if "False": também é sempre True (também não vazio). Portanto, nunca coloque aspas em valores booleanos em condições.

P: Quando devo usar is em vez de ==? R: Use == em 99% dos casos. is é convencional apenas em um cenário — verificar None: if result is None:. Use == para todas as outras comparações de valor. Lembre-se: == compara "valor", is compara "identidade".

P: Quais armadilhas a avaliação de curto-circuito de and/or tem? R: A armadilha mais comum envolve chamadas de função. Se você colocar uma chamada de função no lado direito de and ou or, ela pode não ser executada devido ao curto-circuito, e você não saberá que foi ignorada. Se essa função tiver efeitos colaterais (registrar logs, enviar e-mails, atualizar contadores), o curto-circuito pode causar comportamento inconsistente. Boa prática: se a expressão do lado direito tiver efeitos colaterais, não dependa do curto-circuito — escreva-as separadamente.

P: Por que not not "hello" retorna True? R: not "hello" primeiro avalia "hello" como booleano (string não vazia é truthy), e nega para obter False. Depois not not "hello" nega False novamente, obtendo True. Então not not x é equivalente a bool(x) — converter x para booleano. Mas esse padrão é incomum; use bool(x) diretamente para clareza.

📖 Resumo

📝 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).

Web-Tutorial.com

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.

100%