La estructura match-case fue introducida en Python 3.10 y permite realizar comparaciones estructurales de manera declarativa y concisa. Similar a las estructuras de switch-case en otros lenguajes, esta adición a Python brinda una manera más flexible y poderosa de emparejar patrones y trabajar con ellos, no solo evaluando la igualdad de valores, sino también comparando estructuras de datos.
Es importante destacar que match-case es una nueva estructura de control que permite hacer patron matching o coincidencia de patrones. Esta funcionalidad no solo evalúa valores individuales, sino que también permite hacer coincidir estructuras complejas como tuplas, listas y objetos de manera más intuitiva y legible.
¿Por qué se incorpora?
La motivación principal detrás de la incorporación de match-case es:
- Concisión: Reduce la necesidad de múltiples if-elif-else anidados, lo que mejora la legibilidad del código.
- Flexibilidad: Es capaz de descomponer estructuras complejas como diccionarios, listas, y objetos, lo cual sería más tedioso y difícil con sentencias condicionales tradicionales.
- Patrones ricos: Permite hacer uso de patrones más detallados que van más allá de simples comparaciones de igualdad.
Sintaxis básica de match-case en Python
La sintaxis básica en Python es la siguiente:
match variable:
case <patrón 1>:
# Código si coincide con patrón 1
case <patrón 2>:
# Código si coincide con patrón 2
case _:
# Código por defecto, si ningún patrón coincide (similar al 'else')Como podemos apreciar es un simple de aplicar y si estamos acostumbrados a otros lenguajes que usan switch-case, como JavaScript, nos resultará familiar
Casos de uso
A continuación analizamos algunos casos de uso para este tipo de estructura:
- Comparación de valores. Podemos pensarlo como un
switch-case, pero con más flexibilidad. - Descomposición de estructuras. Nos puede ser útil para descomposición de listas, tuplas o diccionarios.
- Coincidencia con clases u objetos. Puede ser una opción para descomponer instancias de clases.
Uno de los usos esenciales para match-case es evaluar múltiples casos. A continuación veremos un ejemplo básico en código:
def evaluar_entrada(valor):
match valor:
case 1:
return "Es uno"
case 2:
return "Es dos"
case _:
return "No es ni uno ni dos"
print(evaluar_entrada(1)) # Es uno
print(evaluar_entrada(2)) # Es dos
print(evaluar_entrada(4)) # No es ni uno ni dosEn el siguiente ejemplo de código veremos lo que esta característica nos ofrece para evaluar y procesar un trabajo relacionado con descomposición de tuplas:
def procesar_tupla(t):
match t:
case (x, y):
return f"Es una tupla de dos elementos: {x}, {y}"
case (x, y, z):
return f"Es una tupla de tres elementos: {x}, {y}, {z}"
case _:
return "Tupla no reconocida"
print(procesar_tupla((1, 2))) # Es una tupla de dos elementos: 1, 2
print(procesar_tupla((1, 2, 3))) # Es una tupla de tres elementos: 1, 2, 3A continuación veremos un ejemplo que ilustra las coincidencia con clases:
class Punto:
def __init__(self, x, y):
self.x = x
self.y = y
def procesar_objeto(obj):
match obj:
case Punto(x, y):
return f"Punto con coordenadas ({x}, {y})"
case _:
return "Objeto no reconocido"
p = Punto(10, 20)
print(procesar_objeto(p)) # Punto con coordenadas (10, 20)Buenas prácticas
Para entender mejor la naturaleza de esta estructura analizaremos un listado de buenas prácticas relacionadas con match-case:
- Utilizar patrones explícitos. Es muy importante asegurarnos de que los patrones sean claros y específicos. Debemos evitar usar patrones demasiado generales que puedan reducir la legibilidad.
match datos:
case []: # Mala práctica. Es mejor verificar la estructura más allá de que sea una lista vacía.
case [x]: # Mejor, verificamos una lista con un solo elemento.- Apóyate en el caso por defecto
_: Es recomendable que cuando usemosmatch, incorporemos un caso por defecto con_para manejar todos los casos no previstos.
match variable:
case 1:
print("Valor es 1")
case _:
print("Otro valor")- Utilizar
match-casecuando haya lógica condicional compleja. No es recomendable usarmatchpara simples comparaciones. - Cuidado con las coincidencias parciales. Al emplear coincidencia de patrones en estructuras, debemos asegurarnos de manejar correctamente los casos en que los datos no sean completos. Ejemplo:
match t:
case (x, y): # Coincide con tuplas de dos elementos
case (x, y, z): # Coincide con tuplas de tres elementos- Aprovechar la descomposición de objetos. En lugar de acceder a los atributos de un objeto manualmente, podemos descomponerlo directamente en el patrón.
match obj:
case MiClase(x, y): # Descomponer los atributos de MiClase directamenteLa estructura match-case Python: conclusión
La estructura match-case en Python es una herramienta potente que amplía el abanico de posibilidades para manejar estructuras complejas y mejorar la legibilidad del código. Siempre destaco en mis clases que esto resulta importante a la hora de crear código para proyectos que puedan comapartirse en la comunidad o en un equipo de trabajo.
Además de ser más declarativo que el uso tradicional de if-elif-else, permite realizar coincidencias detalladas y flexibles que van más allá de lo que se puede lograr con simples comparaciones de igualdad.
Por todo lo mencionado en este artículo, bien vale conocer y comenzar a trabajar con match-case en Python para aprovechar su potencial en nuestros proyectos.
Más sobre Programación
Autor de los libros: Webmaster Profesional, HTML5: Comprenda el cambio y Apps HTML5 para móviles. Soy especialista en Desarrollo Web. Realizo proyectos basados en Inteligencia Artificial. Colaboré como autor y editor de contenidos para revistas, colecciones y diversos medios impresos y digitales. Brindo capacitaciones, clases de formación y consultorías sobre lenguajes de programación y herramientas para Desarrollo Web y móvil en modalidad online y presencial.
Deja una respuesta