Skip to content

Python Match Case: Explicación del Pattern Matching Estructural (Python 3.10+)

Soren Atelier
Name
Soren Atelier

Updated on

Durante décadas, los desarrolladores de Python han dependido de cadenas de if-elif para manejar la lógica de ramificación. Comprobar una variable contra múltiples valores, inspeccionar la estructura de los datos o enrutar según tipos de objetos suele requerir bloques condicionales verbosos que se vuelven más difíciles de leer a medida que aumentan los casos. Una función que despacha diez tipos posibles de comandos se convierte en un muro de sentencias elif, donde la lógica real queda enterrada bajo comparaciones repetitivas.

Esto no es solo un problema de legibilidad. Las cadenas profundas de if-elif son propensas a errores sutiles: una condición mal colocada, un caso olvidado o un “fall-through” accidental que deja pasar silenciosamente datos incorrectos al flujo posterior. Otros lenguajes resolvieron esto hace años con constructos de pattern matching, pero Python no tuvo una solución nativa hasta la versión 3.10.

Python 3.10 introdujo la sentencia match-case (PEP 634), incorporando el pattern matching estructural al lenguaje. Va mucho más allá de una simple comparación de valores: puedes desestructurar secuencias, hacer match por forma de diccionarios, enlazar variables, aplicar condiciones de guard, y despachar por tipos de clase, todo con una sintaxis limpia y declarativa. Esta guía cubre cada tipo de patrón con ejemplos prácticos.

📚

    ¿Qué es el Pattern Matching Estructural?

    El pattern matching estructural te permite comparar un valor (el “subject”) contra una serie de patrones y ejecutar el bloque de código del primer patrón que coincida. A diferencia de un switch statement en C o Java, el match-case de Python no solo compara valores: inspecciona la estructura de los datos.

    La sintaxis básica:

    match subject:
    case pattern1:
        # code for pattern1
    case pattern2:
        # code for pattern2
    case _:
        # default case (wildcard)

    Características clave:

    • Los patrones se evalúan de arriba hacia abajo. El primer patrón que coincide gana.
    • El patrón comodín _ coincide con cualquier cosa y funciona como caso por defecto.
    • Los patrones pueden enlazar variables, es decir, partes del valor coincidente se capturan en nombres que puedes usar dentro del bloque del case.
    • No hay comportamiento de fall-through. Solo se ejecuta un bloque case.

    Requisito de versión de Python: match-case requiere Python 3.10 o posterior. Comprueba tu versión con python --version. Si estás usando una versión anterior, necesitas actualizar antes de usar esta característica.

    Patrones Literales: Coincidir con Valores Exactos

    El uso más simple de match-case compara un valor contra constantes literales:

    def get_http_status_message(code):
    match code:
        case 200:
            return "OK"
        case 201:
            return "Created"
        case 301:
            return "Moved Permanently"
        case 400:
            return "Bad Request"
        case 403:
            return "Forbidden"
        case 404:
            return "Not Found"
        case 500:
            return "Internal Server Error"
        case _:
            return f"Unknown status code: {code}"
 
print(get_http_status_message(404))  # Not Found
print(get_http_status_message(418))  # Unknown status code: 418

    Los patrones literales funcionan con enteros, strings, booleanos y None:

    def describe_value(value):
    match value:
        case True:
            return "Boolean true"
        case False:
            return "Boolean false"
        case None:
            return "None value"
        case "":
            return "Empty string"
        case 0:
            return "Zero"
        case _:
            return f"Other: {value}"

    Importante: True, False y None se comparan por identidad (como con is), no por igualdad. Esto significa que match 1 no coincidirá con case True aunque 1 == True sea True en Python.

    Or-Patterns: Coincidir con Múltiples Valores

    Usa el operador pipe | para coincidir con cualquiera de varios patrones en un solo case:

    def classify_day(day):
    match day.lower():
        case "monday" | "tuesday" | "wednesday" | "thursday" | "friday":
            return "Weekday"
        case "saturday" | "sunday":
            return "Weekend"
        case _:
            return "Invalid day"
 
print(classify_day("Saturday"))  # Weekend
print(classify_day("Wednesday")) # Weekday

    Los or-patterns funcionan con cualquier tipo de patrón, no solo con literales:

    def categorize_error(code):
    match code:
        case 400 | 401 | 403 | 404 | 405:
            return "Client error"
        case 500 | 502 | 503 | 504:
            return "Server error"
        case _:
            return "Other"

    Patrones de Captura de Variables

    Los patrones pueden capturar partes del valor coincidente en variables. Un nombre “desnudo” en un patrón actúa como una variable que se enlaza al valor que aparezca en esa posición:

    def parse_command(command):
    match command.split():
        case ["quit"]:
            return "Exiting program"
        case ["hello", name]:
            return f"Hello, {name}!"
        case ["add", x, y]:
            return f"Sum: {int(x) + int(y)}"
        case _:
            return "Unknown command"
 
print(parse_command("hello Alice"))  # Hello, Alice!
print(parse_command("add 3 5"))      # Sum: 8
print(parse_command("quit"))         # Exiting program

    En case ["hello", name], la variable name captura el string que aparece en la segunda posición de la lista. Esto es fundamentalmente distinto del match literal: no hay ninguna variable llamada name contra la que se esté comparando. En su lugar, el patrón crea un nuevo enlace (binding).

    El Problema de Captura vs Constante

    Como los nombres desnudos son patrones de captura, no puedes hacer match directamente contra una variable:

    QUIT_COMMAND = "quit"
 
match user_input:
    case QUIT_COMMAND:  # This captures into QUIT_COMMAND, not compare!
        print("This always matches!")

    Para hacer match contra una constante, usa nombres con punto o valores literales:

    class Commands:
    QUIT = "quit"
    HELP = "help"
 
match user_input:
    case Commands.QUIT:  # Dotted name: compares against the value
        print("Quitting")
    case Commands.HELP:
        print("Showing help")

    Los nombres con punto (que contienen un .) se tratan como búsquedas de valor, no como patrones de captura. Esta es una decisión de diseño intencional en PEP 634.

    Patrones de Secuencia: Desestructurar Listas y Tuplas

    Match-case destaca al desestructurar secuencias. Puedes hacer match con la longitud y el contenido de listas o tuplas:

    def process_point(point):
    match point:
        case (0, 0):
            return "Origin"
        case (x, 0):
            return f"On x-axis at {x}"
        case (0, y):
            return f"On y-axis at {y}"
        case (x, y):
            return f"Point at ({x}, {y})"
        case _:
            return "Not a valid point"
 
print(process_point((0, 0)))   # Origin
print(process_point((5, 0)))   # On x-axis at 5
print(process_point((3, 7)))   # Point at (3, 7)

    Star Patterns para Secuencias de Longitud Variable

    Usa * para hacer match con secuencias de longitud variable:

    def analyze_sequence(seq):
    match seq:
        case []:
            return "Empty sequence"
        case [single]:
            return f"Single element: {single}"
        case [first, second]:
            return f"Pair: {first}, {second}"
        case [first, *middle, last]:
            return f"First: {first}, Last: {last}, Middle has {len(middle)} items"
 
print(analyze_sequence([]))              # Empty sequence
print(analyze_sequence([42]))            # Single element: 42
print(analyze_sequence([1, 2, 3, 4, 5])) # First: 1, Last: 5, Middle has 3 items

    Patrones de Secuencia Anidados

    Los patrones se pueden anidar para hacer match con estructuras de datos complejas:

    def process_matrix_row(row):
    match row:
        case [[a, b], [c, d]]:
            return f"2x2 block: {a}, {b}, {c}, {d}"
        case [first_row, *rest]:
            return f"First row: {first_row}, remaining rows: {len(rest)}"
 
print(process_matrix_row([[1, 2], [3, 4]]))
# 2x2 block: 1, 2, 3, 4

    Patrones de Mapping: Coincidir con Diccionarios

    Los patrones de mapping hacen match con objetos tipo diccionario comprobando claves específicas y, opcionalmente, capturando sus valores:

    def handle_api_response(response):
    match response:
        case {"status": "success", "data": data}:
            return f"Success! Data: {data}"
        case {"status": "error", "message": msg}:
            return f"Error: {msg}"
        case {"status": "error", "code": code, "message": msg}:
            return f"Error {code}: {msg}"
        case {"status": status}:
            return f"Unknown status: {status}"
        case _:
            return "Invalid response format"
 
print(handle_api_response({"status": "success", "data": [1, 2, 3]}))
# Success! Data: [1, 2, 3]
 
print(handle_api_response({"status": "error", "message": "Not found"}))
# Error: Not found

    Los patrones de mapping coinciden si el diccionario contiene las claves especificadas: las claves extra se ignoran. Esto los hace ideales para trabajar con datos JSON y respuestas de APIs.

    Usa **rest para capturar las claves restantes:

    def extract_config(config):
    match config:
        case {"host": host, "port": port, **rest}:
            return f"Server: {host}:{port}, extra config: {rest}"
        case _:
            return "Missing required config"
 
print(extract_config({"host": "localhost", "port": 8080, "debug": True}))
# Server: localhost:8080, extra config: {'debug': True}

    Guard Clauses: Añadir Condiciones a los Patrones

    Los guards añaden una condición if que debe ser verdadera para que el patrón coincida. Primero se comprueba el patrón; si coincide, se evalúa la expresión del guard:

    def classify_number(n):
    match n:
        case x if x < 0:
            return "Negative"
        case 0:
            return "Zero"
        case x if x % 2 == 0:
            return "Positive even"
        case x if x % 2 == 1:
            return "Positive odd"
 
print(classify_number(-5))  # Negative
print(classify_number(0))   # Zero
print(classify_number(4))   # Positive even
print(classify_number(7))   # Positive odd

    Los guards son esenciales cuando el patrón por sí solo no puede expresar toda la condición de coincidencia:

    def validate_age(data):
    match data:
        case {"name": name, "age": age} if age < 0:
            return f"Invalid: {name} has negative age"
        case {"name": name, "age": age} if age < 18:
            return f"{name} is a minor (age {age})"
        case {"name": name, "age": age} if age >= 18:
            return f"{name} is an adult (age {age})"
        case _:
            return "Invalid data format"
 
print(validate_age({"name": "Alice", "age": 25}))
# Alice is an adult (age 25)

    Patrones de Clase: Coincidir con Tipos de Objetos

    Los patrones de clase comprueban si un valor es una instancia de una clase y opcionalmente desestructuran sus atributos:

    from dataclasses import dataclass
 
@dataclass
class Point:
    x: float
    y: float
 
@dataclass
class Circle:
    center: Point
    radius: float
 
@dataclass
class Rectangle:
    top_left: Point
    width: float
    height: float
 
def describe_shape(shape):
    match shape:
        case Circle(center=Point(x=0, y=0), radius=r):
            return f"Circle at origin with radius {r}"
        case Circle(center=center, radius=r) if r > 100:
            return f"Large circle at ({center.x}, {center.y})"
        case Circle(center=center, radius=r):
            return f"Circle at ({center.x}, {center.y}) with radius {r}"
        case Rectangle(width=w, height=h) if w == h:
            return f"Square with side {w}"
        case Rectangle(top_left=tl, width=w, height=h):
            return f"Rectangle at ({tl.x}, {tl.y}), {w}x{h}"
        case _:
            return "Unknown shape"
 
print(describe_shape(Circle(Point(0, 0), 5)))
# Circle at origin with radius 5
 
print(describe_shape(Rectangle(Point(1, 2), 10, 10)))
# Square with side 10

    Para clases sin __match_args__, usa argumentos con nombre. Los dataclasses y las named tuples establecen __match_args__ automáticamente, habilitando patrones posicionales:

    @dataclass
class Color:
    r: int
    g: int
    b: int
 
def describe_color(color):
    match color:
        case Color(0, 0, 0):
            return "Black"
        case Color(255, 255, 255):
            return "White"
        case Color(r, 0, 0):
            return f"Red shade (r={r})"
        case Color(0, g, 0):
            return f"Green shade (g={g})"
        case Color(0, 0, b):
            return f"Blue shade (b={b})"
        case Color(r, g, b):
            return f"RGB({r}, {g}, {b})"
 
print(describe_color(Color(255, 0, 0)))   # Red shade (r=255)
print(describe_color(Color(128, 64, 32))) # RGB(128, 64, 32)

    Coincidir con Tipos Integrados (Built-in)

    Puedes hacer match contra tipos built-in para comprobación de tipos:

    def process_value(value):
    match value:
        case int(n):
            return f"Integer: {n}"
        case float(n):
            return f"Float: {n}"
        case str(s):
            return f"String: '{s}'"
        case list(items):
            return f"List with {len(items)} items"
        case dict(d):
            return f"Dict with keys: {list(d.keys())}"
        case _:
            return f"Other type: {type(value).__name__}"
 
print(process_value(42))          # Integer: 42
print(process_value("hello"))     # String: 'hello'
print(process_value([1, 2, 3]))   # List with 3 items

    Match Case vs if-elif: Cuándo Usar Cada Uno

    Criteriomatch-caseif-elif
    Versión de PythonSolo 3.10+Todas las versiones
    Comparación de valoresLimpio, un valor por caseVerboso con variable repetida
    DesestructuraciónIntegrada (secuencias, dicts, objetos)Requiere unpacking manual
    Comprobación de tiposPatrones de clase nativosRequiere llamadas isinstance()
    Condiciones guardif después del patrónif/elif estándar
    Enlace de variablesCaptura automáticaAsignación manual
    RendimientoDespacho de patrones optimizadoEvaluación secuencial
    LegibilidadMejor para 4+ casos con estructuraMejor para 1-3 condiciones simples
    Fall-throughNo (por diseño)Posible si falta elif

    Cuándo match-case es claramente mejor:

    # Parsing structured data -- match-case
def handle_event(event):
    match event:
        case {"type": "click", "x": x, "y": y}:
            process_click(x, y)
        case {"type": "keypress", "key": key, "modifiers": [*mods]}:
            process_key(key, mods)
        case {"type": "scroll", "delta": delta} if delta != 0:
            process_scroll(delta)

    El equivalente con if-elif:

    # Same logic with if-elif -- more verbose
def handle_event(event):
    if event.get("type") == "click" and "x" in event and "y" in event:
        process_click(event["x"], event["y"])
    elif event.get("type") == "keypress" and "key" in event and "modifiers" in event:
        process_key(event["key"], event["modifiers"])
    elif event.get("type") == "scroll" and event.get("delta", 0) != 0:
        process_scroll(event["delta"])

    Cuándo if-elif sigue siendo mejor:

    # Simple range checks -- if-elif is clearer
if temperature > 100:
    status = "boiling"
elif temperature > 50:
    status = "hot"
elif temperature > 20:
    status = "warm"
else:
    status = "cold"

    Match-case no admite comparaciones por rangos directamente en los patrones. Necesitarías guards para cada caso, lo cual anula la ventaja de legibilidad.

    Casos de Uso del Mundo Real

    Parsing de Argumentos de Línea de Comandos

    import sys
 
def main():
    match sys.argv[1:]:
        case ["help"]:
            print("Available commands: help, version, run, test")
        case ["version"]:
            print("v1.0.0")
        case ["run", filename]:
            print(f"Running {filename}")
        case ["run", filename, "--verbose"]:
            print(f"Running {filename} with verbose output")
        case ["test", *test_files] if test_files:
            print(f"Testing: {', '.join(test_files)}")
        case ["test"]:
            print("Running all tests")
        case [unknown, *_]:
            print(f"Unknown command: {unknown}")
        case []:
            print("No command provided. Use 'help' for usage.")

    Implementación de una Máquina de Estados

    from dataclasses import dataclass
from typing import Optional
 
@dataclass
class State:
    name: str
    data: Optional[dict] = None
 
def transition(state, event):
    match (state.name, event):
        case ("idle", "start"):
            return State("loading", {"progress": 0})
        case ("loading", "progress"):
            progress = state.data.get("progress", 0) + 25
            if progress >= 100:
                return State("ready", {"progress": 100})
            return State("loading", {"progress": progress})
        case ("loading", "cancel"):
            return State("idle")
        case ("ready", "process"):
            return State("processing", state.data)
        case ("processing", "complete"):
            return State("done", {"result": "success"})
        case ("processing", "error"):
            return State("error", {"message": "Processing failed"})
        case (_, "reset"):
            return State("idle")
        case (current, unknown_event):
            print(f"No transition from '{current}' on '{unknown_event}'")
            return state
 
# Usage
state = State("idle")
for event in ["start", "progress", "progress", "progress", "progress", "process", "complete"]:
    state = transition(state, event)
    print(f"Event: {event} -> State: {state.name}, Data: {state.data}")

    Handler de Respuesta de API JSON

    def process_api_result(response):
    match response:
        case {"data": {"users": [*users]}, "meta": {"total": total}}:
            print(f"Found {total} users, received {len(users)}")
            for user in users:
                match user:
                    case {"name": name, "role": "admin"}:
                        print(f"  Admin: {name}")
                    case {"name": name, "role": role}:
                        print(f"  {role.title()}: {name}")
 
        case {"data": {"users": []}}:
            print("No users found")
 
        case {"error": {"code": code, "message": msg}} if code >= 500:
            print(f"Server error ({code}): {msg}")
            raise RuntimeError(msg)
 
        case {"error": {"code": code, "message": msg}}:
            print(f"Client error ({code}): {msg}")
 
        case _:
            print(f"Unexpected response format: {type(response)}")
 
# Example
process_api_result({
    "data": {"users": [
        {"name": "Alice", "role": "admin"},
        {"name": "Bob", "role": "editor"}
    ]},
    "meta": {"total": 2}
})

    Parser de Archivo de Configuración

    def apply_config(settings):
    for key, value in settings.items():
        match (key, value):
            case ("database", {"host": host, "port": int(port), "name": db}):
                print(f"DB connection: {host}:{port}/{db}")
            case ("database", _):
                raise ValueError("Invalid database config: need host, port, name")
            case ("logging", {"level": level}) if level in ("DEBUG", "INFO", "WARNING", "ERROR"):
                print(f"Log level set to {level}")
            case ("logging", {"level": level}):
                raise ValueError(f"Invalid log level: {level}")
            case ("features", {"enabled": list(features)}):
                print(f"Enabled features: {', '.join(features)}")
            case ("features", {"enabled": _}):
                raise TypeError("Features must be a list")
            case (key, _):
                print(f"Unknown config key: {key}")
 
apply_config({
    "database": {"host": "localhost", "port": 5432, "name": "mydb"},
    "logging": {"level": "INFO"},
    "features": {"enabled": ["auth", "cache", "metrics"]}
})

    Pipeline de Transformación de Datos

    def transform_record(record):
    """Transform raw data records into standardized format."""
    match record:
        case {"timestamp": ts, "value": float(v) | int(v), "unit": str(unit)}:
            return {"time": ts, "measurement": float(v), "unit": unit.lower()}
 
        case {"timestamp": ts, "value": str(v), "unit": str(unit)}:
            try:
                return {"time": ts, "measurement": float(v), "unit": unit.lower()}
            except ValueError:
                return {"time": ts, "measurement": None, "unit": unit.lower(), "error": f"Cannot parse: {v}"}
 
        case {"timestamp": ts, "value": v}:
            return {"time": ts, "measurement": float(v), "unit": "unknown"}
 
        case {"values": [*values]} if values:
            return [transform_record({"timestamp": None, "value": v, "unit": "batch"}) for v in values]
 
        case _:
            return {"error": f"Unrecognized format: {record}"}
 
# Examples
print(transform_record({"timestamp": "2026-01-01", "value": 42.5, "unit": "Celsius"}))
print(transform_record({"timestamp": "2026-01-01", "value": "98.6", "unit": "F"}))

    Técnicas Avanzadas de Patrones

    Patrón AS: Enlazar el Match Completo

    Usa as para capturar el valor completo que coincide mientras también lo desestructuras:

    def process_item(item):
    match item:
        case {"name": str(name), "price": float(price)} as product if price > 100:
            print(f"Premium product: {product}")
        case {"name": str(name), "price": float(price)} as product:
            print(f"Standard product: {product}")

    Combinación de Tipos de Patrones

    Los patrones se componen de forma natural. Puedes mezclar patrones de secuencia, mapping y clase:

    @dataclass
class Order:
    items: list
    customer: dict
 
def process_order(order):
    match order:
        case Order(items=[single_item], customer={"vip": True}):
            print(f"VIP single-item order: {single_item}")
        case Order(items=[_, _, *rest], customer={"name": name}) if len(rest) > 0:
            print(f"{name} ordered {2 + len(rest)} items")
        case Order(items=[], customer=_):
            print("Empty order")

    Usar Match-Case en Jupyter Notebooks

    El pattern matching es particularmente útil en flujos de trabajo de análisis de datos donde necesitas manejar distintos formatos de datos o respuestas de APIs. Al explorar datasets de forma interactiva en Jupyter notebooks, match-case ofrece una manera limpia de manejar la variedad de “shapes” de datos que encuentras.

    def classify_cell_output(output):
    """Classify Jupyter cell output by type."""
    match output:
        case {"output_type": "stream", "text": text}:
            return f"Text output: {len(text)} chars"
        case {"output_type": "error", "ename": name, "evalue": value}:
            return f"Error: {name}: {value}"
        case {"output_type": "display_data", "data": {"image/png": _}}:
            return "Image output"
        case {"output_type": "execute_result", "data": {"text/html": html}}:
            return "HTML table output"
        case _:
            return "Unknown output type"

    Para data scientists que quieren asistencia de AI mientras trabajan con pattern matching y otras características de Python 3.10+ en notebooks, RunCell (opens in a new tab) ofrece un agente de AI directamente dentro de Jupyter que puede ayudar a escribir, depurar y optimizar sentencias match-case basándose en tus estructuras de datos reales.

    Errores Comunes y Cómo Evitarlos

    Error 1: Usar match-case en Python < 3.10

    # This fails with SyntaxError on Python 3.9 and earlier
match value:
    case 1:
        print("one")

    Arreglo: Comprueba sys.version_info >= (3, 10) o actualiza Python.

    Error 2: Tratar los nombres en case como comparaciones

    expected = 200
 
match status_code:
    case expected:  # WRONG: creates a new variable 'expected'
        print("OK")

    Arreglo: Usa un nombre con punto, un literal o un guard:

    match status_code:
    case code if code == expected:
        print("OK")

    Error 3: Olvidar el caso comodín

    Sin case _, los valores no coincidentes no hacen nada en silencio:

    match command:
    case "start":
        run()
    case "stop":
        halt()
    # If command is "pause", nothing happens -- no error, no warning

    Arreglo: Incluye siempre un caso comodín para un manejo explícito:

    match command:
    case "start":
        run()
    case "stop":
        halt()
    case _:
        raise ValueError(f"Unknown command: {command}")

    Error 4: Patrones dependientes del orden sin suficiente especificidad

    Los patrones se comprueban de arriba hacia abajo. Un patrón amplio antes que uno específico lo oculta:

    # WRONG: the first case always matches
match point:
    case (x, y):       # Captures everything
        print("generic")
    case (0, 0):       # Never reached
        print("origin")

    Arreglo: Pon primero los patrones específicos:

    match point:
    case (0, 0):
        print("origin")
    case (x, y):
        print(f"point at ({x}, {y})")

    Consideraciones de Rendimiento

    Match-case se compila a bytecode eficiente. Para match literal simple, el compilador de Python lo optimiza de forma similar a búsquedas en diccionarios. Para patrones estructurales, genera un árbol de decisión que evita comprobaciones redundantes.

    Los benchmarks muestran que match-case rinde de manera comparable a cadenas if-elif para un número pequeño de casos (menos de 5). Para tablas de despacho más grandes (10+ casos), match-case puede ser más rápido gracias a la optimización del bytecode, especialmente con patrones literales.

    Sin embargo, el pattern matching no reemplaza el dispatch con diccionarios cuando solo necesitas mapear valores a funciones:

    # For simple value-to-action mapping, a dict is cleaner and faster
handlers = {
    "click": handle_click,
    "scroll": handle_scroll,
    "keypress": handle_keypress,
}
 
handler = handlers.get(event_type, handle_unknown)
handler(event_data)

    Usa match-case cuando necesites inspección estructural, desestructuración o guard conditions: cosas que una búsqueda en diccionario no puede expresar.

    FAQ

    ¿Qué versión de Python necesito para match-case?

    Se requiere Python 3.10 o posterior para la sentencia match-case. Se introdujo en PEP 634 como parte del lanzamiento de Python 3.10 en octubre de 2021. Intentar usar match-case en Python 3.9 o anterior produce un SyntaxError. Puedes comprobar tu versión ejecutando python --version en tu terminal.

    ¿Python match-case es lo mismo que switch-case en otros lenguajes?

    No. El match-case de Python es pattern matching estructural, que es más potente que un switch-case tradicional. Mientras que switch-case en C o Java solo compara valores, match-case en Python puede desestructurar secuencias y diccionarios, hacer match con instancias de clases por atributos, enlazar variables a partir de datos coincidentes y aplicar guard conditions. Es más cercano al pattern matching de Rust, Scala o Haskell.

    ¿Match-case tiene fall-through como el switch de C?

    No. El match-case de Python ejecuta solo el primer bloque case que coincida y luego sale de la sentencia match. No hay fall-through y no necesitas sentencias break. Si quieres que múltiples patrones ejecuten el mismo código, usa or-patterns con el operador pipe: case "a" | "b" | "c": coincidirá con cualquiera de esos valores.

    ¿Puedo usar match-case con expresiones regulares?

    No directamente. Los patrones en match-case son estructurales, no basados en regex. Sin embargo, puedes usar guard clauses para aplicar regex: case str(s) if re.match(r"pattern", s): combina la comprobación estructural de tipo con la validación regex en el guard.

    ¿Cómo maneja match-case los valores None?

    None se hace match como patrón literal usando case None:. Como None es un singleton en Python, el match usa comparación por identidad (equivalente a is None). Esto significa que case None: solo coincidirá con el objeto None real, no con otros valores falsy como 0, False o strings vacíos.

    ¿Qué ocurre si no coincide ningún case?

    Si no coincide ningún case y no hay un patrón comodín (case _:), la sentencia match no hace nada y la ejecución continúa después del bloque match. No se lanza ninguna excepción. Por eso es una buena práctica incluir siempre un caso comodín, ya sea para proporcionar una acción por defecto o para lanzar una excepción ante valores inesperados.

    Conclusión

    La sentencia match-case de Python lleva el pattern matching estructural a un lenguaje que durante mucho tiempo ha dependido de cadenas if-elif para lógica de ramificación compleja. Proporciona una forma declarativa de inspeccionar la forma de los datos, desestructurar secuencias y diccionarios, despachar según tipos de objetos y enlazar variables, todo con una sintaxis que se lee con más claridad que el código condicional equivalente.

    La idea clave es que match-case no es solo una sentencia switch. Es una herramienta para trabajar con datos estructurados: parsear comandos, manejar respuestas de APIs, implementar máquinas de estados y enrutar según tipos de objetos. Cuando tu lógica de ramificación implica comprobar la “shape” de los datos en lugar de simples comparaciones de valores, match-case produce código más corto y más fácil de mantener.

    Empieza con patrones literales simples y luego incorpora gradualmente desestructuración de secuencias, patrones de mapping y patrones de clase según lo exijan tus casos de uso. Incluye siempre un caso comodín para el manejo explícito de entradas inesperadas, coloca patrones específicos antes que patrones generales y recuerda que los nombres desnudos capturan valores en lugar de compararlos.

    Para la exploración interactiva de patrones match-case con tus propios datos, los Jupyter notebooks ofrecen un entorno ideal para probar patrones de forma incremental. RunCell (opens in a new tab) mejora este flujo de trabajo con asistencia de AI que entiende características de Python 3.10+ y puede sugerir estructuras de patrones basadas en las shapes de tus datos.

    📚