Comprender los Booleanos en Python

Un boolean es un tipo de dato con exactamente dos valores posibles: True o False. Los booleanos de Python controlan cada decisión que toma tu código — desde sentencias if hasta bucles while y comprensiones de listas. Este capítulo explica cómo funcionan los booleanos, cómo Python evalúa cualquier valor como truthy o falsy, y patrones prácticos que usarás todos los días.

¿Qué son los booleanos en Python?

En Python, True y False son palabras clave (con mayúscula inicial). Pertenecen al tipo integrado bool, que es una subclase de int. Esto significa que True se comporta como 1 y False como 0 en 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)

La última línea — True + True igual a 2 — sorprende a muchos principiantes. Es Python válido y ocasionalmente útil (por ejemplo, contar cuántas condiciones en una lista son verdaderas), pero usar booleanos en aritmética debe ser intencional y estar claramente comentado.

Crear variables booleanas

Puedes asignar True o False directamente a una variable:

Python define boolean variable

Por convención, los nombres de variables booleanas suelen comenzar con is_, has_, can_ o should_ para que su propósito quede claro de un vistazo.

Booleanos a partir de operadores de comparación

Cada operador de comparación produce un resultado boolean:

Python compare two integers

Puedes almacenar los resultados de comparación en una variable y reutilizarlos, lo que mantiene las condiciones if complejas legibles.

Usar booleanos en sentencias condicionales

Los booleanos son el motor detrás de las decisiones if/else. Python evalúa la expresión después de if y ejecuta el bloque indentado solo cuando el resultado es True:

Python compare two integers and print the result

También puedes usar una variable boolean directamente sin ningún operador de comparación:

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

Usar if is_raining: es más Pythónico que if is_raining == True:. Esto último no aporta información y se considera un mal hábito de código.

Valores truthy y falsy

Python no requiere un valor True o False real en un contexto boolean. Cada objeto es o bien truthy (tratado como True) o bien falsy (tratado como False). Esto te permite escribir condiciones concisas sin comparaciones explícitas.

Valores falsy

Los siguientes valores son siempre falsy en Python:

Todo lo demás es truthy — incluidos números distintos de cero, strings no vacíos y colecciones no vacías.

# 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 en la práctica

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")

Este patrón — comprobar una colección directamente en lugar de len(items) > 0 — es Python idiomático.

Convertir valores a boolean con bool()

La función integrada bool() convierte cualquier valor a su equivalente boolean, lo que resulta útil cuando quieres inspeccionar si algo es truthy o falsy:

Python casting into boolean

Más ejemplos:

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

Ten en cuenta que bool([0]) es True aunque el único elemento interior sea falsy. Python comprueba si el contenedor está vacío, no los valores que contiene.

Operadores lógicos con booleanos

Python proporciona tres operadores lógicos para combinar expresiones booleanas. Consulta Python Operators para ver la referencia completa de operadores.

and

Devuelve True solo si ambos operandos son verdaderos:

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

or

Devuelve True si al menos uno de los operandos es verdadero:

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

not

Invierte el 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)

Evaluación en cortocircuito

Python evalúa and y or de forma perezosa — se detiene en cuanto el resultado está determinado. Esto se llama evaluación en cortocircuito:

• False and <anything> — Python nunca evalúa el lado derecho porque el resultado ya es False.
• True or <anything> — Python nunca evalúa el lado derecho porque el resultado ya es True.

Esto importa cuando el lado derecho tiene efectos secundarios o podría lanzar un error:

items = []

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

Sin el cortocircuito, items[0] sobre una lista vacía lanzaría un IndexError. Dado que items es falsy (lista vacía), Python omite el lado derecho por completo.

El operador is frente a == con booleanos

== comprueba si dos valores son iguales. is comprueba si dos nombres se refieren al mismo objeto en memoria.

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

Usa siempre == (o confía en la truthiness) cuando compares valores. Reserva is para comprobaciones de identidad — más comúnmente is None:

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

Usar == None funciona, pero is None es la forma idiomática y ligeramente más rápida.

Contar con booleanos

Dado que True == 1 y False == 0, puedes usar sum() para contar cuántos elementos de una lista cumplen una condición:

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

Esto es más conciso que un bucle contador manual y es un modismo habitual en Python.

Errores comunes

1. Comparar explícitamente con True/False

# Avoid
if is_valid == True:
    ...

# Prefer
if is_valid:
    ...

2. Confundir = (asignación) con == (igualdad)

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

3. Asumir que una lista vacía dentro de una lista es falsy

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

La lista exterior tiene un elemento (la lista interior vacía), por lo que outer en sí misma es truthy. Solo la lista interior outer[0] es falsy.

Resumen

• Los booleanos en Python son True y False — siempre con mayúscula inicial.
• Cada valor en Python es o truthy o falsy. Los valores falsy incluyen 0, "", [], {}, () y None.
• Usa bool() para convertir explícitamente un valor a su equivalente boolean.
• Combina condiciones con and, or y not. Python los evalúa de forma perezosa mediante reglas de cortocircuito.
• Usa is None (no == None) cuando compruebes si algo es None.
• Dado que bool es una subclase de int, True + True es igual a 2 — útil para contar.

A continuación, aprende sobre Python Operators para ver cómo los operadores de comparación y lógicos producen los valores booleanos tratados aquí. También puedes explorar cómo los booleanos dirigen el flujo del programa en Python If...Else.

Práctica