Condiciones y lógica booleana en Python

Una comparación plantea una pregunta sobre valores. Su resultado es un valor booleano: True o False. Son valores del tipo bool, escritos con la primera letra en mayúscula y sin comillas. "True" es texto; true, en minúsculas, es un nombre y provoca un NameError cuando no se ha definido.

Elige el operador que corresponda a la regla

Los operadores de dos caracteres se escriben juntos, con = al final. Escribe <=, no =<. Un número entero y uno de coma flotante pueden resultar iguales al compararlos: 7 == 7.0 da True porque sus valores numéricos coinciden.

Una comparación es una expresión, así que puedes mostrar su resultado o almacenarlo:

x = 7
is_big = x > 5
print(is_big)

Python evalúa x > 5, obtiene True y asigna ese valor a is_big. La salida es True. Un nombre como is_big o has_ticket hace que una variable booleana se lea como una pregunta de sí o no.

Distingue la asignación de la comparación

x = 5 almacena un nuevo valor en x. x == 5 comprueba el valor actual sin cambiarlo. Escribir if x = 5: es un error de sintaxis. El error inverso puede ser más difícil de detectar:

x = 7
x == 5
print(x)

En un archivo de programa, el resultado de la comparación no se utiliza. La salida sigue siendo 7; esa línea intermedia nunca asigna 5.

Resuelve las operaciones aritméticas antes de comparar

En 2 + 3 > 4, Python suma primero para obtener 5 y después compara 5 > 4. El resultado es True. Una comprobación útil para números enteros es n % 2 == 0: % da el resto de la división, y los números pares dejan un resto de 0 al dividirlos entre 2.

Para n = 10, los pasos son 10 % 2 y después 0 == 0, que da True. Para n = -7, -7 % 2 es 1, así que la comprobación de paridad es False. Con el divisor positivo 2, el resto de Python para un entero impar es 1, incluso si el entero impar es negativo.

Decide si se incluye el límite

«Al menos 18» incluye el 18: age >= 18. «Más de 18» lo excluye: age > 18. Del mismo modo, «menos de 13» es age < 13 y «como máximo 3» es bags <= 3. Prueba el propio límite al elegir un operador. Con age = 18, la primera comprobación de edad es verdadera y la segunda es falsa.

Ten en cuenta las pequeñas diferencias de coma flotante

Muchas fracciones decimales solo tienen representaciones binarias aproximadas. Python almacena 0.1 + 0.2 como 0.30000000000000004, así que 0.1 + 0.2 == 0.3 es False.

Para una comparación con una tolerancia absoluta de 1e-9, usa:

print(abs((0.1 + 0.2) - 0.3) < 1e-9)

abs() da la magnitud de la diferencia sin su signo. Esa diferencia es menor que una milmillonésima, así que esta comprobación muestra True. La tolerancia indica cuánta diferencia acepta esta comprobación; no es una igualdad exacta.

Los valores de ambos lados de una comparación importan tanto como el operador. Un texto puede parecer un número y seguir obedeciendo las reglas de las cadenas.

Compara texto de forma exacta

La igualdad de cadenas comprueba cada carácter, incluidas las mayúsculas, las minúsculas y los espacios. "yes" == "Yes" es False, y "yes" == "yes " también es False. Para aceptar diferencias habituales de mayúsculas y minúsculas y espacios alrededor, compara una copia limpia:

answer = " Yes "
print(answer.strip().lower() == "yes")

strip() elimina los caracteres de espacio en blanco de ambos extremos. lower() convierte las letras a minúsculas. El texto limpio es "yes", así que el resultado es True. El valor almacenado en answer no cambia, salvo que le asignes el valor limpio.

Comprende el orden de las cadenas

Python compara cadenas de izquierda a derecha mediante puntos de código Unicode, los números asignados a los caracteres. Se detiene en el primer par de caracteres distintos. Con letras inglesas sin acentos, todas en mayúsculas o todas en minúsculas, esto sigue el orden alfabético: "apple" < "banana" es True. Cuando una cadena es el inicio de la otra, la más corta va primero: "cat" < "catalog" es True.

Esto no es una regla completa de ordenación de diccionario. De A a Z, los puntos de código son 65–90, y de a a z son 97–122. Por tanto, "Zebra" < "apple" es True. La é acentuada también va después de z, así que "zebra" < "éclair" es True.

Los dígitos de las cadenas siguen la misma regla de caracteres. "10" < "9" es True: la primera comparación es entre "1" y "9", no entre los números diez y nueve.

Convierte la entrada para tomar decisiones numéricas

input() devuelve una cadena. Si alguien introduce 5, "5" == 5 da False; la igualdad no convierte el texto. El orden es distinto: "5" < 10 provoca un TypeError porque Python no puede ordenar esa cadena y ese entero entre sí.

age = int(input("Age: "))
print(age >= 18)

Para el texto introducido "18", int() produce el entero 18 y la comprobación muestra True. Usa float() cuando la entrada represente un valor decimal.

Usa una comparación encadenada para un rango

0 <= score <= 100 exige que las dos comparaciones entre valores vecinos sean verdaderas. Significa 0 <= score and score <= 100. Para score = 105, se cumple la comprobación del límite inferior, pero falla la del superior, así que toda la cadena es False.

Una cadena solo compara valores vecinos. 1 < 3 > 2 es True porque tanto 1 < 3 como 3 > 2 son verdaderos; no compara 1 directamente con 2.

Elige pertenencia o identidad cuando corresponda

Los operadores de pertenencia comprueban si un texto aparece dentro de otro. "nan" in "banana" es True; "Ban" in "banana" es False. "x" not in "banana" es True.

None representa la ausencia de valor. Compruébalo con result is None o result is not None. El operador is pregunta si se trata del mismo objeto, mientras que == pregunta si los valores son iguales. Usa == para la igualdad de números y cadenas: una comprobación de identidad como x is 5 no es fiable para ese fin y produce un SyntaxWarning.

Una sentencia if ejecuta un bloque solo cuando su condición es verdadera. La cabecera empieza con if, indica la condición y termina con dos puntos. Las líneas que hay debajo llevan sangría para mostrar que pertenecen a su cuerpo.

Sigue una decisión de una sola alternativa

temperature = 31
if temperature > 30:
    print("Hot day")
    print("Drink water")
print("Done")

En la cabecera, Python lee el valor actual de temperature. La comparación 31 > 30 es True, así que se ejecutan ambas líneas con sangría. Después, el programa llega a la línea que está fuera del bloque. Su salida es:

Hot day
Drink water
Done

Cambia la primera línea por temperature = 25. Ahora 25 > 30 es False, así que Python omite todo el cuerpo. Solo se muestra Done. La condición se comprueba una vez cuando Python llega a la cabecera; un if no sigue comprobándola.

Deja que la sangría indique qué pertenece al bloque

Por convención, usa 4 espacios por cada nivel de sangría. Las líneas del mismo nivel pertenecen al mismo bloque. Volver al nivel externo lo termina. Si aplicas una sangría de 4 espacios a print("Done"), pasa al cuerpo del if y solo muestra su mensaje cuando se cumple la condición.

Un diagrama de flujo muestra la misma elección con un rombo. El camino de verdadero entra en el cuerpo, el de falso lo rodea y ambos se unen en la siguiente sentencia fuera del bloque.

Python puede informar de SyntaxError, IndentationError o TabError ante estos problemas. Empieza por la cabecera y la sangría alrededor de la línea indicada. Los paréntesis alrededor de la condición son opcionales; if temperature > 30: es la forma habitual.

Un cuerpo no puede estar vacío. Si dejas un lugar reservado para una acción, escribe un pass con sangría. Es una sentencia válida que no hace nada:

if temperature > 30:
    pass

Las comprobaciones separadas son independientes

score = 95
if score >= 50:
    print("Pass")
if score >= 90:
    print("Excellent")

Python llega a ambas cabeceras. Las dos condiciones son verdaderas, así que muestra ambos mensajes. Las sentencias if independientes son adecuadas para reglas cuyas acciones pueden aplicarse todas a la misma entrada.

Da al código posterior un valor que pueda usar

Un nombre al que solo se asigna un valor dentro del cuerpo puede no llegar a crearse:

x = 0
if x > 0:
    message = "positive"
print(message)

En un archivo de programa ejecutado desde cero, se omite el cuerpo y message no tiene valor, así que la última línea provoca un NameError. Una solución es proporcionar un valor inicial antes de la elección:

x = 0
message = "not positive"
if x > 0:
    message = "positive"
print(message)

Ahora la línea posterior dispone de un valor en ambos caminos. Para cero muestra not positive; para un x positivo, el cuerpo sustituye ese texto por positive.

Una sentencia if–else elige uno de dos bloques. Cuando la condición es verdadera, Python ejecuta el cuerpo del if. En caso contrario, ejecuta el cuerpo del else. Se ejecuta exactamente uno al llegar a esta decisión.

Alinea las alternativas

number = int(input("Enter a whole number: "))
if number % 2 == 0:
    print(number, "is even")
else:
    print(number, "is odd")

Para la entrada 14, el resto es 0, así que la salida es 14 is even. Para la entrada -7, el resto es 1, así que la salida es -7 is odd. El else pertenece al if que tiene su mismo nivel de sangría. Su cuerpo lleva su propia sangría.

No hay ninguna condición después de else: significa que la condición anterior era falsa. else number < 0: es un error de sintaxis. Mantén la cláusula justo después del cuerpo del if; una sentencia ajena sin sangría entre ambos rompe la estructura.

Comprueba qué incluye «todo lo demás»

Con if answer == "yes":, un else no significa solo "no". También acepta "maybe", "Yes" y "", porque ninguno es igual a "yes". Esto es útil cuando todas las entradas restantes merecen la misma acción. Si varias entradas rechazadas necesitan respuestas distintas, hacen falta más comprobaciones.

Asigna un valor en ambos caminos

Una regla de envío ofrece envío gratuito para importes totales de al menos 50 u.m. y cobra 5,99 u.m. en los demás casos:

total = 42.50
if total >= 50:
    shipping = 0
else:
    shipping = 5.99
print(total + shipping)

Primero, 42.50 >= 50 da False. Python omite la asignación de 0, ejecuta el else y almacena 5.99. La última línea está fuera de ambos cuerpos y muestra 48.49. Cambia total a 60: el primer cuerpo almacena 0, el otro se omite y la última línea muestra 60. Ambos caminos definen shipping antes de que se use.

Elige un valor con una expresión condicional

Cuando la única diferencia es el valor que se asigna, una expresión condicional puede expresarlo en una línea:

shipping = 0 if total >= 50 else 5.99

Su forma es value_if_true if condition else value_if_false. Aunque el valor para el caso verdadero aparece primero en la página, Python evalúa primero la condición. Solo evalúa el valor elegido y después asigna el resultado a shipping.

Otro ejemplo es label = "even" if n % 2 == 0 else "odd". Para n = 14, selecciona "even". Para n = -7, selecciona "odd".

La expresión necesita ambos valores. x = 1 if flag está incompleta y provoca un SyntaxError porque no hay un valor para else. Una sentencia if completa puede omitir else porque simplemente puede no realizar ninguna acción en el camino falso; una expresión debe producir un valor en cualquier caso.

Usa elif, abreviatura de «si no, si», para añadir otra comprobación a una decisión. Python prueba las condiciones de arriba abajo. Se elige la primera condición verdadera y se omite el resto de esa cadena.

Sigue una decisión de calificación

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"
print(grade)

La primera comprobación, 85 >= 90, es falsa. La segunda, 85 >= 80, es verdadera, así que Python almacena "B". No comprueba las condiciones restantes ni entra en else. La salida es B.

Usa lo que te indican las condiciones falsas anteriores

Llegar a elif score >= 80: ya te indica que la puntuación es inferior a 90. Para puntuaciones enteras, esta rama abarca de 80 a 89. Añadir and score < 90 repetiría una comprobación que el programa ya ha resuelto.

El orden importa porque estos rangos se solapan. Si score >= 60 va primero, abarca 85 y 95 antes de que se llegue a las comprobaciones de sus calificaciones superiores. Para comprobaciones de límite inferior con >=, coloca primero el umbral más alto. Para comprobaciones de límite superior con <, empieza por el umbral más bajo.

Mantén una sola elección en una sola cadena

Sustituir las palabras reservadas elif por if cambia el comportamiento. Con una puntuación de 85, la comprobación de 80 asigna "B", la de 70 asigna después "C" y la de 60 asigna "D". El valor final es "D". Cada nuevo if inicia una decisión independiente.

Esta distinción también afecta a else. En un grupo de sentencias if independientes, un else final pertenece solo a su if correspondiente, no a todo el grupo. Mantén unidas las ramas cuando representen una sola clasificación.

Prevé los límites y las entradas sin coincidencia

Una cadena elif puede tener cualquier número de comprobaciones adicionales, y su else final es opcional. Sin una rama para los casos restantes, puede no ejecutar ningún cuerpo:

temp = 20
if temp < 18:
    print("Cool")
elif temp > 24:
    print("Warm")

No se cumple ninguna condición. Añade else: con un print("Comfortable") con sangría si cada temperatura necesita un mensaje. Del mismo modo, t < 18 seguido de t > 18 deja exactamente el 18 sin coincidencia. En los umbrales de calificación, escribir score > 90 enviaría el 90 a la rama "B".

Los menús de texto usan la misma estructura: comprueba choice == "1", después choice == "2" y responde con "Unknown option" a cualquier otra entrada. Estas comprobaciones comparan cadenas porque input() devuelve texto. Cuando muchas comprobaciones comparan un valor con opciones fijas, match ofrece otra forma de organizar la decisión.

Los operadores lógicos and, or y not permiten construir una condición a partir de otras más sencillas. Python los escribe como palabras en minúsculas.

Examina todas las posibilidades

Para entradas booleanas, and da True solo cuando ambas entradas son verdaderas. or da True cuando al menos una es verdadera, incluido el caso en que ambas lo son. Esto es una disyunción inclusiva.

not invierte un valor de verdad: not True da False y not False da True. Una tabla de verdad enumera todas las combinaciones de entradas booleanas. Dos entradas necesitan cuatro filas; tres necesitan ocho. Cada entrada booleana independiente adicional duplica las combinaciones.

Para A and not B, invierte primero B y después combínalo con A. En la fila A = True, B = False, not B es True, así que el resultado es True. Las otras tres filas dan False.

Traduce una regla a comprobaciones completas

Un museo aplica un descuento en la entrada a los visitantes menores de 12 años o de 65 años en adelante:

has_discount = age < 12 or age >= 65

A los 10 años se cumple la primera comparación. A los 65, se cumple la segunda. Las edades 30 y 64 no cumplen ninguna. Usar and exigiría que una misma edad fuera menor de 12 y de al menos 65, lo que no puede ocurrir.

Una atracción exige una estatura de al menos 120 centímetros y no tener ninguna afección cardíaca:

can_ride = height >= 120 and not has_heart_condition

Los dos requisitos deben cumplirse a la vez. Con la estatura mínima y has_heart_condition = False, se cumplen ambas partes. Si falla cualquiera de los requisitos, can_ride es False.

Distingue entre estar dentro y fuera de un rango

La comprobación de pertenencia al rango necesita ambos límites. Para estar fuera basta con incumplir uno de ellos. score < 0 and score > 100 nunca puede ser verdadero para un mismo número.

Cada comparación necesita ambos lados. score >= 0 and <= 100 tiene una sintaxis incompleta. Un problema más sutil se ejecuta sin errores:

if answer == "y" or "yes":
    print("Accepted")

Python interpreta (answer == "y") or "yes". Cuando la comparación es falsa, la cadena no vacía "yes" hace que la condición siga considerándose verdadera. Repite la comparación: answer == "y" or answer == "yes".

La redacción cotidiana necesita el mismo cuidado. «Cerrado los sábados y domingos» significa day == "Saturday" or day == "Sunday"; un día no tiene que tener ambos nombres a la vez. Para una variable booleana, niégala directamente con not is_member. Una comparación negada como not (age >= 18) también puede escribirse de forma más sencilla como age < 18. Aquí los operadores de Python son palabras, no &&, || ni !.

Una condición más larga plantea dos cuestiones: cómo se agrupan sus partes y qué partes evalúa realmente Python. La precedencia de operadores responde a la primera. La evaluación en cortocircuito responde a la segunda.

Interpreta primero la agrupación

Para los operadores que se usan aquí, la precedencia va de mayor a menor:

1. Potenciación: **.
2. Multiplicación, división, división entera con redondeo hacia abajo y resto: *, /, //, %.
3. Suma y resta: +, -.
4. Comparaciones, incluidas in, not in, is e is not.
5. not, después and y después or.
6. La expresión condicional: a if condition else b.

Los paréntesis cambian la agrupación. Por ejemplo, x > 3 or x < 0 and x != 5 se agrupa como x > 3 or (x < 0 and x != 5). Con x = 5, la comparación izquierda es verdadera y se omite todo el grupo de la derecha. El resultado es True.

Con (x > 3 or x < 0) and x != 5, los paréntesis convierten el primer grupo en un operando de and. Con x = 5, ese grupo es verdadero, pero x != 5 es falso, así que el resultado es False.

Por eso is_weekend or is_holiday and is_sunny acepta todos los fines de semana, incluso si llueve. Para la regla «un día libre que además sea soleado», escribe (is_weekend or is_holiday) and is_sunny.

Sigue la evaluación de izquierda a derecha

Para and, una primera parte falsa ya ha descartado el requisito completo. Para or, una primera parte verdadera ya lo ha satisfecho. La precedencia no obliga a Python a calcular un operando omitido solo porque contenga operadores de mayor precedencia.

Puedes usar esto para colocar una condición de protección antes de una operación que fallaría:

count = 0
total = 50
is_large_average = count != 0 and total / count > 10
print(is_large_average)

count != 0 es falso, así que Python nunca intenta 50 / 0. Almacena y muestra False. Invertir los operandos intenta primero la división y provoca un ZeroDivisionError; la comprobación posterior no puede proteger una operación anterior.

Distribuye not dentro de una comprobación agrupada

Las leyes de De Morgan reescriben una negación invirtiendo cada parte y cambiando el operador que las combina:

«No es adolescente» puede comprobarse como not (age >= 13 and age <= 19). La comprobación directa equivalente es age < 13 or age > 19. Las edades 12 y 20 la cumplen; 13, 16 y 19 no.

Mantener and después de negar ambas partes cambia la regla. Con A = True, B = False, not (A and B) es verdadero, pero not A and not B es falso. Compara todas las filas de las tablas de verdad al comprobar si dos formas booleanas son equivalentes.

Para una variable que ya contiene un booleano, escribe if is_valid: o if not is_valid:. Compararla con True o False añade una comprobación que la condición no necesita.

Un condicional anidado coloca una decisión dentro de una rama de otra. Solo se llega a la decisión interna cuando la ejecución entra en esa rama externa. Cada nivel de anidamiento añade 4 espacios de sangría.

Sigue la elección externa antes de la interna

has_ticket = True
age = 15
if has_ticket:
    if age >= 13:
        print("Enjoy the movie")
    else:
        print("This movie needs an adult")
else:
    print("Please buy a ticket first")

Primero, has_ticket es verdadero, así que Python entra en el cuerpo externo. Después comprueba 15 >= 13, obtiene verdadero y muestra Enjoy the movie. Se omiten tanto el cuerpo del else interno como el del externo.

Cambia la edad a 10 y mantén la entrada. Python sigue entrando en el cuerpo externo, pero la condición interna falla, así que muestra This movie needs an adult. Con has_ticket = False, nunca se llega a comprobar la edad; el else externo muestra Please buy a ticket first.

Asocia cada else según la sangría

Un else pertenece al if que tiene su mismo nivel de sangría. Moverlo puede cambiar el comportamiento aunque el archivo de programa siga siendo válido. Considera esta variante más breve:

if has_ticket:
    if age >= 13:
        print("Enter")
else:
    print("Buy a ticket")

El else pertenece a if has_ticket:. Un niño de 10 años con entrada no recibe ningún mensaje. Mueve ese else y su cuerpo un nivel hacia dentro y pasará a pertenecer a if age >= 13:. Ahora el mismo niño recibe Buy a ticket, mientras que alguien sin entrada no recibe ningún mensaje. La nueva disposición expresa una regla distinta.

En el ejemplo completo de la película, el if interno ya tiene un else. Mover ahí el else externo hacia dentro crearía dos alternativas para el mismo if y causaría un error de sintaxis.

Reduce el anidamiento de dos requisitos

Cuando solo hay una acción y ninguno de los niveles tiene un else, and suele eliminar un nivel de anidamiento:

if is_member and total >= 50:
    print("Free shipping")

Esto ejecuta la misma acción que un if is_member: externo que contiene un if total >= 50: interno. Ambos requisitos deben cumplirse, y solo se llega al segundo después de que se cumpla el primero. Mantén el anidamiento cuando las ramas externas necesiten sus propias acciones distintas, como al comprar una entrada.

Un else cuya única acción sea otro if–else puede convertirse en una cadena elif. Para positivo, negativo y cero, la forma sin anidamiento es if x > 0:, después elif x < 0: y después else:. Conserva los mismos tres resultados con menos sangría.

Valida antes de clasificar

Una decisión de calificación debe rechazar las puntuaciones fuera del rango permitido antes de asignar una letra:

if 0 <= score <= 100:
    if score >= 90:
        print("A")
    else:
        print("Below A")
else:
    print("Score must be between 0 and 100")

Con score = 150, la comprobación externa falla, así que no se asigna ninguna calificación. El anidamiento también pone de manifiesto caminos imposibles: un if x < 5: interno bajo if x > 10: nunca puede cumplirse. Cuando haya muchos niveles de sangría, busca requisitos que puedan combinarse, una cadena elif o una comprobación de validación anterior que aclare los caminos restantes.

Python puede comprobar un valor directamente en una condición. Su valor de verdad en un contexto booleano determina si se ejecuta el cuerpo. Esto ahorra comparaciones, pero el valor de verdad puede diferir de lo que parece decir el texto.

Reconoce los valores considerados falsos

Para los tipos incorporados que se usan aquí, False, None, el cero numérico, las cadenas vacías y las colecciones vacías se consideran falsos. Los números distintos de cero y las cadenas o colecciones no vacías se consideran verdaderos.

bool() convierte un valor a su valor de verdad booleano. En una condición, if value: elige la misma rama que if bool(value):. No transforma el valor almacenado en un booleano.

Comprueba si la entrada está vacía sin interpretarla mal

name = input("Name: ")
if name:
    print("Hello", name)
else:
    print("No name entered")

Pulsar Intro sin escribir nada produce "", así que se ejecuta el segundo cuerpo. Un nombre formado únicamente por espacios no está vacío y cumple la primera condición. En cambio, if name.strip(): comprueba el texto después de eliminar los espacios en blanco de los extremos, así que una respuesta formada solo por espacios tampoco cumple la condición.

Una respuesta de sí o no necesita otra pregunta. if answer: se ejecuta para "no" y "False" porque ambas contienen caracteres. Para reconocer una respuesta afirmativa, compara el texto, por ejemplo answer == "yes". El valor de verdad comprueba si el texto está vacío, no el significado de una palabra.

Distingue un cero válido de un dato ausente

Supón que quantity es None antes de que se proporcione un valor y que puede ser legítimamente 0. if quantity: rechaza ambos. Usa quantity is not None para preguntar si hay un valor; esto acepta el cero.

Para una variable que realmente es booleana, la comprobación directa es clara. Para otros valores, x == True hace algo distinto de if x:. Con x = 5, se cumple la comprobación del valor de verdad, pero 5 == True es falso; la igualdad numérica considera que True es igual a 1, no a cualquier número distinto de cero.

and y or devuelven un valor que examinan

Estos operadores devuelven un operando, que puede no ser un booleano:

Para or, Python devuelve el valor izquierdo si se considera verdadero; en caso contrario, evalúa y devuelve el derecho. Para and, devuelve el valor izquierdo si se considera falso; en caso contrario, evalúa y devuelve el derecho.

display_name = name or "Guest" proporciona un valor predeterminado para una entrada vacía. El mismo patrón con quantity or 1 sustituye un cero real por 1. Usa así un valor predeterminado solo cuando todos los valores considerados falsos signifiquen ausencia de datos. not se comporta de otra manera: siempre devuelve True o False. Si una variable indicadora (bandera) almacenada debe ser booleana, has_name = bool(name or nickname) convierte el texto seleccionado en un valor de verdad.

Un archivo de programa puede ejecutarse sin errores de sintaxis y aun así elegir la rama incorrecta. El seguimiento de la ejecución permite seguir una ejecución a mano. Las pruebas ejecutan entradas elegidas y comparan el resultado observado con el que exige la regla.

Planifica y sigue un camino

Antes de escribir código, expresa las elecciones en pasos de lenguaje cotidiano, o pseudocódigo. Un diagrama de flujo coloca cada condición en un rombo con flechas de verdadero y falso. Ambos caminos necesitan un siguiente paso o un final claro.

Para seguir el código, escribe los valores iniciales, evalúa cada condición a la que se llegue, registra las asignaciones y copia la salida exactamente. Para la cadena de calificaciones con score = 72:

«No se evalúa» es distinto de falso. Python ya ha seleccionado una rama, así que no necesita las comparaciones posteriores.

Cubre todas las ramas y todos los límites

Una cadena de cuatro ramas necesita al menos cuatro entradas para ejecutar cada rama una vez. Elígelas según los caminos previstos, no por lo variados que parezcan los números. Varias puntuaciones altas pueden ejecutar siempre el mismo primer cuerpo.

La cobertura de ramas por sí sola puede no detectar un límite incorrecto. Para age >= 18, prueba 17, 18 y 19. Un > equivocado supera las dos comprobaciones de los extremos como se esperaba, pero rechaza el límite exacto. Para un umbral de calificación de 90, compara 89, 90 y 91; haz lo mismo en los demás umbrales. Para entradas decimales, elige valores próximos adecuados a la precisión de la medida.

Encuentra ramas que no pueden ejecutarse

if score >= 60:
    print("Pass")
elif score >= 90:
    print("Excellent")

La segunda rama es inalcanzable. Cualquier puntuación de al menos 90 ya ha cumplido la primera condición. Coloca primero el umbral más restrictivo o cambia los rangos para que correspondan a la regla prevista.

Un caso sin cubrir deja sin tratar un caso previsto: t < 0 seguido de t > 0 omite el cero. Un solapamiento puede hacer que se ejecuten varias acciones independientes: las comprobaciones separadas t >= 0 y t <= 10 se cumplen ambas para 5. Una cadena solo permite ejecutar su primera rama verdadera, pero su orden sigue determinando qué condición de las que se solapan se elige.

Incluye entradas problemáticas

Prueba valores negativos, cero, texto vacío y respuestas en mayúsculas cuando el programa espera minúsculas. Si solo se aceptan "y" y "n", da a cualquier otro texto una respuesta clara como "Please answer y or n".

Cuando una comprobación se comporte de forma inesperada, inspecciona el valor y su tipo antes de evaluar la comparación sospechosa:

print(repr(age), type(age))

Para age = "18", esto muestra '18' <class 'str'>. Convierte el texto antes de intentar age >= 18; colocar la comparación defectuosa dentro de ese mismo print() de depuración provocaría un TypeError antes de que apareciera la salida de diagnóstico. Para problemas de estructura, inspecciona la sangría y el mensaje de error de sintaxis.

Por último, una comparación puede asignar directamente una variable indicadora booleana: is_adult = age >= 18. Esto sustituye a dos ramas cuyas únicas asignaciones son True y False. Usa bool() cuando la expresión subyacente pueda devolver otro tipo de valor.

Una sentencia match, disponible en Python 3.10 y posteriores, comprueba un valor con una serie de patrones. Ese valor es el valor examinado. Cada case proporciona un patrón y un cuerpo con sangría.

Sigue el primer caso que coincide

command = "stop"
match command:
    case "start":
        print("Starting")
    case "stop":
        print("Stopping")
    case _:
        print("Unknown command")
print("Ready")

El valor examinado es "stop". No coincide con "start", así que Python prueba el siguiente caso. "stop" coincide y el cuerpo muestra Stopping. Después, Python sale de todo el match y muestra Ready. Solo se ejecuta el cuerpo de un caso; no se pasa al cuerpo siguiente y no hace falta ningún break.

Un valor examinado de "jump" llega al patrón comodín final, _, que acepta cualquier valor. La salida es Unknown command y después Ready. Sin ese caso, un valor examinado sin coincidencia simplemente no ejecuta ningún cuerpo y continúa después de la sentencia.

Mantén la disposición y el caso final en orden

Las cabeceras case llevan una sangría de 4 espacios bajo match, y sus cuerpos otros 4 espacios. Todas las cabeceras terminan con dos puntos. Un case _: sin condición de guarda debe ir al final, porque acepta todo. Colocar más casos después provoca un SyntaxError: nunca se podría llegar a esos patrones posteriores.

Un comodín con condición de guarda puede aparecer antes porque su condición adicional puede fallar. Un match en un archivo de programa de ejecución secuencial tampoco puede contener break; esa sentencia necesita un bucle que la contenga.

Comprende cómo coinciden los literales

Un patrón literal usa un número fijo, una cadena, True, False o None. Los patrones de cadena son exactos y distinguen entre mayúsculas y minúsculas: "stop" no coincide con "Stop". Los patrones numéricos usan la igualdad, así que case 1: coincide con 1, 1.0 y True, que es igual a 1.

En cambio, los patrones True, False y None usan la identidad. Por tanto, case True: coincide con el booleano True, pero no con el entero 1. El orden de los patrones importa si tanto un caso numérico como uno booleano pueden aceptar el valor examinado.

Combina alternativas fijas con una barra

Un patrón de alternativas combina alternativas con |:

day = int(input("Day number: "))
match day:
    case 6 | 7:
        print("Weekend")
    case 1 | 2 | 3 | 4 | 5:
        print("Weekday")
    case _:
        print("Not a day number")

Para 6, se ejecuta el primer cuerpo; para 3, el segundo; para 9, el comodín. Sin int(), el "6" introducido sigue siendo una cadena y no coincide con el número 6.

Usa el separador de patrones |, no la palabra lógica or. case "y" or "yes": no es válido; case "y" | "yes": sí lo es.

Para comandos fijos, una cadena if–elif basada en la igualdad puede producir las mismas salidas. Elige la disposición que facilite más la lectura de los casos.

Los patrones pueden hacer más que comprobar un literal fijo. Un patrón puede dar nombre al valor examinado, y una condición de guarda puede comprobar un requisito adicional antes de aceptar el caso.

Captura primero y comprueba después la condición de guarda

Un patrón de captura es un nombre sin más, como n. Acepta cualquier valor examinado y lo asigna al nombre. Una condición de guarda sigue al patrón con if condition; el cuerpo solo se ejecuta si el patrón coincide y la condición de guarda es verdadera.

temperature = -5
match temperature:
    case 0:
        print("Exactly freezing")
    case t if t < 0:
        print("Below freezing by", -t, "degrees")
    case _:
        print("Above freezing")

Con -5, el primer literal no coincide. El siguiente patrón captura -5 en t y después comprueba t < 0. La condición de guarda es verdadera, así que la salida es Below freezing by 5 degrees.

Con 0, se elige el caso literal antes de intentar la captura. Con 12, la captura tiene éxito, pero la condición de guarda falla, así que Python prueba el comodín y muestra Above freezing. Una condición de guarda falsa no termina la búsqueda de un caso.

Un nombre sin más no consulta una constante

Supón que QUIT = "q". Es tentador escribir case QUIT: para comprobar si el valor examinado es igual a ese valor. Pero un nombre sin más siempre es una captura, incluso si está en mayúsculas. El caso acepta cualquier valor examinado y sobrescribe QUIT con él.

Si hay más casos después de una captura sin condición de guarda, Python informa de un error de sintaxis porque la captura los hace inalcanzables. Si la captura está al final, el error puede pasar inadvertido durante la ejecución. Compara explícitamente con una condición de guarda:

QUIT = "q"
key = "x"
match key:
    case k if k == QUIT:
        print("Quit")
    case _:
        print("Keep working")

Aquí k captura "x". La condición de guarda lo compara con el "q" existente, falla y deja que el comodín muestre Keep working. Un literal case "q": es más sencillo cuando el valor fijo puede escribirse directamente.

Distingue un patrón de valor con punto

Un nombre con punto como math.pi es un patrón de valor, no una captura. Consulta un valor existente y compara el valor examinado con él mediante ==. Las constantes con nombre proporcionadas por módulos o clases pueden usar esta forma. La distinción que debes reconocer es el punto: case n: asigna un nombre; un patrón con punto comprueba un valor existente.

Da nombre a una coincidencia específica con as

answer = "y"
match answer:
    case "y" | "yes" as accepted:
        print("Accepted:", accepted)
    case _:
        print("Please answer y or yes")

El patrón de alternativas comprueba las cadenas permitidas y as almacena el valor examinado que ha coincidido en accepted. Para "y", la salida es Accepted: y. No sustituye la entrada por una palabra estándar: "yes" almacenaría "yes". "Yes" no coincide con ninguna de las cadenas porque las mayúsculas y minúsculas siguen importando.

Una o dos condiciones de guarda pueden encajar de forma natural entre casos fijos. Cuando casi todos los casos comprueban rangos o usan variables distintas, una cadena if–elif suele ser más clara. Cualquiera de las dos estructuras necesita un caso final para los restantes cuando cada entrada deba recibir una respuesta.