Entendendo Booleans em Python

Um boolean é um tipo de dado com exatamente dois valores possíveis: True ou False. Os booleans em Python controlam cada decisão que seu código toma — desde instruções if até loops while e list comprehensions. Este capítulo aborda como os booleans funcionam, como Python avalia qualquer valor como truthy ou falsy, e padrões práticos que você usará todos os dias.

O Que São Booleans em Python?

Em Python, True e False são palavras-chave (com letra maiúscula). Eles pertencem ao tipo built-in bool, que é uma subclasse de int. Isso significa que True se comporta como 1 e False se comporta como 0 em contextos aritméticos.

print(type(True))   # <class 'bool'>
print(type(False))  # <class 'bool'>

print(True == 1)    # True
print(False == 0)   # True
print(True + True)  # 2  (bool is a subclass of int)

A última linha — True + True sendo igual a 2 — surpreende muitos iniciantes. É Python válido e ocasionalmente útil (por exemplo, contar quantas condições em uma lista são verdadeiras), mas usar booleans em aritmética deve ser intencional e claramente comentado.

Criando Variáveis Boolean

Você pode atribuir True ou False diretamente a uma variável:

Python define boolean variable

Por convenção, nomes de variáveis boolean frequentemente começam com is_, has_, can_ ou should_ para deixar seu propósito claro à primeira vista.

Booleans a Partir de Operadores de Comparação

Cada operador de comparação produz um resultado boolean:

Python compare two integers

Você pode armazenar resultados de comparação em uma variável e reutilizá-los, o que mantém condições if complexas legíveis.

Usando Booleans em Instruções Condicionais

Os booleans são o mecanismo por trás das decisões if/else. Python avalia a expressão após if e executa o bloco indentado somente quando o resultado é True:

Python compare two integers and print the result

Você também pode usar uma variável boolean diretamente sem nenhum operador de comparação:

is_raining = True
if is_raining:
    print("Bring an umbrella")
else:
    print("Enjoy the sunshine")

Usar if is_raining: é mais Pythônico do que if is_raining == True:. O último não acrescenta nenhuma informação e é considerado um code smell.

Valores Truthy e Falsy

Python não requer um valor True ou False real em um contexto boolean. Cada objeto é truthy (tratado como True) ou falsy (tratado como False). Isso permite escrever condições concisas sem comparações explícitas.

Valores falsy

Os seguintes valores são sempre falsy em Python:

Tudo o mais é truthy — incluindo números diferentes de zero, strings não vazias e coleções não vazias.

# All of these print "empty" because the values are falsy
for value in [0, 0.0, "", [], {}, (), None]:
    if not value:
        print(f"{repr(value)} is falsy")

Valores truthy na prática

name = input("Enter your name: ")
if name:                   # truthy if name is not an empty string
    print(f"Hello, {name}!")
else:
    print("No name provided.")

items = [1, 2, 3]
if items:                  # truthy if list is not empty
    print(f"Processing {len(items)} items")

Esse padrão — verificar uma coleção diretamente em vez de len(items) > 0 — é Python idiomático.

Convertendo Valores para Boolean com bool()

A função built-in bool() converte qualquer valor para seu equivalente boolean, o que é útil quando você quer inspecionar se algo é truthy ou falsy:

Python casting into boolean

Mais exemplos:

print(bool(0))        # False
print(bool(0.0))      # False
print(bool(""))       # False
print(bool([]))       # False
print(bool(None))     # False

print(bool(1))        # True
print(bool(-1))       # True
print(bool("hello"))  # True
print(bool([0]))      # True  — list with one element is truthy

Note que bool([0]) é True mesmo que o único elemento dentro seja falsy. Python verifica se o contêiner está vazio, não os valores dentro dele.

Operadores Lógicos com Booleans

Python fornece três operadores lógicos para combinar expressões boolean. Veja Python Operators para a referência completa de operadores.

and

Retorna True somente se ambos os operandos forem verdadeiros:

print(True and True)   # True
print(True and False)  # False
print(False and True)  # False
print(False and False) # False

or

Retorna True se pelo menos um operando for verdadeiro:

print(True or False)   # True
print(False or False)  # False
print(True or True)    # True

not

Inverte o valor boolean:

print(not True)   # False
print(not False)  # True
print(not 0)      # True  (0 is falsy, so not 0 is True)
print(not "hi")   # False ("hi" is truthy, so not "hi" is False)

Avaliação de curto-circuito

Python avalia and e or de forma preguiçosa — ele para assim que o resultado é determinado. Isso é chamado de avaliação de curto-circuito:

• False and <anything> — Python nunca avalia o lado direito porque o resultado já é False.
• True or <anything> — Python nunca avalia o lado direito porque o resultado já é True.

Isso importa quando o lado direito tem efeitos colaterais ou poderia gerar um erro:

items = []

# Safe: the second condition is only evaluated if items is truthy
if items and items[0] > 10:
    print("First item exceeds 10")

Sem o curto-circuito, items[0] em uma lista vazia geraria um IndexError. Como items é falsy (lista vazia), Python pula o lado direito completamente.

O Operador is vs. == com Booleans

== testa se dois valores são iguais. is testa se dois nomes se referem ao mesmo objeto na memória.

print(1 == True)   # True  (equal in value)
print(1 is True)   # False (different objects)

Sempre use == (ou confie na truthiness) ao comparar valores. Reserve is para verificações de identidade — mais comumente is None:

value = None
if value is None:
    print("No value provided")

Usar == None funciona, mas is None é a forma idiomática e ligeiramente mais rápida.

Contando com Booleans

Como True == 1 e False == 0, você pode usar sum() para contar quantos itens em uma lista satisfazem uma condição:

scores = [85, 42, 91, 67, 55, 78]
passed = sum(score >= 60 for score in scores)
print(f"{passed} out of {len(scores)} students passed")
# 4 out of 6 students passed

Isso é mais conciso do que um loop contador manual e é um idioma comum em Python.

Armadilhas Comuns

1. Comparar com True/False explicitamente

# Avoid
if is_valid == True:
    ...

# Prefer
if is_valid:
    ...

2. Confundir = (atribuição) com == (igualdade)

x = 5
if x = 5:   # SyntaxError — use == for comparison
    print("equal")

3. Assumir que uma lista vazia dentro de uma lista é falsy

outer = [[]]       # a list containing one empty list
if outer:
    print("truthy")  # This prints! outer has one element.

A lista externa tem um item (a lista vazia interna), então outer em si é truthy. Apenas a lista interna outer[0] é falsy.

Resumo

• Os booleans em Python são True e False — sempre com letra maiúscula.
• Todo valor em Python é truthy ou falsy. Valores falsy incluem 0, "", [], {}, () e None.
• Use bool() para converter explicitamente um valor para seu equivalente boolean.
• Combine condições com and, or e not. Python os avalia de forma preguiçosa por meio de regras de curto-circuito.
• Use is None (não == None) ao verificar None.
• Como bool é uma subclasse de int, True + True é igual a 2 — útil para contagem.

Em seguida, aprenda sobre Python Operators para ver como os operadores de comparação e lógicos produzem os valores boolean abordados aqui. Você também pode explorar como os booleans orientam o fluxo do programa em Python If...Else.

Prática