Em Python, os valores booleanos representam dois estados: verdadeiro ou falso. Eles são fundamentais para controle de fluxo, como em condicionais e laços. Nesta aula, vamos explorar os literais True e False, entender como outros valores são interpretados como verdadeiros ou falsos (valores falsy), e aprender a usar operadores lógicos para combinar expressões booleanas. Também veremos o conceito de curto-circuito, que pode otimizar a execução do código.

Vamos começar com o básico e depois mergulhar em detalhes importantes para escrever código Python eficiente e expressivo.

True/False

Em Python, os valores booleanos são representados pelas constantes True e False. Eles são do tipo bool, que é uma subclasse de int: True equivale a 1 e False equivale a 0. Isso permite que operações aritméticas funcionem com booleanos, embora não seja recomendado por questões de clareza.

Você pode obter um valor booleano como resultado de comparações (como ==, !=, >, <, etc.) ou usando a função bool() para converter outros valores. Exemplos:

print(5 > 3)    # True
print(10 == 10) # True
print(7 != 7)   # False
print(bool(1))  # True
print(bool(0))  # False

Os valores booleanos são imutáveis e podem ser usados em expressões lógicas, atribuições e como índices (embora raramente).

Valores falsy

Em Python, alguns valores são considerados "falsos" quando avaliados em um contexto booleano, como em um if. Esses são chamados de valores falsy. Os principais são:

  • None
  • False
  • Zero numérico: 0, 0.0, 0j
  • Sequências e coleções vazias: '', (), [], {}, set()
  • Qualquer objeto que implemente __bool__() ou __len__() retornando False ou 0.

Todos os outros valores são considerados truthy. Isso é útil para verificar se uma lista está vazia, por exemplo:

lista = []
if lista:
    print('lista não vazia')
else:
    print('lista vazia')  # Isso será executado

Entender valores falsy ajuda a escrever condições mais concisas e legíveis.

Operadores lógicos

Python oferece três operadores lógicos: and, or e not. Eles operam sobre valores booleanos (ou valores que podem ser convertidos para booleano) e retornam um valor booleano ou um dos operandos, dependendo do operador.

  • and: retorna True apenas se ambos os operandos forem verdadeiros. Caso contrário, retorna False. Na prática, ele retorna o primeiro valor falso ou o último valor verdadeiro.
  • or: retorna True se pelo menos um operando for verdadeiro. Retorna o primeiro valor verdadeiro ou o último valor falso.
  • not: retorna o valor booleano inverso do operando (True vira False e vice-versa).

Exemplos:

a = True
b = False
print(a and b)  # False
print(a or b)   # True
print(not a)    # False

# Com valores não booleanos
print(0 and 10)   # 0 (primeiro falso)
print(10 and 20)  # 20 (último verdadeiro)
print(0 or 10)    # 10 (primeiro verdadeiro)
print(10 or 20)   # 10 (primeiro verdadeiro)

Observe que os operadores and e or não retornam necessariamente True ou False, mas um dos operandos. Isso é útil para atribuições condicionais.

Curto-circuito

Os operadores and e or usam avaliação de curto-circuito: a expressão é avaliada da esquerda para a direita e a avaliação para assim que o resultado é determinado. Para and, se o primeiro operando for falso, o segundo não é avaliado (pois o resultado já será falso). Para or, se o primeiro operando for verdadeiro, o segundo não é avaliado.

Isso pode ser usado para evitar erros, como acessar atributos de None:

def get_nome(dicionario, chave):
    return dicionario.get(chave) or 'Nome padrão'

pessoa = {'nome': 'João'}
print(get_nome(pessoa, 'nome'))  # João
print(get_nome(pessoa, 'idade')) # Nome padrão (pois None é falsy)

Outro exemplo: verificar se uma lista não é vazia antes de acessar o primeiro elemento:

lista = []
primeiro = lista and lista[0]  # Se lista for vazia, retorna [] (falso), sem erro
print(primeiro)  # []

O curto-circuito também é útil para encadear condições, garantindo que uma condição só seja avaliada se a anterior for verdadeira.

Boas práticas: Use curto-circuito para simplificar verificações, mas evite expressões muito complexas que prejudiquem a legibilidade. Prefira if explícitos quando a lógica não for trivial.

Referências

Exercícios

  1. O que será impresso pelo código abaixo? Explique.

    x = 0
y = 10
resultado = x and y
print(resultado)

    ✓ Resposta: O código imprime 0. Como x é 0 (falsy), o operador and para e retorna o primeiro valor falsy, que é 0.

  2. Qual é o resultado da expressão not (10 > 5) or (3 == 3)?

    ✓ Resposta: True. Primeiro, not (10 > 5) é not True = False. Depois, False or (3 == 3) é False or True = True.

  3. Escreva uma expressão que verifique se uma variável nome não é vazia e, se for, atribua 'Visitante' a ela, usando curto-circuito.

    ✓ Resposta: nome = nome or 'Visitante'. Se nome for uma string vazia (falsy), a expressão retorna 'Visitante'. Caso contrário, retorna o próprio nome.

  4. O que a função bool() retorna para os valores: [], 'False', 0.0, None?

    ✓ Resposta: bool([]) retorna False (lista vazia é falsy). bool('False') retorna True (string não vazia é truthy). bool(0.0) retorna False. bool(None) retorna False.

  5. Explique o que acontece na expressão 10 or 0/0 e por que não ocorre erro de divisão por zero.

    ✓ Resposta: A expressão retorna 10. Como 10 é truthy, o operador or faz curto-circuito e não avalia o segundo operando (0/0), evitando assim o erro de divisão por zero.