¡Última oportunidad! 50 % de descuento en todo
La oferta termina dentro de
Python ha ganado el premio de TIOBE a "Lenguaje del año" tres veces en los últimos cuatro años. A mitad de 2022, este popular lenguaje de programación sigue liderando el índice TIOBE.
Python encabeza el índice TIOBE en junio de 2022.
Que Python tenga una puntuación del 12,74% significa que la palabra clave «Python» apareció en ~13% de todas las búsquedas relacionadas con programación. En otras palabras, 1 de cada 7 u 8 preguntas sobre programación en Internet trata sobre Python.
Hoy, Python se asocia a menudo con los mayores avances en ciencia de datos e IA. Quienes lo usan valoran su sencillez, su amplio conjunto de librerías integradas y de terceros para multitud de tareas y su comunidad.
Con la versión final y estable de la 3.11 prevista para el 3 de octubre de 2022, la comunidad de Python puede esperar varias mejoras bienvenidas, como un aumento notable de la velocidad, mejor gestión de errores y depuración, y numerosos avances de usabilidad en las librerías estándar.
¿Cuáles son las novedades de Python 3.11?
El changelog de Python 3.11 es una lista casi interminable de correcciones, mejoras y añadidos, muchos de los cuales quizá ni notes. Aun así, hay algunas novedades clave que pueden mejorar bastante tu flujo de trabajo cuando llegue la versión estable. Te las resumimos a continuación.
1. Mejora de velocidad
El primer gran cambio que entusiasmará a quienes trabajan con datos es la mejora de rendimiento: el conjunto estándar de benchmarks se ejecuta alrededor de un 25% más rápido que en la 3.10. La documentación afirma que 3.11 puede ser hasta un 60% más rápido en ciertos casos. Aquí tienes cómo hacer tú mismo la prueba de rendimiento para comprobarlo.
Para comparar las velocidades de Python 3.10 y 3.11, necesitarás una instalación de Docker. Tras asegurarte de que Docker Desktop está en marcha, ejecuta estos dos comandos en el terminal; descargarán dos imágenes para las dos versiones de Python.
$ docker run -d python:3.10.4-bullseye
$ docker run -d python:3.11-rc-bullseyeDeberías ver las imágenes descargadas en tu panel de Docker, desde donde también puedes iniciarlas.
Después de lanzar los contenedores, puedes ejecutar docker ps para ver detalles como el ID del contenedor, la imagen, su estado y más.
Los contenedores en ejecución también se ven en la pestaña Containers del panel, donde encontrarás botones de CLI junto a "Run/Stop". Haz clic en ambos para abrir dos pestañas de terminal conectadas a los contenedores.
En ambas pestañas, instala el paquete pyperformance con pip. Luego, ejecuta estos comandos en cada terminal del contenedor.
Para Python 3.10
$ pyperformance run -r -o py310.jsonPara Python 3.11
$ pyperformance run -r -o py310.jsone run -r -o py311.jsonEstos comandos ejecutarán pruebas de rendimiento para unas 60 funciones de Python de las librerías estándar y generarán metadatos en JSON. He añadido opcionalmente la etiqueta -r para pedir a pyperformance que haga pruebas más rigurosas, lo que lleva más tiempo. En mi caso, ambos contenedores se ejecutan en una máquina Windows con una CPU AMD Ryzen de 12 núcleos.
Ahora tenemos dos archivos JSON en dos contenedores y necesitamos poner ambos en un único directorio para continuar con la prueba. Para ello usaremos el comando docker cp y copiaremos el archivo JSON del contenedor de Python 3.11 al de 3.10.
Ejecuta estos comandos en una pestaña de terminal aparte, actualizando la ruta para que coincida con tu equipo:
$ docker cp crazy_snyder:/py311.json C:/Users/bex/Desktop
$ docker cp C:/Users/bex/Desktop/py311.json charming_proskuriakova:/En mi caso, crazy_snyder y charming_proskuriakova son los IDs de los contenedores en ejecución. Ya están ambos JSON en el contenedor de Python 3.10. Para completar el benchmark y guardar los resultados en CSV, ejecuta estos comandos.
$ pyperformance compare py310.json py311.json --csv comparison.csv
$ docker cp charming_proskuriakova:/comparison.csv C:/Users/bex/Desktop/articlesPor último, cargamos el CSV en Pandas y lo analizamos:
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
df = pd.read_csv("data/comparison.csv")
df.rename({"Base": "py310", "Changed": "py311", "Benchmark": "function"},
axis=1,
inplace=True)>>> df.shape
(59, 3)>>> df.sample(5)
| Function | py310 | py311 | |
| 40 | scimark_monte_carlo |
0.12392 | 0.08052 |
| 19 | mako |
0.01967 | 0.01289 |
| 1 | chameleon |
0.01131 | 0.00843 |
| 8 | float |
0.14265 | 0.09133 |
| 35 | regex_effbot |
0.00315 | 0.00261 |
Cada fila del dataframe registra cuánto tiempo (en milisegundos) tardaron ambas versiones en ejecutar la función. Vamos a representar un histograma de las mejoras.
df["speed_up"] = (df["py310"] / df["py311"]).round(3)
fig, ax = plt.subplots()
sns.histplot(df["speed_up"], bins=11)
ax.set(xlabel="Speedup (times)",
title="Python 3.10 vs. Python 3.11 - speedup comparison")
plt.show()
El gráfico deja claro que la mayoría de funciones en Python 3.11 fueron aproximadamente 1,2 veces (un 20%) más rápidas. Podemos confirmarlo con la media y la mediana.
>>> df["speed_up"].mean()
1.2605593220338982>>> df["speed_up"].median()
1.207Parece que hay un caso en el que el aumento de velocidad supera el 60%.
>>> df["speed_up"].max()
1.899También hay cuatro casos en los que Python 3.10 fue más rápido que la nueva versión.
>>> (df["speed_up"] <= 1).sum()
4Aunque las mejoras de rendimiento se notan sobre el papel, su impacto real variará según el caso y aún falta la publicación de la versión estable definitiva de Python 3.11. El benchmark usa funciones puras de Python, que quizá no utilices tanto en tu trabajo diario, pero configurar Docker con Python 3.10 y 3.11 te permitirá estimar el aumento de velocidad en tus propios casos de uso.
2. Mejores mensajes de error
Otra novedad interesante de Python 3.11 son los mensajes de error mejorados, que señalan el lugar exacto del fallo. En lugar de devolver un traceback de 100 líneas que termina en un mensaje difícil de interpretar, Python 3.11 apunta a la expresión concreta que causó el error.
En el ejemplo anterior, el intérprete de Python señala la x que hizo fallar el script por su valor None. El error habría sido ambiguo en versiones actuales de Python, ya que hay dos objetos con el atributo «x». Sin embargo, el manejo de errores de la 3.11 destaca claramente la expresión problemática.
Este ejemplo muestra cómo la 3.11 detecta un error en un diccionario profundamente anidado e indica con claridad a qué clave pertenece el error.
La misma precisión se aprecia en expresiones aritméticas complejas.
Estos mensajes de error mejorados son, sin duda, un añadido bien recibido, especialmente para quienes se pelean con la depuración de scripts.
3. Notas en excepciones
«Explícito es mejor que implícito.»
Esta es la segunda línea del Zen de Python, una lista con 20 principios de diseño del lenguaje. Representa la idea de que el código Python debe ser lo más expresivo posible.
Para reforzar este patrón de diseño, Python 3.11 introduce las notas en excepciones (PEP 678). Ahora, dentro de tus cláusulas except, puedes llamar a la función add_note() y pasar un mensaje personalizado cuando lances un error.
import math
try:
math.sqrt(-1)
except ValueError as e:
e.add_note("Negative value passed! Please try again.")
raise
Si has escrito una clase de excepción personalizada como la de abajo, puedes añadir varias notas a la clase dentro del atributo protegido a nivel de clase __notes__:
import math
class MyOwnError(Exception):
# Should be a list of strings
__notes__ = ["This is a custom error!"]
try:
math.sqrt(-1)
except:
raise MyOwnError
Ahora, cuando el intérprete llegue al error, mostrará el mensaje personalizado tras el cuerpo del mensaje habitual.
También hay una nueva sintaxis para lanzar excepciones con la cláusula except*, que se usa junto con la nueva clase ExceptionGroup. La PEP 654 indica que puedes usarla para lanzar simultáneamente varios errores no relacionados en distintos escenarios. La mayoría de estos casos son bastante específicos, como trabajar con websockets, programar concurrentemente con asyncio, etc., poco habituales en el día a día de la ciencia de datos, pero si te interesa puedes profundizar en la nueva sintaxis aquí.
4. Nueva característica de typing: Self
Los lenguajes estáticamente tipados ayudan a que tu código sea más legible y fácil de depurar. Definir el tipo exacto de variables, entradas y salidas de funciones puede ahorrarte horas de depuración y facilitar que otras personas lean tu código. Añadir anotaciones de tipos también permite que los IDE modernos muestren definiciones de funciones mientras escribes sus nombres, haciendo que tus funciones sean más fáciles de interpretar.
Hasta ahora, el potente módulo typing de Python tenía clases para prácticamente cualquier tipo de dato, salvo para clases que devuelven instancias de sí mismas. En las versiones actuales de Python, el ejemplo siguiente no es posible:
from typing import Self
class Language:
def __init__(self, name, version, release_date):
self.name = name
self.version = version
self.release_date = release_date
def change_version(self, version) -> Self:
self.version = version
return Language(self.name, self.version, self.release_date)
Sin embargo, Python 3.11 introduce la clase Self, que puedes añadir a la definición de una función si su valor de retorno es self o una nueva instancia de la propia clase.
5. Mejoras en las librerías estándar
Hay otras mejoras de usabilidad en las librerías estándar. Para empezar, se añaden dos funciones muy esperadas al módulo math.
>>> import math
>>> math.cbrt(9) # Find the cube-root of x
2.080083823051904
>>> math.cbrt(27)
3.0000000000000004
>>> math.exp2(5) # Raise 2 to the power of x
32.0Que Python haya tardado 28 años en añadir la función de raíz cúbica sorprende, pero, como se suele decir, nunca es tarde si la dicha es buena.
El módulo fractions también incorpora una novedad que permite crear fracciones a partir de cadenas:
>>> from fractions import Fraction
>>> Fraction("22/7") # New in Python 3.11
Fraction(22, 7)
>>> Fraction(numerator=22, denominator=7)
Fraction(22, 7)
>>> Fraction("3e-4")
Fraction(3, 10000)
>>> Fraction("-73/41")
Fraction(-73, 41)
>>> Fraction(3.1415) # Find the closest approximation to the given float
Fraction(7074029114692207, 2251799813685248)Como ves, el módulo fractions puede ser muy útil para ciertas operaciones aritméticas. En particular, es interesante cómo encuentra la fracción más cercana que aproxima a un float dado. Puedes ir un paso más allá limitando el denominador:
>>> from math import pi
>>> Fraction(pi).limit_denominator(100000)
Fraction(312689, 99532)También hay un módulo nuevo, tomllib, para parsear documentos TOML. TOML (Tom's Obvious Minimal Language) es un formato popular para escribir archivos de configuración legibles por humanos. Esta imagen es de la página del proyecto:
import tomllib
toml_str = """
python-version = "3.11.0"
release_date = "2022-10-22"
"""
data = tomllib.loads(toml_str)
print(data) # {'python-version': '3.11.0', 'release_date': '2022-10-22'}
print(data['python-version']) # 3.11.0
print(data['release_date']) # 2022-10-22Fecha de lanzamiento de Python 3.11
El desarrollo de Python 3.11 comenzó el 5 de mayo de 2021. Desde entonces se han publicado siete versiones alfa, coincidiendo con la primera beta el 8 de mayo de 2022. A partir de esa fecha y hasta el lanzamiento oficial no se introducirán nuevas funciones en Python.
La versión final y estable saldrá el 3 de octubre de 2022, tras tres betas más y dos candidatas entre medias. Puedes aprender más sobre Python consultando estos recursos.
