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

La gente dice **sí y sí**, **sí o no**, **definitivamente no**. En Python, los operadores lógicos **`and`**, **`or`** y **`not`** expresan estas ideas de forma formal y producen valores booleanos (`True`/`False`) que se utilizan con comparaciones en `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**

Verdadero solo cuando **ambos** `X` y `Y` son True.

Verdadero cuando **al menos uno** de `X`, `Y` es True.

Negación: **invierte** True a False y viceversa.

### Precedencia
`not` tiene mayor prioridad que `and`, que a su vez tiene mayor prioridad que `or` (`not > and > or`). Utiliza paréntesis en caso de duda.

Por ejemplo, `age >= 18 and has_id` es `True` solo si ambas condiciones se cumplen:

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

## Tabla de verdad

Una **tabla de verdad** enumera todos los posibles valores de verdad de las entradas y muestra el resultado de una expresión lógica. Es una forma compacta de razonar sobre la lógica sin ejecutar código.


### Uso de la tabla
Si `X` es `False` y `Y` es `True`, entonces `X and Y` es `False`, `X or Y` es `True` y `not X` es `True`.


## Valores de retorno y cortocircuito

`and` y `or` no siempre devuelven los valores booleanos `True` o `False`. En su lugar, retornan **uno de sus operandos**, y Python detiene la evaluación anticipadamente (cortocircuita) en el momento en que el resultado final está garantizado.

* `A and B`:
* Si `A` es falso, el resultado está garantizado como falso, por lo que Python cortocircuita y devuelve `A` (sin evaluar `B`).
* Si `A` es verdadero, el resultado depende completamente de `B`, así que Python evalúa y devuelve `B`.

* `A or B`:
* Si `A` es verdadero, el resultado está garantizado como verdadero, por lo que Python cortocircuita y devuelve `A` (sin evaluar `B`).
* Si `A` es falso, el resultado depende completamente de `B`, así que Python evalúa y devuelve `B`.

* `not X` siempre devuelve un valor booleano real: `True` o `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

¿Qué enunciado corresponde a la lógica clásica para "ni X ni Y"?

Adquiera una comprensión sólida de los tipos de datos fundamentales de Python y aprenda a trabajar con ellos de manera eficaz. Explore números, booleanos y cadenas mediante ejercicios prácticos y ejemplos aplicados. Desarrolle confianza al realizar operaciones básicas y obtenga las habilidades fundamentales necesarias para escribir código Python limpio y eficiente.

Descubra los aspectos esenciales de los tipos de datos numéricos en Python y aprenda a trabajar con enteros y números de punto flotante. Domine las operaciones aritméticas básicas, explore el concepto de inmutabilidad y adquiera experiencia práctica utilizando las funciones y herramientas integradas de Python para manejar números de manera eficiente en escenarios del mundo real.

Adquiera una comprensión clara del tipo de dato Booleano, un subtipo especializado de datos numéricos que representa valores de verdad. Aunque puede parecer desafiante al principio, dominar los Booleanos es esencial para escribir programas lógicos y eficientes. Esta sección le ayudará a aplicar con confianza la lógica booleana en escenarios de programación del mundo real.

Las cadenas permiten trabajar con texto en Python, desde mostrar mensajes hasta procesar la entrada del usuario. Explorarás cómo crear, modificar y manipular cadenas de manera efectiva. Comprender las cadenas es fundamental para escribir programas interactivos y comunicar información de manera clara a través del código.

Aprenda a manejar los tipos de datos de manera efectiva para garantizar la precisión y coherencia en sus programas. Convierta valores al tipo adecuado, limpie el texto antes de la comparación y separe las operaciones numéricas del formato de texto. También descubrirá cómo gestionar datos faltantes de forma deliberada y tratar el texto legible para humanos de manera diferente al dato sin procesar, logrando resultados fiables, coherentes y fáciles de leer.

Operadores Lógicos

Qué significa cada operador

Precedencia

Tabla de verdad

Uso de la tabla

Valores de retorno y cortocircuito

1. Rellena los espacios con `True` o `False`. Sea `X = True`, `Y = False`.

2. ¿Qué enunciado corresponde a la lógica clásica para "ni X ni Y"?

3. ¿Qué devuelve la expresión?