Summary  
This chapter explains how logical operators (`and`, `or`, `not`) combine and invert Boolean expressions, covering their precedence, short-circuit evaluation, and the fact that `and`/`or` can return operand values.  

General domain of usage  
Control flow and conditional decision making

As pessoas dizem **sim e sim**, **sim ou não**, **definitivamente não**. Em Python, os operadores lógicos **`and`**, **`or`** e **`not`** expressam essas ideias formalmente e produzem valores booleanos (`True`/`False`) que você usará com comparações em `if`/`while`.

Watch this video for a clear explanation of logical operators in Python. You'll see how `and`, `or`, and `not` work in real code, how short-circuiting happens, and how to use these operators to control program flow. The video includes practical examples and visualizations to help you master logical expressions and their results.

**generation rule: make video with duration of 120-180 seconds**

Verdadeiro apenas quando **ambos** `X` e `Y` são True.

Verdadeiro quando **pelo menos um** entre `X` e `Y` é True.

Negação: **inverte** True para False e vice-versa.

### Precedência
`not` tem maior precedência que `and`, que por sua vez tem maior precedência que `or` (`not > and > or`). Utilize parênteses em caso de dúvida.

Por exemplo, `age >= 18 and has_id` é `True` apenas se ambas as verificações forem verdadeiras:

age = 21
has_id = True
print(age >= 18 and has_id)   # True

## Tabela-Verdade

Uma **tabela-verdade** lista todos os possíveis valores lógicos das entradas e mostra o resultado de uma expressão lógica. É uma forma compacta de raciocinar sobre lógica sem executar o código.


### Usando a Tabela
Se `X` for `False` e `Y` for `True`, então `X and Y` é `False`, `X or Y` é `True` e `not X` é `True`.


## Valores de Retorno e Curto-Circuito

`and` e `or` nem sempre retornam os valores booleanos `True` ou `False`. Em vez disso, eles retornam **um de seus operandos**, e o Python interrompe a avaliação antecipadamente (curto-circuito) assim que o resultado final é garantido.

* `A and B`:
  * Se `A` for falso, o resultado é garantido como falso, então o Python faz curto-circuito e retorna `A` (sem avaliar `B`).
* Se `A` for verdadeiro, o resultado depende totalmente de `B`, então o Python avalia e retorna `B`.

* `A or B`:
  * Se `A` for verdadeiro, o resultado é garantido como verdadeiro, então o Python faz curto-circuito e retorna `A` (sem avaliar `B`).
* Se `A` for falso, o resultado depende totalmente de `B`, então o Python avalia e retorna `B`.

* `not X` sempre retorna um valor booleano real: `True` ou `False`.

# Choosing a display name for a user profile
username = ""             # user didn't set a custom name
print(username or "Guest")   # "Guest" → fallback to default name

username = "Alice"
print(username or "Guest")   # "Alice" → custom name is used

# Checking login attempts and access permissions
login_attempts = 0
access_level = 123
print(login_attempts and access_level)  # 0 → login not yet attempted

login_attempts = 5
print(login_attempts and access_level)  # 123 → user has access after attempts

# Checking empty and non-empty values
print(not 0, not "Hello")  # True False → 0 is falsey, non-empty string is truthy

Qual afirmação corresponde à lógica clássica para "nem X nem Y"?

Adquira uma compreensão sólida dos principais tipos de dados do Python e aprenda a utilizá-los de forma eficaz. Explore números, booleanos e strings por meio de exercícios práticos e exemplos aplicados. Desenvolva confiança na realização de operações básicas e construa as habilidades fundamentais necessárias para escrever códigos Python limpos e eficientes.

Descubra os conceitos essenciais dos tipos de dados numéricos em Python e aprenda a trabalhar com inteiros e números de ponto flutuante. Domine operações aritméticas básicas, explore o conceito de imutabilidade e obtenha experiência prática utilizando as funções e ferramentas integradas do Python para manipular números de forma eficiente em cenários do mundo real.

Obtenha uma compreensão clara do tipo de dado Booleano, um subtipo especializado de dados numéricos que representa valores de verdade. Embora possa parecer desafiador no início, dominar Booleanos é essencial para escrever programas lógicos e eficientes. Esta seção ajudará você a aplicar com confiança a lógica booleana em cenários de programação do mundo real.

Strings permitem trabalhar com texto em Python, desde exibir mensagens até processar entradas do usuário. Você explorará como criar, modificar e manipular strings de forma eficaz. Compreender strings é fundamental para escrever programas interativos e comunicar informações de maneira clara por meio do código.

Aprenda a lidar com tipos de dados de forma eficaz para garantir precisão e consistência em seus programas. Converta valores para o tipo apropriado, limpe textos antes de comparações e separe operações numéricas da formatação de texto. Descubra também como gerenciar dados ausentes de maneira deliberada e tratar textos legíveis por humanos de forma diferente dos dados brutos, alcançando resultados confiáveis, consistentes e de fácil leitura.

Operadores Lógicos

O que cada operador significa

Precedência

Tabela-Verdade

Usando a Tabela

Valores de Retorno e Curto-Circuito

1. Preencha as lacunas com `True` ou `False`. Considere `X = True`, `Y = False`.

2. Qual afirmação corresponde à lógica clássica para "nem X nem Y"?

3. O que a expressão retorna?