7. Valores booleanos y condiciones

En los capítulos anteriores aprendiste a trabajar con números, cadenas y operaciones básicas con datos. Ahora estamos listos para explorar cómo Python toma decisiones, una capacidad fundamental que permite que los programas respondan de forma diferente según distintas condiciones. En el corazón de la toma de decisiones en Python están los valores booleanos y las condiciones.

Piensa en decisiones cotidianas: "Si está lloviendo, llevaré un paraguas". "Si la temperatura es superior a 30 °C, encenderé el aire acondicionado". Estas decisiones se basan en condiciones que son verdaderas o falsas. Python usa el mismo principio: evalúa condiciones para determinar si son verdaderas o falsas y luego actúa en consecuencia.

En este capítulo exploraremos los valores booleanos, aprenderemos a crear condiciones utilizando operadores de comparación, entenderemos el concepto de "truthiness" de Python y descubriremos técnicas potentes para construir expresiones lógicas complejas. Al final de este capítulo, habrás dominado los bloques de construcción necesarios para las sentencias if y los bucles (loops) que aprenderás en los próximos capítulos.

7.1) Valores booleanos True y False

Python tiene un tipo de datos especial llamado bool (abreviatura de Boolean) que representa valores de verdad. Este tipo tiene exactamente dos valores posibles: True y False. Fíjate en que estos valores empiezan con mayúscula; esto es importante en Python. Escribir true o false en minúsculas provocará un error porque Python no los reconocerá.

python

# boolean_basics.py
# Creación de variables 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'>

Los valores booleanos son fundamentales porque representan el resultado de cualquier pregunta de sí/no que tu programa pueda hacer: ¿Este número es mayor que 10? ¿Esta cadena contiene la letra 'a'? ¿El usuario ha iniciado sesión? Toda condición en Python finalmente se evalúa como True o False.

7.1.1) Booleanos en variables y expresiones

Puedes almacenar valores booleanos en variables igual que almacenas números o cadenas. Esto es útil cuando quieres seguir el estado de algo en tu programa:

python

# boolean_variables.py
# Uso de variables booleanas para seguir 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
 
# Las variables booleanas se pueden reasignar
is_logged_in = True
print("User logged in:", is_logged_in)        # Output: User logged in: True

Las variables booleanas suelen nombrarse con prefijos como is_, has_ o can_ para dejar clara su finalidad. Esta convención de nombres ayuda a que tú y otras personas que lean tu código entiendan inmediatamente que la variable contiene un valor verdadero/falso.

7.2) Operadores de comparación y condiciones básicas

Aunque puedes crear valores booleanos directamente con True y False, la mayoría de los valores booleanos en tus programas surgirán de comparaciones, es decir, de probar relaciones entre valores. Python proporciona varios operadores de comparación que comparan dos valores y producen un resultado booleano.

7.2.1) Los seis operadores de comparación

Python tiene seis operadores de comparación principales:

Operador	Significado	Ejemplo	Resultado
`==`	Igual que	`5 == 5`	`True`
`!=`	Distinto de	`5 != 3`	`True`
`<`	Menor que	`3 < 5`	`True`
`>`	Mayor que	`5 > 3`	`True`
`<=`	Menor o igual que	`5 <= 5`	`True`
`>=`	Mayor o igual que	`5 >= 3`	`True`

Veamos estos operadores en acción:

python

# comparison_operators.py
# Comparación de 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
 
# Comparaciones con valores iguales
a = 15
b = 15
 
print(a == b)   # Output: True
print(a <= b)   # Output: True
print(a >= b)   # Output: True

7.2.2) Comparación de números y cadenas

Los operadores de comparación funcionan con muchos tipos de valores, no solo con enteros:

python

# comparing_types.py
# Comparación de números de punto flotante
temperature = 23.5
print(temperature > 20.0)   # Output: True
print(temperature == 23.5)  # Output: True
 
# Comparación de cadenas (orden alfabético/lexicográfico)
name1 = "Alice"
name2 = "Bob"
print(name1 < name2)   # Output: True
print(name1 == name2)  # Output: False
 
# La comparación de cadenas distingue mayúsculas/minúsculas
word1 = "Python"
word2 = "python"
print(word1 == word2)  # Output: False
 
# Comparación de longitudes de cadenas usando len()
print(len(name1) == len(name2))  # Output: False

Al comparar cadenas, Python utiliza el orden lexicográfico, que es básicamente el orden alfabético basado en los valores Unicode de los caracteres. Las letras mayúsculas van antes que las minúsculas en este orden, por eso "Python" y "python" no son iguales.

7.2.3) Almacenando resultados de comparaciones

El resultado de cualquier comparación es un valor booleano, lo que significa que puedes almacenarlo en una variable:

python

# storing_comparisons.py
# Almacenamiento de resultados de comparaciones para uso posterior
age = 25
is_adult = age >= 18
is_senior = age >= 65
is_teenager = 13 <= age <= 19  # Aprenderemos sobre comparaciones encadenadas pronto
 
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
 
# Uso de comparaciones almacenadas en cálculos u otras expresiones
price = 100
discount_eligible = price > 50
print("Discount eligible:", discount_eligible)  # Output: Discount eligible: True

Almacenar resultados de comparaciones en variables con nombres descriptivos hace que tu código sea más legible. En lugar de escribir repetidamente age >= 18 en todo tu programa, puedes usar la variable is_adult, que comunica claramente qué estás comprobando.

7.3) Booleanos a partir de comparaciones, expresiones y la función bool()

Hemos visto que las comparaciones producen valores booleanos. Pero hay otras formas de obtener valores booleanos en Python, incluyendo el uso de la función bool() para convertir otros tipos a booleanos.

7.3.1) La función bool()

La función bool() convierte cualquier valor a su equivalente booleano. Esto es útil cuando quieres comprobar explícitamente si un valor sería considerado verdadero o falso en un contexto booleano:

python

# bool_function.py
# Conversión de números a 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
 
# Conversión de cadenas a booleanos
print(bool("Hello"))     # Output: True
print(bool("False"))     # Output: True
print(bool(""))          # Output: False
 
# Conversión de None a booleano
print(bool(None))    # Output: False

La función bool() sigue reglas específicas de conversión, que exploraremos en detalle en la siguiente sección sobre truthiness y falsiness. Por ahora, fíjate en que la mayoría de los valores se convierten en True, pero ciertos valores especiales como 0, 0.0, las cadenas vacías ("") y None se convierten en False.

7.4) Truthiness y falsiness en condiciones

Una de las características más potentes de Python es su concepto de truthiness y falsiness. En Python, cada valor, no solo True y False, tiene una interpretación booleana inherente. Esto significa que puedes usar cualquier valor donde se espera un booleano, y Python lo tratará como verdadero o falso.

7.4.1) Valores falsy: qué cuenta como falso

En Python, los siguientes valores se consideran falsy (se comportan como False en contextos booleanos):

El propio valor booleano False
El valor especial None
Ceros numéricos en cualquier forma: 0, 0.0, 0j (cero complejo)
Secuencias vacías: "" (cadena vacía), [] (lista vacía), () (tupla vacía)
Mapeos vacíos: {} (diccionario vacío)
Conjuntos vacíos: set()

Verifiquemos esto con la función bool():

python

# falsy_values.py
# Todos estos valores son 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 lo demás

Todos los demás valores en Python se consideran truthy (se comportan como True en contextos booleanos). Esto incluye:

El propio valor booleano True
Cualquier número distinto de cero (positivo o negativo)
Cualquier cadena, lista, tupla, diccionario o conjunto no vacío
La mayoría de los objetos que crees

python

# truthy_values.py
# Todos estos valores son 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: La cadena "False" es truthy porque es una cadena no vacía. La cadena "0" también es truthy por la misma razón. Solo el valor booleano real False y el valor numérico 0 son falsy.

7.4.3) Por qué importa la truthiness

Entender la truthiness es importante porque es un concepto fundamental en Python con el que te encontrarás con frecuencia. En el Capítulo 8 aprenderás sobre las sentencias if que toman decisiones basadas en condiciones. Estas sentencias pueden usar cualquier valor, no solo comparaciones booleanas explícitas, porque Python evalúa automáticamente la truthiness de los valores.

La truthiness te permite escribir código conciso que comprueba si las colecciones contienen elementos, si las cadenas tienen contenido o si los valores opcionales están presentes. Aquí tienes un adelanto de cómo la truthiness será útil (aprenderemos la sintaxis completa de la sentencia if en el Capítulo 8):

python

# truthiness_preview.py
# Demostración de la truthiness con bool()
# (En el Capítulo 8 usaremos esto directamente en sentencias if)
 
# Comprobación de si una cadena tiene contenido
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
 
# Comprobación de si una lista tiene elementos
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
 
# Comprobación de si un valor existe (no es None)
optional_value = None
value_exists = bool(optional_value)
print("Value exists:", value_exists)  # Output: Value exists: False

Entender la truthiness hace que tu código sea más "pythónico": sigue las convenciones e idioms de Python. Cuando veas que programadores experimentados en Python comprueban condiciones sin comparaciones explícitas, están aprovechando la truthiness para escribir código más limpio y legible.

7.5) Comparaciones encadenadas y errores comunes con booleanos

Python ofrece una característica potente llamada comparaciones encadenadas que hace que ciertas condiciones sean más legibles y más parecidas a la notación matemática. Sin embargo, esta característica y otros aspectos de la lógica booleana también pueden dar lugar a errores comunes.

7.5.1) Comparaciones encadenadas

En matemáticas, podrías escribir "10 < x < 20" para expresar que x está entre 10 y 20. Python te permite escribir esto exactamente de la misma manera:

python

# chained_comparisons.py
# Comprobación de si un valor está en un rango
x = 15
 
# La forma matemática (comparación encadenada)
in_range = 10 < x < 20
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Esto equivale a combinar dos comparaciones
# (Aprenderemos sobre 'and' en el 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
 
# Prueba con un valor fuera del rango
y = 25
in_range = 10 < y < 20
print("y is between 10 and 20:", in_range)  # Output: y is between 10 and 20: False
 
# Prueba con valores en el límite
z = 10
in_range = 10 < z < 20
print("z is between 10 and 20:", in_range)  # Output: z is between 10 and 20: False
 
# Inclusión de los límites con <= y >=
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

Las comparaciones encadenadas funcionan evaluando cada par de elementos adyacentes. La expresión 10 < x < 20 se evalúa como (10 < x) and (x < 20). Todas las comparaciones deben ser verdaderas para que toda la cadena sea verdadera.

Puedes encadenar más de dos comparaciones:

python

# multiple_chains.py
# Encadenamiento de múltiples comparaciones
a = 5
b = 10
c = 15
d = 20
 
# Comprobación de si los valores están en orden ascendente
ascending = a < b < c < d
print("Values are in ascending order:", ascending)  # Output: Values are in ascending order: True

Aquí tienes una representación visual de cómo funcionan las comparaciones encadenadas:

7.5.2) Error común: asignación vs comparación

Uno de los errores más comunes que cometen las personas que empiezan es usar asignación (=) cuando quieren comparación (==):

python

# assignment_vs_comparison_pitfall.py
x = 10
 
# Esto es asignación, no comparación
# Asigna 20 a x, no compara x con 20
# x = 20  # Esto cambiaría x a 20
 
# Esto es comparación
result = (x == 20)  # Esto comprueba si x es igual a 20
print("x equals 20:", result)  # Output: x equals 20: False
print("x is now:", x)  # Output: x is now: 10
 
# En el Capítulo 8 aprenderás que usar = en condiciones provoca un error
# if x = 20:  # SyntaxError: invalid syntax
#     print("This won't work")
 
# La comparación correcta
# En el Capítulo 8 escribirás: if x == 10:
result = x == 10
print("x equals 10:", result)  # Output: x equals 10: True

Python ayuda a prevenir este error en las sentencias if (que aprenderás en el Capítulo 8) lanzando un SyntaxError si usas asignación en lugar de comparación. Sin embargo, en otros contextos, usar = cuando querías == puede crear errores sutiles que son difíciles de encontrar.

7.5.3) Error común: comparaciones con números de punto flotante

Al comparar números de punto flotante, debes tener en cuenta los problemas de precisión:

python

# floating_point_comparison.py
# La aritmética de punto flotante puede tener problemas de precisión
result = 0.1 + 0.2
print("0.1 + 0.2 =", result)  # Output: 0.1 + 0.2 = 0.30000000000000004
 
# La comparación directa puede no funcionar como esperas
is_equal = (result == 0.3)
print("Result equals 0.3:", is_equal)  # Output: Result equals 0.3: False
 
# El valor real es muy cercano pero no exactamente 0.3
print("Difference:", result - 0.3)  # Output: Difference: 5.551115123125783e-17
 
# Para comparaciones de punto flotante, usa una pequeña tolerancia
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+ proporciona math.isclose() para esto
# Aprenderemos sobre la importación de módulos en el Capítulo 23
# import math
# is_close = math.isclose(result, 0.3)

Este problema surge porque los ordenadores almacenan números de punto flotante en binario, y algunos números decimales (como 0.1) no se pueden representar exactamente en binario. Cuando realizas operaciones con estos números, se acumulan pequeños errores de redondeo. Para la mayoría de los propósitos prácticos, estos errores son insignificantes, pero pueden hacer que las comparaciones de igualdad directas fallen de forma inesperada.

7.6) Booleanos como enteros (1 y 0) y por qué deberías evitar la aritmética

Aquí tienes un hecho sorprendente: en Python, True y False son en realidad casos especiales de enteros. True es equivalente a 1, y False es equivalente a 0. Esto es un vestigio histórico del diseño de Python, pero tiene implicaciones interesantes. Entender esta relación te ayuda a evitar confusiones, pero rara vez deberías usarla directamente en tu código.

7.6.1) Los booleanos son enteros

Puedes verificar que los booleanos son enteros comprobando su tipo y realizando operaciones de enteros:

python

# booleans_as_integers.py
# Los booleanos son un subtipo de los enteros
print(isinstance(True, int))   # Output: True
print(isinstance(False, int))  # Output: True
 
# True es igual a 1, False es igual a 0
print(True == 1)    # Output: True
print(False == 0)   # Output: True
print(True == 2)    # Output: False
 
# Puedes usar booleanos en aritmética (¡pero no deberías!)
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
 
# Los booleanos se pueden usar como índices de listas
items = ["first", "second", "third"]
print(items[False])  # Output: first
print(items[True])   # Output: second

La función isinstance() comprueba si un valor es una instancia de un tipo. Cuando comprobamos isinstance(True, int), Python devuelve True porque el tipo bool es una subclase del tipo int.

7.6.2) Por qué deberías evitar la aritmética con booleanos

Aunque Python te permite usar booleanos en aritmética, deberías evitar hacerlo. Usar booleanos como números hace que tu código sea confuso y más difícil de entender. La relación entre booleanos y enteros es sobre todo un detalle histórico del que deberías estar al tanto, pero que rara vez deberías usar directamente.

Aquí tienes por qué la aritmética con booleanos es problemática:

python

# boolean_arithmetic_problems.py
# Ejemplo de código confuso
count = 0
has_error = True
has_warning = False
 
# Esto funciona, pero es confuso
total = count + has_error + has_warning
print("Total:", total)  # Output: Total: 1
 
# ¿Qué significa esto? ¡No está claro!
# Enfoque mejor: ser explícito
# Aprenderemos sobre la expresión if-else en el 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

La única excepción común a esta regla es cuando se cuentan valores True en una colección:

python

# counting_trues.py
# Conteo de cuántas condiciones son true
conditions = [True, False, True, True, False]
 
# Esto es aceptable porque la intención es clara
true_count = sum(conditions)
print("Number of true conditions:", true_count)  # Output: Number of true conditions: 3
 
# Esto funciona porque sum() suma los valores
# True se trata como 1, False como 0
# Así que sum([True, False, True, True, False]) = 1 + 0 + 1 + 1 + 0 = 3

En este caso, usar sum() sobre una lista de booleanos es un idiom común de Python que es ampliamente entendido. La intención —contar cuántas condiciones son verdaderas— es clara por el contexto.

7.6.3) Booleanos en la conversión de tipos

Como los booleanos son enteros, convertirlos explícitamente a enteros es redundante:

python

# boolean_conversion.py
# Conversión de booleanos a enteros (innecesaria)
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
 
# Pero convertir enteros a booleanos es ú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

Convertir un booleano a entero con int() es innecesario porque los booleanos ya se comportan como enteros. Sin embargo, convertir enteros (u otros tipos) a booleanos con bool() es útil cuando quieres comprobar explícitamente la truthiness.

7.6.4) La razón histórica

La razón por la que los booleanos son enteros en Python es histórica. Las primeras versiones de Python (antes de la versión 2.3) no tenían un tipo booleano separado. Las personas programadoras usaban 1 para verdadero y 0 para falso. Cuando se añadió el tipo bool, se hizo una subclase de int para mantener la compatibilidad con el código existente.

Hoy en día, deberías pensar en True y False ante todo como valores booleanos. Su relación con 1 y 0 es un detalle de implementación del que rara vez necesitas preocuparte, salvo cuando te lo encuentras en lugares inesperados.

7.7) Uso de in y not in en condiciones

Los operadores in y not in comprueban pertenencia, es decir, si un valor existe dentro de una colección. Estos operadores son increíblemente útiles para crear condiciones legibles, especialmente cuando trabajas con cadenas, listas y otras colecciones.

7.7.1) Comprobación de pertenencia en cadenas

El operador in comprueba si una cadena aparece dentro de otra cadena:

python

# string_membership.py
# Comprobación de si una subcadena existe en una cadena
text = "Python programming is fun"
 
# Uso de 'in' para comprobar subcadenas
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
 
# Coincidencia que distingue mayúsculas/minúsculas
has_python_lower = "python" in text
print("Contains 'python':", has_python_lower)  # Output: Contains 'python': False
 
# Uso de 'not in' para comprobar ausencia
has_no_java = "Java" not in text
print("Does not contain 'Java':", has_no_java)  # Output: Does not contain 'Java': True

El operador in realiza una búsqueda que distingue mayúsculas y minúsculas. Si necesitas una búsqueda que no distinga mayúsculas/minúsculas, puedes convertir ambas cadenas al mismo caso:

python

# case_insensitive_search.py
text = "Python Programming"
 
# Búsqueda que distingue mayúsculas/minúsculas (no coincide)
result = "python" in text
print("Contains 'python':", result)  # Output: Contains 'python': False
 
# Búsqueda sin distinción de mayúsculas/minúsculas (convierte ambas a minúsculas)
result = "python" in text.lower()
print("Contains 'python' (case-insensitive):", result)  # Output: Contains 'python' (case-insensitive): True
 
# La cadena original no cambia
print("Original text:", text)  # Output: Original text: Python Programming

7.7.2) Comprobación de pertenencia en listas

El operador in también funciona con listas (que aprenderemos en detalle en el Capítulo 14):

python

# list_membership.py
# Comprobación de si un valor existe en una 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
 
# Uso de 'not in'
missing_ten = 10 not in numbers
print("List does not contain 10:", missing_ten)  # Output: List does not contain 10: True
 
# Funciona con cadenas en 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) Comprobación de pertenencia con ranges

También puedes usar in con objetos range (que estudiaremos en el Capítulo 12):

python

# range_membership.py
# Comprobación de si un número está en un range
age = 25
 
# Uso de 'in' con range
is_adult = age in range(18, 100)
print("Is adult:", is_adult)  # Output: Is adult: True
 
# Sin embargo, los operadores de comparación son más eficientes para rangos numéricos
is_adult = 18 <= age < 100
print("Is adult:", is_adult)  # Output: Is adult: True
 
# 'in' con range es útil para secuencias específicas
valid_ages = range(18, 66)  # Rango de edad laboral
is_working_age = age in valid_ages
print("Is working age:", is_working_age)  # Output: Is working age: True

7.7.4) El operador not in

El operador not in es lo opuesto a in: devuelve True si el valor NO se encuentra en la colección:

python

# not_in_operator.py
# Uso de 'not in' para una lógica más clara
allowed_users = ["alice", "bob", "charlie"]
current_user = "eve"
 
# Usar 'not in' es más legible
is_unauthorized = current_user not in allowed_users
print("User is unauthorized:", is_unauthorized)  # Output: User is unauthorized: True
 
# Comprobación de campos requeridos que faltan
provided_fields = ["name", "email"]
 
# Búsqueda de campos que faltan
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

Los operadores in y not in hacen que tus condiciones sean más legibles y expresivas. En lugar de escribir comparaciones complejas, puedes expresar directamente "¿está este valor en esta colección?", lo cual encaja con la forma en que piensas sobre el problema.

En este capítulo has aprendido los fundamentos de los valores booleanos y las condiciones en Python. Ahora entiendes:

Los valores booleanos True y False y su papel en la toma de decisiones
Los operadores de comparación (==, !=, <, >, <=, >=) para crear condiciones
La función bool() para convertir valores a booleanos
La truthiness y la falsiness: cómo Python trata todos los valores como verdaderos o falsos
Las comparaciones encadenadas para comprobaciones de rangos legibles
Los errores comunes que debes evitar al trabajar con booleanos
La relación entre los booleanos y los enteros (y por qué evitar la aritmética con booleanos)
La comprobación de pertenencia con los operadores in y not in

Estos conceptos forman la base de las estructuras de control de flujo que aprenderás en los próximos capítulos. En el Capítulo 8 usarás expresiones booleanas en sentencias if para hacer que tus programas respondan a distintas condiciones. En el Capítulo 9 aprenderás a combinar múltiples condiciones usando operadores lógicos como and, or y not. Y en los Capítulos 10 y 11 usarás condiciones para controlar bucles que repiten acciones.

Entender los booleanos y las condiciones es esencial para escribir programas que puedan tomar decisiones, validar entradas y responder adecuadamente a distintas situaciones. Practica con estos conceptos y verás que la toma de decisiones en Python se vuelve natural e intuitiva.