El nuevo switch en Python 3.10

Posiblemente una de las novedades más interesantes que ha traído la versión 3.10 de Python es la incorporación de un nuevo mecanismo de control de flujo Match-Case. Mecanismos que es habitual en otros lenguajes de alto nivel y que en la mayoría de los casos se conoce como switch-case. Un mecanismo que, a diferencia de Python, ya se encontraba implementado hace tiempo en otros lenguajes como R, Matlab o JavaScript. Hasta ahora Python no contaba con un mecanismo para la selección de casos más allá del uso de if anidados, por lo que creo que la introducción de este mecanismo puede hacer que el código sea más legible en muchos casos. Veamos cómo funciona Match-Case y cómo se puede incorporar el mecanismo switch en Python 3.10.

Uso básico de switch en Python 3.10

La estructura Match-Case de Python tiene la siguiente sintaxis:

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

En la que se evalúa si el contenido de la variable subject es igual al del patrón (<pattern_1>) situado después de la primera instrucción case. Si es cierto, se ejecutará el código debajo de este y el flujo de ejecución saldrá de la estructura. En el caso de que sea falso, se evaluará el patrón después del siguiente case hasta que se encuentre uno que sea válido o se evalúen todos los casos de forma negativa. Para los casos en los que es necesario un caso por defecto, aquel que se debe ejecutar cuando todos los casos son negativos, se debe emplear el comodín _ como se muestra en el ejemplo. Siendo importante que este se incluya en último lugar, ya que en caso contrario no se evaluarían los cases debajo de este.

Comparado listas o tuplas con Match-Case

En Python la estructura Match-Case no solamente permite comparar variables básicas, sino que también es posible trabajar con listas o tuplas. Siendo necesario en estos casos que los dos objetos tengan exactamente los mismos elementos, aunque también se puede utilizar el comodín _ para cualquier valor en un elemento de la lista. Algo que se puede ver en el siguiente ejemplo.

match point:
    case (0, 0):
        print('Origin')
    case (_, 0):
        print('X')
    case (0, _):
        print('Y')
    case (_, _):
        print('Point')
    case _:
        raise ValueError("Not a point")

En este se puede ver que si el punto es (0, 0) se mostrará el texto origen, si solamente es uno de los dos cero se mostrar X o Y en función de cual sea, si ambos son cero el texto Point y, en el caso de que no sea una lista o tupla de dos elementos generar un error indicando que no es un punto.

Creación de variables

Para los casos como el anterior puede ser interesante extraer los valores de la lista para usarlos en el código. Así, en lugar de usar el comodín, se puede definir una variable en la que se copiará el valor. Algo que se puede ver en el siguiente ejemplo incluido en la documentación.

match point:
    case (0, 0):
        print("Origin")
    case (0, y):
        print(f"Y={y}")
    case (x, 0):
        print(f"X={x}")
    case (x, y):
        print(f"X={x}, Y={y}")
    case _:
        raise ValueError("Not a point")

En este ejemplo, si los dos valores de la tupla son cero se imprimirá por pantalla la palabra Origin. Ahora bien, en el caso de que solamente sea cero el primer valor se imprimirá por pantalla un mensaje indicando que Y es una constante. Usando para ello una f-string. Análogamente, en el caso de que solamente sea cero el segundo se indicará que X es una constante. En el último caso, si ningún valor de la tupla es cero se imprimirá la ecuación correspondiente. Finalmente, en el caso de que el dato no sea una tupla se indicará el error.

Combinación de múltiples opciones

En el caso de que una acción se deba ejecutar para más de un valor no es necesario repetir varios case, ya que se puede usar el operador | para indicar más de una opción.

match msg:
    case 401 | 403 | 404:
        print("Not allowed")

Conclusiones

La introducción de un control de flujo tipo switch en Python 3.10 mediante la incorporación de Match-Case es una gran novedad. Un patrón que ya existía en otros lenguajes y permite la creación de código más legible, lo que es una gran noticia.

Imagen de herry wibisono en Pixabay