Python 3.14 y su nuevo compilador JIT

Marca un punto importante en la evolución del lenguaje de programación más popular del mundo. Si bien Python ha sido reconocido durante mucho tiempo por su legibilidad y su gran ecosistema, su velocidad de ejecución a menudo ha sido el "elefante en la sala".

Con la llegada de 3.14, el equipo de desarrollo central de CPython ha entregado no una, sino dos de las características más esperadas en los últimos tiempos.

El fin del GIL

Ya he escrito sobre esto antes. La verdadera concurrencia ahora está disponible en Python si la desea. Si desea obtener más detalles sobre Python sin GIL, dejaré un enlace a mi artículo al respecto al final.

El compilador Justo a tiempo (JIT)

Esta característica experimental ahora está incluida directamente en los instaladores oficiales y es en lo que nos centraremos aquí. Es el resultado de años de preparación arquitectónica realizada por el equipo central de Python y otros, con el objetivo de hacer que Python sea "más rápido por defecto" sin romper el ecosistema de extensión C que impulsa todo, desde la ciencia de datos hasta los backends web.

En este artículo, presentaremos el nuevo JIT, exploraremos cómo se diferencia de los esfuerzos de optimización anteriores y analizaremos algunas metodologías de evaluación comparativa para ayudarlo a decidir si es hora de probar el JIT en sus cargas de trabajo.

¿Qué es el nuevo compilador Just-In-Time (JIT) de Python?

Para comprender el JIT 3.14, necesitamos saber cómo se ejecuta tradicionalmente Python. Python estándar (CPython) es un lenguaje interpretado. Cuando ejecuta un script, su código se compila en código de bytes, que es un conjunto de instrucciones que ejecuta la máquina virtual CPython.

El JIT cambia este flujo. En lugar de simplemente interpretar el código de bytes línea por línea, el JIT monitorea qué partes de su código se ejecutan con mayor frecuencia (las rutas "calientes"). Cuando una función o bucle se considera "activo", el JIT traduce el código de bytes a código de máquina nativo (instrucciones que la CPU entiende). Luego, la próxima vez que se invoque el código, no se requiere interpretación. En cambio, simplemente se ejecuta tal como está. Esto puede suponer un gran ahorro de tiempo, como veremos más adelante.

Cómo encaja el JIT en CPython

El JIT de Python 3.14 no es una reescritura total. Está diseñado como un componente opcional que funciona junto con el intérprete existente. Utiliza una técnica llamada "copiar y parchear", que permite que JIT sea liviano y portátil en diferentes arquitecturas de CPU sin requerir un compilador backend enorme y complejo como LLVM.

¿Qué cambió en Python 3.14?

Python 3.13 tenía un JIT experimental básico, pero estaba deshabilitado de forma predeterminada. Si quería probarlo, tenía que clonar el árbol fuente de CPython y compilarlo con indicadores experimentales específicos como – enable-experimental-jit.

Con Python 3.14, todo cambió. Ofrecía el JIT en los instaladores oficiales .msi (Windows) y .pkg (macOS). También significó que ya no necesitaba un compilador de C en su máquina para experimentar los beneficios de JIT. Si bien sigue siendo "experimental", la inclusión en binarios oficiales indica que el equipo central cree que el JIT es lo suficientemente estable como para realizar pruebas en una comunidad amplia.

Obteniendo Python 3.14

Dirígete a https://www.python.org/downloads/ y verás una opción de descarga para 3.14. Haga clic en eso y luego siga las instrucciones.

Alternativamente, si tiene instalada la herramienta UV, puede escribir lo siguiente.

PS C: > instalación uv python 3.14

Habilitando el JIT

De forma predeterminada, el JIT está deshabilitado. Esta es una medida de seguridad; Debido a que es experimental, el Consejo Directivo de Python quiere garantizar que los usuarios no enfrenten regresiones inesperadas en la estabilidad o el uso de la memoria sin elegirlo explícitamente.

Para activar el JIT, utiliza una variable de entorno. Esto le indica al tiempo de ejecución de CPython que inicialice el motor JIT al inicio.

En Windows (PowerShell):

$entorno:PYTHON_JIT=1 python my_script.py

En macOS/Linux (Bash/Zsh):

PYTHON_JIT=1 python mi_script.py

Una vez habilitado, CPython no compila JIT todo inmediatamente. Utiliza un sistema de niveles. Básicamente, primero intenta ejecutar el código lo más barato posible y solo dedica esfuerzo de compilación/optimización a las partes que resultan ser interesantes.

Nivel 0: interpretación estándar. Nivel 1: código de bytes especializado (introducido en 3.11). Nivel 2 (JIT): generación de código de máquina para las rutas más utilizadas.

Medir el impacto del JIT

Al probar un JIT, no puede simplemente usar time.time() alrededor de una función. Los JIT requieren un período de calentamiento. Las primeras iteraciones de un bucle pueden ser más lentas de lo normal a medida que JIT perfila el código, pero las iteraciones posteriores pueden ser significativamente más rápidas.

La suite de referencia

A continuación se muestra un conjunto de pruebas integral diseñado para ejercitar diferentes aspectos del JIT, desde matemáticas pesadas hasta manipulación compleja de objetos.

Archivo 1: cargas de trabajo.py

Este archivo contiene tres tareas diferentes vinculadas a la CPU.

1/ La función Mandelbrot itera la fórmula de Mandelbrot sobre una cuadrícula de píxeles y devuelve una suma de comprobación de los recuentos de iteraciones por píxel.

2/ La función Djikstra construye un gráfico ponderado aleatorio determinista y ejecuta Dijkstra desde el nodo 0, devolviendo cuántos nodos fueron finalizados/visitados.

3/ La función Levenshtein genera N pares de cadenas aleatorias deterministas y devuelve la suma de sus distancias de Levenshtein

de __future__ importar anotaciones importar aleatorio importar heapq # Carga de trabajo 1: Mandelbrot (CPU + bucles matemáticos) def mandelbrot(ancho: int = 1000, alto: int = 1000, iters: int = 500) -> int: suma de comprobación = 0 para y en rango (alto): cy = (y / alto) * 2,4 – 1,2 para x en rango (ancho): cx = (x / ancho) * 3,2 – 2,2 zx, zy, recuento = 0,0, 0,0, 0 mientras zx * zx + zy * zy <= 4,0 y recuento < iters: zx, zy = zx * zx – zy * zy + cx, 2,0 * zx * zy + cy recuento += 1 suma de comprobación += recuento devuelve suma de comprobación # Carga de trabajo 2: Dijkstra (montón + lista + lógica) def dijkstra (n: int = 10000, bordes_por_nodo: int = 50, semilla: int = 123) -> int: rng = aleatorio. Gráfico aleatorio (semilla) = [[]para _ en rango(n)] para u en rango(n): para _ en rango(edges_per_node): v = rng.randrange(n) si v != u: gráfico[u].append((v, rng.randrange(1, 30))) dist = [10**12] * n dist[0]= 0 pq = [(0, 0)] visitó = 0 while pq: d, u = heapq.heappop(pq) if d != dist[u]: continuar visitado += 1 for v, w in graph[u]: nd = d + w if nd < dist[v]: dist[v] = nd heapq.heappush(pq, (nd, v)) return visitó # Carga de trabajo 3: distancia de Levenshtein (programación dinámica) def levenshtein(a: str, b: str) -> int: prev = list(range(len(b) + 1)) for i, ca in enumerate(a, 1): cur = [i] for j, cb in enumerate(b, 1): cur.append(min(cur[j – 1] + 1, prev[j] + 1, prev[j – 1] + (ca != cb))) prev = cur return prev[-1] def levenshtein_batch(n: int = 10000, seed: int = 7, k: int = 50) -> int: """ Lote determinista: semilla RNG fija, alfabeto fijo, longitud de cadena fija. Devuelve la suma de distancias. """ rng = random.Random(seed) alfabeto = "abc" total = 0 para _ en rango(n): a = "".join(rng.choices(alphabet, k=k)) b = "".join(rng.choices(alphabet, k=k)) total += levenshtein(a, b) devuelve total

Archivo 2: punto de referencia.py

Este script automatiza la comparación de diferentes cargas de trabajo con JIT habilitado y deshabilitado.

import os import time import json import subprocess from pathlib import Path PYTHON_EXE = r"C:UsersthomaAppDataLocalProgramsPythonPython314python.exe" PROJECT_DIR = Path(__file__).resolve().parent # Cargas de trabajo originales (la declaración imprime un resultado por razones de cordura) WORKLOADS = [ ("mandelbrot", 'from workloads import mandelbrot; print(mandelbrot())'), ("dijkstra", 'desde cargas de trabajo import dijkstra; print(dijkstra())'), ("levenshtein_batch", 'desde cargas de trabajo import levenshtein_batch; print(levenshtein_batch())'), ] N_RUNS = 10 # promedio de TODAS las ejecuciones (establecido en 6/10/20 como desee) OUTFILE = PROJECT_DIR / "results_avg.json" def run_once(stmt: str, jit_val: int) -> tuple[float, str]: env = os.environ.copy() env["PYTHON_JIT"] = str(jit_val) # Asegúrese de que workloads.py local sea importable en el subproceso env["PYTHONPATH"] = str(PROJECT_DIR) + (os.pathsep + env.get("PYTHONPATH", "")) t0 = time.perf_counter() p = subprocess.run( [PYTHON_EXE, "-c", stmt], env=env, cwd=str(PROJECT_DIR), capture_output=True, text=True, ) t1 = time.perf_counter() si p.returncode != 0: aumentar RuntimeError( f"Error de ejecución (PYTHON_JIT={jit_val})nn" f"Statement:n{stmt}nn" f"STDOUT:n{p.stdout}nnSTDERR:n{p.stderr}" ) return (t1 – t0, p.stdout.strip()) def resume(times: list[float]) -> dict: return { "avg": suma(veces) / len(veces), "min": min(veces), "max": max(veces), "ejecuciones": veces, } def bench_workload(nombre: str, stmt: str) -> dict: resultados = {} salidas = {} para jit_val en (0, 1): veces =[]salidas =[]print(f" PYTHON_JIT={jit_val}: ejecutando {N_RUNS} veces…") para i in range(1, N_RUNS + 1): dt, out = run_once(stmt, jit_val) times.append(dt) outs.append(out) print(f" run {i}/{N_RUNS}: {dt:.6f}s") resultados[jit_val] = resumir (veces) salidas [jit_val] = salidas avg0 = resultados[0]["promedio"] promedio1 = resultados[1]["avg"] aceleración = avg0 / avg1 si avg1 else float("inf") delta_pct = (avg1 – avg0) / avg0 * 100.0 si avg0 else 0.0 return { "workload": nombre, "jit0": resultados[0], "jit1": resultados[1], "speedup_jit0_over_jit1": aceleración, "delta_pct_jit1_vs_jit0": delta_pct, "outputs": salidas, # cordura: debe ser estable } def main() -> int: all_results =[]print(f"Usando Python: {PYTHON_EXE}") print(f"Director del proyecto: {PROJECT_DIR}") print(f"Ejecuciones por configuración (promedio de todas las ejecuciones): {N_RUNS}n") para nombre, stmt en CARGAS DE TRABAJO: print(f"=== {name} ===") r = bench_workload(name, stmt) all_results.append(r) print(f"n Promedios:") print(f" JIT=0 promedio: {r['jit0']['avg']:.6f}s (min {r['jit0']['min']:.6f}, max {r['jit0']['max']:.6f})") print(f" JIT=1 promedio: {r['jit1']['avg']:.6f}s (min {r['jit1']['min']:.6f}, max {r['jit1']['max']:.6f})") print(f" Aceleración (JIT=0 / JIT=1): {r['speedup_jit0_over_jit1']:.3f}× (Δ={r['delta_pct_jit1_vs_jit0']:+.2f}%)n") # Opcional: advertir si las salidas varían entre ejecuciones (no determinismo) if len(set(r["salidas"][0])) != 1: print(" !! ADVERTENCIA: la salida JIT=0 difiere entre ejecuciones (¿carga de trabajo no determinista?)") if len(set(r["outputs"][1])) != 1: print(" !! ADVERTENCIA: la salida JIT=1 difiere según las ejecuciones (¿carga de trabajo no determinista?)") OUTFILE.write_text(json.dumps(all_results, indent=2), encoding="utf-8") print(f"Wrote: {OUTFILE}") devuelve 0 si __name__ == "__main__": rise SystemExit(main())

Aquí están mis resultados.

C:Usersthomaprojectspython_jit>C:UsersthomaAppDataLocalProgramsPythonPython314python.exe benchmark.py Usando Python: C:UsersthomaAppDataLocalProgramsPythonPython314python.exe Directorio del proyecto: C:Usersthomaprojectspython_jit Ejecuciones por configuración (promedio de todas las ejecuciones): 10 === mandelbrot === PYTHON_JIT=0: ejecutándose 10 veces… ejecución 1/10: 6,890924s ejecución 2/10: 6,950737s ejecución 3/10: 7,265357s ejecución 4/10: 6,947150 s ejecutados 5/10: 6,932333 s ejecutados 6/10: 6,939378 s ejecutados 7/10: 7,194705 s ejecutados 8/10: 6,995550 s ejecutados 9/10: 6,902696 s ejecutados 10/10: 7.256164s PYTHON_JIT=1: ejecutando 10 veces… ejecución 1/10: 5.216740s ejecución 2/10: 5.241888s ejecución 3/10: 5.350822s ejecución 4/10: 5.246767s ejecución 5/10: 5.294771s ejecución 6/10: 5,273295 s ejecutados 7/10: 5,272135 s ejecutados 8/10: 5,617062 s ejecutados 9/10: 5,251656 s ejecutados 10/10: 5,239060 s Promedios: JIT=0 promedio: 7,027499 s (mín. 6,890924, máx. 7.265357) JIT=1 promedio: 5.300420s (min 5.216740, max 5.617062) Aceleración (JIT=0 / JIT=1): 1.326× (Δ=-24.58%) === dijkstra === PYTHON_JIT=0: corriendo 10 veces… corriendo 1/10: 0,235401s ejecutados 2/10: 0,227603s ejecutados 3/10: 0,244492s ejecutados 4/10: 0,232971s ejecutados 5/10: 0,249589s ejecutados 6/10: 0,232229s ejecutados 7/10: 0,229422s ejecutados 8/10: 0,238399s de ejecución 9/10: 0,230657s de ejecución 10/10: 0,235772s PYTHON_JIT=1: corriendo 10 veces… ejecución 1/10: 0,238862s de ejecución 2/10: 0,239266s de ejecución 3/10: 0,240312s ejecución 4/10: 0,231413 s ejecución 5/10: 0,232692 s ejecución 6/10: 0,233783 s ejecución 7/10: 0,230016 s ejecución 8/10: 0,237760 s ejecución 9/10: 0,240895 s ejecución 10/10: 0,246033s Promedios: JIT=0 promedio: 0,235653s (mín. 0,227603, máximo 0,249589) JIT=1 promedio: 0,237103s (mín. 0,230016, máximo 0,246033) Aceleración (JIT=0 / JIT=1): 0,994× (Δ=+0.62%) === levenshtein_batch === PYTHON_JIT=0: ejecutando 10 veces… ejecutando 1/10: 2.176256s ejecutando 2/10: 2.171253s ejecutando 3/10: 2.171834s ejecutando 4/10: 2.170444s ejecutando 5/10: 2.149874s ejecutados 6/10: 2.162820s ejecutados 7/10: 2.171975s ejecutados 8/10: 2.199151s ejecutados 9/10: 2.168398s ejecutados 10/10: 2.167821s PYTHON_JIT=1: ejecutando 10 veces… ejecutado 1/10: 1,575666s de carrera 2/10: 1,612615s de carrera 3/10: 1,571106s de carrera 4/10: 1,584650s de carrera 5/10: 1,579948s de carrera 6/10: 1,582633s de carrera 7/10: 1,593924s ejecución 8/10: 1,573608 s ejecución 9/10: 1,581427 s ejecución 10/10: 1,578553 s Promedios: JIT=0 promedio: 2,170983 s (mínimo 2,149874, máximo 2,199151) JIT=1 promedio: 1,583413 s (mínimo 1,571106, máx. 1,612615) Aceleración (JIT=0 / JIT=1): 1,371× (Δ=-27,06%)

Interpretación de los resultados

Como puede ver, los resultados son heterogéneos. Esto es normal para un JIT experimental.

Aceleración del 10 al 30%: común en bucles "Python puro" (como las pruebas de Mandelbrot o Levenshtein) donde el JIT puede evitar la sobrecarga del bucle de envío de código de bytes. Mejora del 0%: común en tareas vinculadas a E/S o código que utiliza en gran medida extensiones C. El código de Dijkstra no se aceleró porque su tiempo de ejecución está dominado por operaciones de montón/tupla y trabajo basado en asignación con mucha memoria que el CPython JIT actual no optimiza significativamente, por lo que cualquier ahorro de intérprete se pierde en el ruido.

Cuándo utilizar Python 3.14 JIT

El JIT es una herramienta poderosa, pero no es un “botón mágico”. Según mi experiencia, deberías probar el JIT cuando tengas…

Lógica vinculada a la CPU: su aplicación realiza cálculos pesados, procesamiento de datos o lógica compleja en Python puro. Procesos de larga duración: servidores web (Gunicorn/Uvicorn) o trabajadores en segundo plano (Celery) que se ejecutan durante horas, lo que permite al JIT suficiente tiempo para calentar y optimizar las rutas activas. Pruebas experimentales: desea preparar su código base para futuras versiones de Python (3.15+), donde el JIT probablemente será más agresivo.

Y evítalo cuando tengas…

Aplicaciones vinculadas a E/S: si su aplicación solo espera consultas de la base de datos o respuestas de la API, el JIT no ayudará. Entornos con memoria limitada: las funciones Lambda pequeñas o los contenedores diminutos pueden verse afectados por el aumento del uso de memoria de la caché JIT. Herramientas CLI de corta duración: un script que se ejecuta en menos de un segundo no necesita un JIT.

Direcciones futuras: más allá de 3.14

El equipo central de CPython considera 3.14 como el "año de fundación". Se espera que las iteraciones futuras (Python 3.15 y 3.16) incluyan:

Pases de optimización más profundos: uso de la información de tipo recopilada en tiempo de ejecución para realizar una generación de código de máquina aún más agresiva. Mejor heurística: decisiones más inteligentes sobre cuándo compilar, lo que reduce la penalización del "calentamiento". Reducir los gastos generales: perfeccionar el mecanismo de copia y parcheo para reducir el consumo de memoria.

Resumen

JIT de Python 3.14 es más que un simple parche de rendimiento. Es una declaración de intenciones. Demuestra que Python se toma en serio el objetivo de cerrar la brecha de rendimiento con lenguajes como Java o Go, manteniendo al mismo tiempo la simplicidad de "baterías incluidas" que lo hizo famoso.

Para la mayoría de los desarrolladores, JIT es simplemente otra herramienta a la que vale la pena prestar atención. Si el rendimiento es importante en sus proyectos, vale la pena probar Python 3.14 con sus cargas de trabajo existentes. Algunas pruebas comparativas de las rutas de código más importantes pueden revelar mejoras de rendimiento que no esperaba.

Aquí está el enlace a mi artículo anterior sobre GIL Fee Python, que mencioné al principio.