7. Booleanos e Condições

Nos capítulos anteriores, você aprendeu a trabalhar com números, strings e operações básicas com dados. Agora estamos prontos para explorar como o Python toma decisões — uma capacidade fundamental que permite que programas respondam de forma diferente com base em condições variadas. No coração da tomada de decisão em Python estão os valores Booleanos e as condições.

Pense em decisões do dia a dia: "Se estiver chovendo, eu vou levar um guarda-chuva." "Se a temperatura estiver acima de 30°C, vou ligar o ar-condicionado." Essas decisões são baseadas em condições que são verdadeiras ou falsas. O Python usa o mesmo princípio: ele avalia condições para determinar se são verdadeiras ou falsas e então age de acordo.

Neste capítulo, vamos explorar valores Booleanos, aprender como criar condições usando operadores de comparação, entender o conceito de "truthiness" em Python e descobrir técnicas poderosas para construir expressões lógicas complexas. Ao final deste capítulo, você terá dominado os blocos de construção necessários para as instruções if e loops que verá nos próximos capítulos.

7.1) Valores Booleanos True e False

Python tem um tipo de dado especial chamado bool (abreviação de Boolean) que representa valores de verdade. Esse tipo tem exatamente dois valores possíveis: True e False. Note que esses valores começam com letra maiúscula — isso é importante em Python. Escrever true ou false (minúsculo) causará um erro porque o Python não os reconhecerá.

python

# boolean_basics.py
# Criando variáveis Booleanas
is_sunny = True
is_raining = False
 
print(is_sunny)    # Output: True
print(is_raining)  # Output: False
 
print(type(True))   # Output: <class 'bool'>
print(type(False))  # Output: <class 'bool'>

Valores Booleanos são fundamentais porque representam o resultado de qualquer pergunta de sim/não que seu programa possa fazer: Esse número é maior que 10? Essa string contém a letra 'a'? O usuário está logado? Toda condição em Python acaba avaliando para True ou False.

7.1.1) Booleanos em Variáveis e Expressões

Você pode armazenar valores Booleanos em variáveis assim como armazena números ou strings. Isso é útil quando você quer acompanhar o estado de algo no seu programa:

python

# boolean_variables.py
# Usando variáveis Booleanas para acompanhar estados
is_logged_in = False
has_permission = True
is_valid_email = True
 
print("User logged in:", is_logged_in)        # Output: User logged in: False
print("Has permission:", has_permission)      # Output: Has permission: True
print("Valid email:", is_valid_email)         # Output: Valid email: True
 
# Variáveis Booleanas podem ser reatribuídas
is_logged_in = True
print("User logged in:", is_logged_in)        # Output: User logged in: True

Variáveis Booleanas costumam ser nomeadas com prefixos como is_, has_ ou can_ para deixar claro seu propósito. Essa convenção de nomes ajuda você e outras pessoas lendo seu código a entenderem imediatamente que a variável guarda um valor de verdadeiro/falso.

7.2) Operadores de Comparação e Condições Básicas

Embora você possa criar valores Booleanos diretamente com True e False, a maioria dos valores Booleanos nos seus programas virá de comparações — testar relações entre valores. O Python fornece vários operadores de comparação que comparam dois valores e produzem um resultado Booleano.

7.2.1) Os Seis Operadores de Comparação

Python tem seis operadores de comparação principais:

Operador	Significado	Exemplo	Resultado
`==`	Igual a	`5 == 5`	`True`
`!=`	Diferente de	`5 != 3`	`True`
`<`	Menor que	`3 < 5`	`True`
`>`	Maior que	`5 > 3`	`True`
`<=`	Menor ou igual a	`5 <= 5`	`True`
`>=`	Maior ou igual a	`5 >= 3`	`True`

Vamos ver esses operadores em ação:

python

# comparison_operators.py
# Comparando números
x = 10
y = 20
 
print(x == y)   # Output: False
print(x != y)   # Output: True
print(x < y)    # Output: True
print(x > y)    # Output: False
print(x <= y)   # Output: True
print(x >= y)   # Output: False
 
# Comparações com valores iguais
a = 15
b = 15
 
print(a == b)   # Output: True
print(a <= b)   # Output: True
print(a >= b)   # Output: True

7.2.2) Comparando Números e Strings

Operadores de comparação funcionam com muitos tipos de valores, não apenas inteiros:

python

# comparing_types.py
# Comparando números de ponto flutuante
temperature = 23.5
print(temperature > 20.0)   # Output: True
print(temperature == 23.5)  # Output: True
 
# Comparando strings (ordem alfabética/lexicográfica)
name1 = "Alice"
name2 = "Bob"
print(name1 < name2)   # Output: True
print(name1 == name2)  # Output: False
 
# Comparações de strings diferenciam maiúsculas de minúsculas
word1 = "Python"
word2 = "python"
print(word1 == word2)  # Output: False
 
# Comparando tamanhos de strings usando len()
print(len(name1) == len(name2))  # Output: False

Ao comparar strings, o Python usa ordem lexicográfica, que é basicamente ordem alfabética com base nos valores Unicode dos caracteres. Letras maiúsculas vêm antes de letras minúsculas nessa ordem, e é por isso que "Python" e "python" não são iguais.

7.2.3) Armazenando Resultados de Comparações

O resultado de qualquer comparação é um valor Booleano, o que significa que você pode armazená-lo em uma variável:

python

# storing_comparisons.py
# Armazenando resultados de comparações para uso posterior
age = 25
is_adult = age >= 18
is_senior = age >= 65
is_teenager = 13 <= age <= 19  # Vamos aprender sobre comparações encadeadas em breve
 
print("Is adult:", is_adult)        # Output: Is adult: True
print("Is senior:", is_senior)      # Output: Is senior: False
print("Is teenager:", is_teenager)  # Output: Is teenager: False
 
# Usando comparações armazenadas em cálculos ou outras expressões
price = 100
discount_eligible = price > 50
print("Discount eligible:", discount_eligible)  # Output: Discount eligible: True

Armazenar resultados de comparações em variáveis com nomes descritivos deixa seu código mais legível. Em vez de escrever repetidamente age >= 18 ao longo do programa, você pode usar a variável is_adult, que comunica claramente o que você está verificando.

7.3) Booleanos de Comparações, Expressões e a Função bool()

Vimos que comparações produzem valores Booleanos. Mas há outras maneiras de obter valores Booleanos em Python, incluindo o uso da função bool() para converter outros tipos para Booleanos.

7.3.1) A Função bool()

A função bool() converte qualquer valor em seu equivalente Booleano. Isso é útil quando você quer verificar explicitamente se um valor seria considerado verdadeiro ou falso em um contexto Booleano:

python

# bool_function.py
# Convertendo números para Booleanos
print(bool(1))       # Output: True
print(bool(42))      # Output: True
print(bool(-5))      # Output: True
print(bool(0))       # Output: False
print(bool(0.0))     # Output: False
 
# Convertendo strings para Booleanos
print(bool("Hello"))     # Output: True
print(bool("False"))     # Output: True
print(bool(""))          # Output: False
 
# Convertendo None para Booleano
print(bool(None))    # Output: False

A função bool() segue regras específicas de conversão, que vamos explorar em detalhes na próxima seção sobre truthiness e falsiness. Por enquanto, repare que a maioria dos valores é convertida para True, mas certos valores especiais como 0, 0.0, strings vazias ("") e None são convertidos para False.

7.4) Truthiness e Falsiness em Condições

Uma das características mais poderosas do Python é seu conceito de truthiness e falsiness. Em Python, todo valor — não apenas True e False — tem uma interpretação Booleana inerente. Isso significa que você pode usar qualquer valor onde se espera um Booleano, e o Python vai tratá-lo como verdadeiro ou falso.

7.4.1) Valores Falsy: O que Conta como False

Em Python, os seguintes valores são considerados falsy (eles se comportam como False em contextos Booleanos):

O próprio valor Booleano False
O valor especial None
Zero numérico em qualquer forma: 0, 0.0, 0j (zero complexo)
Sequências vazias: "" (string vazia), [] (lista vazia), () (tupla vazia)
Mapeamentos vazios: {} (dicionário vazio)
Conjuntos vazios: set()

Vamos verificar isso com a função bool():

python

# falsy_values.py
# Todos esses valores são falsy
print("Boolean False:", bool(False))     # Output: Boolean False: False
print("None:", bool(None))               # Output: None: False
print("Zero integer:", bool(0))          # Output: Zero integer: False
print("Zero float:", bool(0.0))          # Output: Zero float: False
print("Empty string:", bool(""))         # Output: Empty string: False
print("Empty list:", bool([]))           # Output: Empty list: False
print("Empty tuple:", bool(()))          # Output: Empty tuple: False
print("Empty dict:", bool({}))           # Output: Empty dict: False

7.4.2) Valores Truthy: Todo o Resto

Todo o resto em Python é considerado truthy (comporta-se como True em contextos Booleanos). Isso inclui:

O próprio valor Booleano True
Qualquer número diferente de zero (positivo ou negativo)
Qualquer string, lista, tupla, dicionário ou conjunto não vazio
A maioria dos objetos que você cria

python

# truthy_values.py
# Todos esses valores são truthy
print("Boolean True:", bool(True))           # Output: Boolean True: True
print("Positive integer:", bool(42))         # Output: Positive integer: True
print("Negative integer:", bool(-1))         # Output: Negative integer: True
print("Non-zero float:", bool(3.14))         # Output: Non-zero float: True
print("Non-empty string:", bool("Hello"))    # Output: Non-empty string: True
print("String 'False':", bool("False"))      # Output: String 'False': True
print("String '0':", bool("0"))              # Output: String '0': True
print("Non-empty list:", bool([1, 2, 3]))    # Output: Non-empty list: True
print("Non-empty tuple:", bool((1,)))        # Output: Non-empty tuple: True
print("Non-empty dict:", bool({"a": 1}))     # Output: Non-empty dict: True

Nota importante: A string "False" é truthy porque é uma string não vazia. A string "0" também é truthy pelo mesmo motivo. Somente o valor Booleano real False e o valor numérico 0 são falsy.

7.4.3) Por que Truthiness Importa

Entender truthiness é importante porque é um conceito fundamental em Python que você encontrará com frequência. No Capítulo 8, você aprenderá sobre instruções if que tomam decisões com base em condições. Essas instruções podem usar qualquer valor, não apenas comparações Booleanas explícitas, porque o Python avalia automaticamente a truthiness dos valores.

Truthiness permite escrever código conciso que verifica se coleções contêm itens, se strings têm conteúdo ou se valores opcionais estão presentes. Aqui está uma prévia de como truthiness será útil (vamos aprender a sintaxe completa da instrução if no Capítulo 8):

python

# truthiness_preview.py
# Demonstrando truthiness com bool()
# (No Capítulo 8, vamos usar isso diretamente em instruções if)
 
# Verificando se uma string tem conteúdo
user_input = ""
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: False
 
user_input = "Alice"
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: True
 
# Verificando se uma lista tem itens
shopping_list = []
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: False
 
shopping_list = ["milk", "eggs", "bread"]
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: True
 
# Verificando se um valor existe (não é None)
optional_value = None
value_exists = bool(optional_value)
print("Value exists:", value_exists)  # Output: Value exists: False

Entender truthiness deixa seu código mais "Pythônico" — ele segue as convenções e os idioms do Python. Quando você vê programadores experientes em Python verificando condições sem comparações explícitas, eles estão aproveitando truthiness para escrever código mais limpo e legível.

7.5) Comparações Encadeadas e Armadilhas Comuns com Booleanos

Python oferece um recurso poderoso chamado comparações encadeadas que torna certas condições mais legíveis e mais próximas da notação matemática. Porém, esse recurso e outros aspectos da lógica Booleana também podem levar a erros comuns.

7.5.1) Comparações Encadeadas

Em matemática, você pode escrever "10 < x < 20" para expressar que x está entre 10 e 20. O Python permite que você escreva exatamente da mesma forma:

python

# chained_comparisons.py
# Verificando se um valor está em um intervalo
x = 15
 
# A forma matemática (comparação encadeada)
in_range = 10 < x < 20
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Isso é equivalente a combinar duas comparações
# (Vamos aprender sobre 'and' no Capítulo 9)
in_range = (10 < x) and (x < 20)
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Testando com um valor fora do intervalo
y = 25
in_range = 10 < y < 20
print("y is between 10 and 20:", in_range)  # Output: y is between 10 and 20: False
 
# Testando com valores de borda
z = 10
in_range = 10 < z < 20
print("z is between 10 and 20:", in_range)  # Output: z is between 10 and 20: False
 
# Incluindo as bordas com <= e >=
in_range_inclusive = 10 <= z <= 20
print("z is between 10 and 20 (inclusive):", in_range_inclusive)  # Output: z is between 10 and 20 (inclusive): True

Comparações encadeadas funcionam avaliando cada par de itens adjacentes. A expressão 10 < x < 20 é avaliada como (10 < x) and (x < 20). Todas as comparações precisam ser verdadeiras para que toda a cadeia seja verdadeira.

Você pode encadear mais de duas comparações:

python

# multiple_chains.py
# Encadeando múltiplas comparações
a = 5
b = 10
c = 15
d = 20
 
# Verificando se os valores estão em ordem crescente
ascending = a < b < c < d
print("Values are in ascending order:", ascending)  # Output: Values are in ascending order: True

Aqui está uma representação visual de como comparações encadeadas funcionam:

7.5.2) Armadilha Comum: Atribuição vs Comparação

Um dos erros mais comuns que iniciantes cometem é usar atribuição (=) quando querem comparação (==):

python

# assignment_vs_comparison_pitfall.py
x = 10
 
# Isto é atribuição, não comparação
# Isso atribui 20 a x, não compara x com 20
# x = 20  # Isso mudaria x para 20
 
# Isto é comparação
result = (x == 20)  # Isso verifica se x é igual a 20
print("x equals 20:", result)  # Output: x equals 20: False
print("x is now:", x)  # Output: x is now: 10
 
# No Capítulo 8, você vai aprender que usar = em condições causa um erro
# if x = 20:  # SyntaxError: invalid syntax
#     print("This won't work")
 
# A comparação correta
# No Capítulo 8, você escreverá: if x == 10:
result = x == 10
print("x equals 10:", result)  # Output: x equals 10: True

O Python ajuda a evitar esse erro em instruções if (que você aprenderá no Capítulo 8) gerando um SyntaxError se você usar atribuição em vez de comparação. Porém, em outros contextos, usar = quando você queria == pode criar bugs sutis que são difíceis de encontrar.

7.5.3) Armadilha Comum: Comparações com Ponto Flutuante

Ao comparar números de ponto flutuante, você precisa estar atento a questões de precisão:

python

# floating_point_comparison.py
# Aritmética de ponto flutuante pode ter problemas de precisão
result = 0.1 + 0.2
print("0.1 + 0.2 =", result)  # Output: 0.1 + 0.2 = 0.30000000000000004
 
# Comparação direta pode não funcionar como esperado
is_equal = (result == 0.3)
print("Result equals 0.3:", is_equal)  # Output: Result equals 0.3: False
 
# O valor real é bem próximo, mas não exatamente 0.3
print("Difference:", result - 0.3)  # Output: Difference: 5.551115123125783e-17
 
# Para comparações com ponto flutuante, use uma pequena tolerância
tolerance = 0.0001
is_close = abs(result - 0.3) < tolerance
print("Result is close to 0.3:", is_close)  # Output: Result is close to 0.3: True
 
# Python 3.5+ fornece math.isclose() para isso
# Vamos aprender sobre importação de módulos no Capítulo 23
# import math
# is_close = math.isclose(result, 0.3)

Esse problema surge porque computadores armazenam números de ponto flutuante em binário, e alguns números decimais (como 0.1) não podem ser representados exatamente em binário. Quando você faz operações com esses números, pequenos erros de arredondamento se acumulam. Para a maioria dos propósitos práticos, esses erros são desprezíveis, mas podem fazer comparações de igualdade direta falharem de forma inesperada.

7.6) Booleanos como Inteiros (1 e 0) e Por que Evitar Aritmética

Aqui vai um fato surpreendente: em Python, True e False são na verdade casos especiais de inteiros. True é equivalente a 1, e False é equivalente a 0. Isso é um artefato histórico do design do Python, mas tem algumas implicações interessantes. Entender essa relação ajuda a evitar confusão, mas você raramente deve usá-la diretamente no seu código.

7.6.1) Booleanos São Inteiros

Você pode verificar que Booleanos são inteiros checando seu tipo e fazendo operações inteiras:

python

# booleans_as_integers.py
# Booleanos são um subtipo de inteiros
print(isinstance(True, int))   # Output: True
print(isinstance(False, int))  # Output: True
 
# True é igual a 1, False é igual a 0
print(True == 1)    # Output: True
print(False == 0)   # Output: True
print(True == 2)    # Output: False
 
# Você pode usar Booleanos em operações aritméticas (mas não deveria!)
result = True + True
print("True + True =", result)  # Output: True + True = 2
 
result = True + False
print("True + False =", result)  # Output: True + False = 1
 
result = False * 100
print("False * 100 =", result)  # Output: False * 100 = 0
 
# Booleanos podem ser usados como índices de lista
items = ["first", "second", "third"]
print(items[False])  # Output: first
print(items[True])   # Output: second

A função isinstance() verifica se um valor é uma instância de um tipo. Quando verificamos isinstance(True, int), o Python retorna True porque o tipo bool é uma subclasse do tipo int.

7.6.2) Por que Evitar Aritmética com Booleanos

Mesmo que o Python permita usar Booleanos em operações aritméticas, você deve evitar fazer isso. Usar Booleanos como números torna seu código confuso e mais difícil de entender. A relação entre Booleanos e inteiros é principalmente um detalhe histórico que você deve conhecer, mas raramente usar diretamente.

Veja por que a aritmética com Booleanos é problemática:

python

# boolean_arithmetic_problems.py
# Exemplo de código confuso
count = 0
has_error = True
has_warning = False
 
# Isso funciona, mas é confuso
total = count + has_error + has_warning
print("Total:", total)  # Output: Total: 1
 
# O que isso significa? Não é claro!
# Abordagem melhor: ser explícito
# Vamos aprender sobre a expressão if-else no Capítulo 10.
error_count = 1 if has_error else 0
warning_count = 1 if has_warning else 0
total = count + error_count + warning_count
print("Total:", total)  # Output: Total: 1

A única exceção comum a essa regra é ao contar valores True em uma coleção:

python

# counting_trues.py
# Contando quantas condições são true
conditions = [True, False, True, True, False]
 
# Isso é aceitável porque a intenção é clara
true_count = sum(conditions)
print("Number of true conditions:", true_count)  # Output: Number of true conditions: 3
 
# Isso funciona porque sum() soma os valores
# True é tratado como 1, False como 0
# Então sum([True, False, True, True, False]) = 1 + 0 + 1 + 1 + 0 = 3

Nesse caso, usar sum() em uma lista de Booleanos é um idiom comum em Python e amplamente entendido. A intenção — contar quantas condições são verdadeiras — fica clara pelo contexto.

7.6.3) Booleanos em Conversão de Tipos

Como Booleanos são inteiros, convertê-los para inteiros explicitamente é redundante:

python

# boolean_conversion.py
# Convertendo Booleanos para inteiros (desnecessário)
value = True
int_value = int(value)
print("Integer value:", int_value)  # Output: Integer value: 1
print("Are they equal?", value == int_value)  # Output: Are they equal? True
 
# Mas converter inteiros para Booleanos é útil
number = 0
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: False
 
number = 42
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: True

Converter um Booleano para inteiro com int() é desnecessário porque Booleanos já se comportam como inteiros. Porém, converter inteiros (ou outros tipos) para Booleanos com bool() é útil quando você quer verificar explicitamente a truthiness.

7.6.4) A Razão Histórica

A razão pela qual Booleanos são inteiros em Python é histórica. Versões antigas do Python (antes da versão 2.3) não tinham um tipo Booleano separado. Programadores usavam 1 para verdadeiro e 0 para falso. Quando o tipo bool foi adicionado, ele foi feito como uma subclasse de int para manter compatibilidade com código existente.

Hoje, você deve pensar em True e False como valores Booleanos antes de tudo. A relação deles com 1 e 0 é um detalhe de implementação com o qual você raramente precisa se preocupar, exceto quando encontrá-lo em lugares inesperados.

7.7) Usando in e not in em Condições

Os operadores in e not in testam pertencimento — se um valor existe dentro de uma coleção. Esses operadores são extremamente úteis para criar condições legíveis, especialmente ao trabalhar com strings, listas e outras coleções.

7.7.1) Testando Pertencimento em Strings

O operador in verifica se uma string aparece dentro de outra string:

python

# string_membership.py
# Verificando se uma substring existe em uma string
text = "Python programming is fun"
 
# Usando 'in' para verificar substrings
has_python = "Python" in text
print("Contains 'Python':", has_python)  # Output: Contains 'Python': True
 
has_java = "Java" in text
print("Contains 'Java':", has_java)  # Output: Contains 'Java': False
 
# Verificação diferencia maiúsculas de minúsculas
has_python_lower = "python" in text
print("Contains 'python':", has_python_lower)  # Output: Contains 'python': False
 
# Usando 'not in' para verificar ausência
has_no_java = "Java" not in text
print("Does not contain 'Java':", has_no_java)  # Output: Does not contain 'Java': True

O operador in faz uma busca que diferencia maiúsculas de minúsculas. Se você precisar de busca sem diferenciar maiúsculas de minúsculas, pode converter as duas strings para a mesma caixa:

python

# case_insensitive_search.py
text = "Python Programming"
 
# Busca que diferencia maiúsculas de minúsculas (não encontra)
result = "python" in text
print("Contains 'python':", result)  # Output: Contains 'python': False
 
# Busca sem diferenciar maiúsculas de minúsculas (converte ambas para minúsculas)
result = "python" in text.lower()
print("Contains 'python' (case-insensitive):", result)  # Output: Contains 'python' (case-insensitive): True
 
# A string original permanece inalterada
print("Original text:", text)  # Output: Original text: Python Programming

7.7.2) Testando Pertencimento em Listas

O operador in também funciona com listas (que vamos aprender em detalhes no Capítulo 14):

python

# list_membership.py
# Verificando se um valor existe em uma lista
numbers = [1, 2, 3, 4, 5]
 
has_three = 3 in numbers
print("List contains 3:", has_three)  # Output: List contains 3: True
 
has_ten = 10 in numbers
print("List contains 10:", has_ten)  # Output: List contains 10: False
 
# Usando 'not in'
missing_ten = 10 not in numbers
print("List does not contain 10:", missing_ten)  # Output: List does not contain 10: True
 
# Funciona com strings em listas
fruits = ["apple", "banana", "cherry"]
has_banana = "banana" in fruits
print("List contains 'banana':", has_banana)  # Output: List contains 'banana': True
 
has_grape = "grape" in fruits
print("List contains 'grape':", has_grape)  # Output: List contains 'grape': False

7.7.3) Testando Pertencimento com Ranges

Você também pode usar in com objetos range (que vamos aprender no Capítulo 12):

python

# range_membership.py
# Verificando se um número está em um range
age = 25
 
# Usando 'in' com range
is_adult = age in range(18, 100)
print("Is adult:", is_adult)  # Output: Is adult: True
 
# Porém, operadores de comparação são mais eficientes para intervalos numéricos
is_adult = 18 <= age < 100
print("Is adult:", is_adult)  # Output: Is adult: True
 
# 'in' com range é útil para sequências específicas
valid_ages = range(18, 66)  # Faixa de idade ativa de trabalho
is_working_age = age in valid_ages
print("Is working age:", is_working_age)  # Output: Is working age: True

7.7.4) O Operador not in

O operador not in é o oposto de in — ele retorna True se o valor NÃO for encontrado na coleção:

python

# not_in_operator.py
# Usando 'not in' para uma lógica mais clara
allowed_users = ["alice", "bob", "charlie"]
current_user = "eve"
 
# Usar 'not in' é mais legível
is_unauthorized = current_user not in allowed_users
print("User is unauthorized:", is_unauthorized)  # Output: User is unauthorized: True
 
# Verificando campos obrigatórios ausentes
provided_fields = ["name", "email"]
 
# Encontrando campos faltando
missing_name = "name" not in provided_fields
missing_email = "email" not in provided_fields
missing_password = "password" not in provided_fields
 
print("Missing name:", missing_name)      # Output: Missing name: False
print("Missing email:", missing_email)    # Output: Missing email: False
print("Missing password:", missing_password)  # Output: Missing password: True

Os operadores in e not in deixam suas condições mais legíveis e expressivas. Em vez de escrever comparações complexas, você pode expressar diretamente "este valor está nesta coleção?", o que combina com a forma como você pensa sobre o problema.

Neste capítulo, você aprendeu os fundamentos de valores Booleanos e condições em Python. Agora você entende:

Os valores Booleanos True e False e seu papel na tomada de decisão
Operadores de comparação (==, !=, <, >, <=, >=) para criar condições
A função bool() para converter valores em Booleanos
Truthiness e falsiness — como o Python trata todos os valores como verdadeiros ou falsos
Comparações encadeadas para verificações de intervalo legíveis
Armadilhas comuns a evitar ao trabalhar com Booleanos
A relação entre Booleanos e inteiros (e por que evitar aritmética com Booleanos)
Teste de pertencimento com os operadores in e not in

Esses conceitos formam a base para as estruturas de controle de fluxo que você aprenderá nos próximos capítulos. No Capítulo 8, você usará expressões Booleanas em instruções if para fazer seus programas responderem a diferentes condições. No Capítulo 9, você aprenderá a combinar múltiplas condições usando operadores lógicos como and, or e not. E nos Capítulos 10 e 11, você usará condições para controlar loops que repetem ações.

Entender Booleanos e condições é essencial para escrever programas que conseguem tomar decisões, validar entrada e responder adequadamente a diferentes situações. Pratique trabalhar com esses conceitos e você verá que a tomada de decisão em Python se tornará algo natural e intuitivo.