Nos encontramos en octubre, y como ya es costumbre en Python, hace un par de días se libero la versión 3.11 del lenguaje. Una versión que promete muchas cosas interesantes. 🥳

Es por ello que en esta ocasión me gustaría listarte alguno de los features más interesantes que podremos encontrar en esta nueva versión.

Así que, en lo que descargas e instalas esta nueva versión (Te comparto el link de la página oficial), hablemos de lo nuevo de Python. 🐍

Bien, sin más dilación comencemos con esta nueva entrega.

Mejor performance ✅

Comencemos hablando del performance. Y esto no es de extrañarse, ya que cada nueva versión de un lenguaje de programación promete ser mucho más veloz que sus versiones anteriores. Y en este caso con la versión 3.11 no es la excepción.

Para este post, en Pytwombat, nos dimos a la tarea de comparar la versión 3.11 de Python con su antecesor, la versión 3.10, y mediante un pequeño script de suma, podemos percatarnos que, en efecto, esta nueva versión es mucho más veloz que su versión anterior.

import time

def timer_track(function):
    def wrapper(*args, **kwargs):

        start = time.time()
        function(*args, **kwargs)
        print(f'{ time.time() - start }')

    return wrapper

@timer_track
def example():
    sum =  0
    for _ in range(1_000_000_000):
        sum += 1

example()

Salida con Python 3.10

>>> python3.10 main.py
0.62278103...

Salida 3.11Salida con Python 3.11

>>> python3.11 main.py
0.4767448902...

Si deseas ver la captura de pantalla para este ejemplo puedes acceder al siguiente enlace.

¿Bastante cool, no lo crees?

Y por si te lo estas preguntando, las características de la computadoras son: core i7 y 32GB de RAM. Te invito a que hagas tus propias prueba con ejemplos mucho más complejos.

Ubicación de errores 👾

Ahora hablemos de los mensajes de errores en el lenguaje, un tema que Python ya ha trabajando en versiones anteriores. Y no es que el tema de errores fuera malo, simplemente que ahora los errores son mucho más descriptivos.

Para esta nueve versión se implementa lo que se conoce como error locations, una forma rápida y sencilla de poder identificar el causante del, o los errores.

Aquí un par de ejemplos.

numeros = [1, 2, 3, 4, 5]
numeros[10]

Para este ejemplo si intentamos obtener el elemento de un índice que no existe, el mensaje de error será el siguiente.

return lista[index]
    numeros[10]
   ~~~~~~~^^^^
IndexError: list index out of range

Un mensaje bastante descriptivo, pudiendo así identificar de forma rápidamente el causante del error.

Otro ejemplo puede ser al tratar de dividir sobre 0.

number1 = 10
number2 = 0

result = number1 / number2

Para este segundo ejemplo el mensaje de error posee el siguiente formato.

result = number1 / number2
             ~~~~~~~~^~~~~~~~~
ZeroDivisionError: division by zero

Cómo podemos observar los mensajes son muy puntales sobre qué parte del código fue el culpable de lanzar la excepción. Algo muy parecido a lo que podemos encontrar en Rust. 🦀

Desde mi punto de vista algo super útil.

Anotación Self 🤠

Algo que sin duda debemos destacar de Python en sus últimas versiones, es sin duda la incorporación de anotaciones al lenguaje. Una forma muy eficiente de poder identificar el "tipo" para nuestras variables.

Si no conoces el tema de anotaciones te comparto el link a un post en PyWombat donde hablamos acerca de ellas.

Pues bien, en esta nueva versión de Python podemos encontrar la anotación Self; una anotación diseñada para denotar el objeto Per se.

Esta nueva anotación la encontraremos en el módulo typing.

from typing import Self

class User():

    def user(self, username:str, email:str) -> Self:
        self.username = username
        self.email = email

        return self

Obteniendo así, un código mucho más legible. 🤠

Grupo de Excepciones

Ya nos encontramos en la recta final y vamos a finalizar con el tema de Excepciones.

Para esta nueva versión de Python encontraremos el feature de Exception Group, con el cual seremos capaces de lanzar múltiples excepciones en una sola sentencia. Para estos vamos a usar la clase ExceptionGroup que toma como argumento 2 valores. El primero, el nombre del grupo, y el segundo, un listado de Excepciones que serán lanzadas como errores.

Aquí un ejemplo.

group_exception = ExceptionGroup('PyWombatErrors', [
    ValueError('Lo sentimo, el error no es valido.'),
    NameError('Lo sentimo, el nombre no es valido.')
])

raise group_exception

Esto nos dará como salida el siguiente output.

  + Exception Group Traceback (most recent call last):
  |     raise group_exception
  | ExceptionGroup: PyWombatErrors (2 sub-exceptions)
  +-+---------------- 1 ----------------
    | ValueError: Lo sentimo, el error no es valido.
    +---------------- 2 ----------------
    | NameError: Lo sentimo, el nombre no es valido.

Esto por supuesto podemos manejarlo mediante bloques de Excepciones. 😎

try:

    raise group_exception

except* ValueError as err:
    print(err.message)

except* NameError as err:
    print(err.message)

Notas en Excepciones

Continuando con el tema de Excepciones, y ya para finalizar el post, un feature que en lo personal se me es muy interesante, son las notas sobre las excepciones. Así como a lees, a las instancias de excepciones es posible añadirles notas.

error = ValueError('Lo sentimo, el error no es valido.')

error.add_note('Nueva nota para Python 3.11')
error.add_note('Nueva nota para PyWombat')

print(error.__notes__) # Accedemos al listado de notas

Obteniendo como salida el listado de notas.

['Nueva nota para Python 3.11', 'Nueva nota para PyWombat']

Y si lanzamos la excepción las anotaciones las podremos ver en consola.

>>> raise error

ValueError: Lo sentimo, el error no es valido.
Nueva nota para Python 3.11
Nueva nota para PyWombat

Conclusión

En conclusión, como pudimos observar Python añade cosas muy interesantes al lenguaje, y no solo eso, si no además, da continuidad a features implementados hace un par de versiones, algo que sin duda nos deja tranquilos como desarrolladores, puesto que da la confianza sobre hacía donde se dirige el lenguaje. Son features que sin duda fueron planeados a largo plazo y podemos ver los avances de ellos. 🥳

En mi opinión esta versión fue bástate regular. No es mala sin duda alguna, pero si se encuentra lejos de la versión 3.10 que nos ofreció joyas como la integración del switch al lenguaje. 🍻