Python Academy · Lección

Guardas y comodines

Añada condiciones y casos generales

Guardas y comodines es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

Perfeccionar las coincidencias

A veces un patrón estructural no basta; también necesita una condición. Las guardas añaden una prueba if a un caso y los comodines proporcionan patrones generales flexibles.

Añadir una guarda

Escriba if <condition> después de un patrón. El caso solo coincide cuando el patrón encaja y la guarda es verdadera.

n = 7

match n:
    case x if x < 0:
        print('negative')
    case x if x == 0:
        print('zero')
    case x if x > 0:
        print('positive')

Las guardas usan nombres capturados

Una guarda puede hacer referencia a las variables asignadas por el patrón. Aquí se comprueba la igualdad del par capturado.

point = [3, 3]

match point:
    case [x, y] if x == y:
        print('on the diagonal')
    case [x, y]:
        print('off the diagonal')

Si la guarda falla

Si la estructura coincide, pero la guarda es falsa, la coincidencia continúa con el caso siguiente en lugar de detenerse.

value = 5

match value:
    case n if n > 100:
        print('big')
    case n:
        print('fell through to here:', n)

Guardas con patrones de clase

Las guardas se combinan con cualquier tipo de patrón, incluidos los patrones de clase, para expresar condiciones precisas sobre los atributos de los objetos.

from dataclasses import dataclass

@dataclass
class Order:
    total: float

def discount(order):
    match order:
        case Order(total=t) if t > 100:
            return 'free shipping'
        case Order():
            return 'standard shipping'

print(discount(Order(150)))
print(discount(Order(50)))

Resumen del comodín

El guion bajo aislado _ coincide con cualquier cosa y no asigna ningún valor. Como caso final, gestiona todo lo que no se haya capturado antes.

x = 'unexpected'

match x:
    case 'a':
        print('letter a')
    case _:
        print('catch-all')

Captura frente a comodín

Una captura con nombre también coincide con cualquier cosa, pero conserva el valor, mientras que _ lo descarta. Use un nombre cuando necesite el valor en el cuerpo.

value = 42

match value:
    case 0:
        print('zero')
    case other:        # capture: keeps the value
        print('value was', other)

Comodines dentro de patrones

El guion bajo puede aparecer dentro de patrones más grandes para ignorar las partes que no le interesen.

record = ('user', 42, 'ignore_me')

match record:
    case ('user', user_id, _):
        print('user id:', user_id)

Combinar OR, guardas y comodines

Estas características se pueden combinar. Un patrón OR, seguido de una guarda y de un comodín final, permite crear un clasificador muy expresivo.

def classify(n):
    match n:
        case 0 | 1:
            return 'binary digit'
        case x if x % 2 == 0:
            return 'even'
        case _:
            return 'odd'

print(classify(0))
print(classify(4))
print(classify(7))

Exhaustividad

A diferencia de algunos lenguajes, Python no obliga a que una coincidencia sea exhaustiva. Si ningún caso coincide, la sentencia simplemente no hace nada. Añada un case _ final cuando quiera garantizar que siempre se ejecute una rama.

color = 'purple'
result = 'no match'

match color:
    case 'red':
        result = 'stop'
    case 'green':
        result = 'go'

print(result)

Guardas sobre datos desestructurados

Las guardas combinan de forma natural con los patrones de secuencia y de mapeo, lo que permite comprobar los valores que acaba de extraer.

data = [10, 20]

match data:
    case [a, b] if a + b > 25:
        print('sum is large')
    case [a, b]:
        print('sum is small')

Comprobación rápida

¿Qué ocurre cuando un patrón coincide estructuralmente, pero su condición de guarda es falsa?

Resumen

Ha aprendido a añadir condiciones y casos generales.

Las guardas añaden una prueba if que puede usar nombres capturados.
Si una guarda falla, se pasa al caso siguiente.
_ coincide y descarta el valor; un nombre lo captura.
Añada un case _ final para garantizar que se ejecute una rama.

Preguntas frecuentes

¿La lección «Guardas y comodines» es gratis?

Sí — el texto completo de «Guardas y comodines» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Guardas y comodines»?

Añada condiciones y casos generales Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Guardas y comodines»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Python Academy