Python
Rendimiento de Python 3.15: ¿qué se volvió realmente más rápido?
Descubre qué mejoró realmente en Python 3.15: JIT, startup, librería estándar, profiling y cómo medir tu propio código.
En este artículo
Python 3.15 incluye trabajo real de rendimiento, pero la forma más útil de entenderlo no es buscar un único número como “Python 3.15 es X % más rápido”.
No existe un porcentaje universal responsable.
El rendimiento depende de lo que ejecutes, la plataforma, el build del intérprete, si el JIT experimental está activado, cuánto trabajo ocurre en librerías nativas y si el problema real es el arranque o la ejecución sostenida.
Los cambios más importantes son:
- JIT experimental mucho más capaz;
- intérprete tail-calling en binarios oficiales Windows 64 bits;
- imports perezosos explícitos para reducir trabajo de startup;
- varias operaciones de la librería estándar más rápidas;
- un nuevo profiler por muestreo;
- frame pointers habilitados por defecto cuando la plataforma lo soporta.
Respuesta rápida
Python 3.15 puede ser más rápido que Python 3.14, pero no de manera uniforme.
Los resultados oficiales más llamativos del JIT son:
- 7–8 % de mejora media geométrica frente al intérprete optimizado estándar en Linux x86-64;
- 11–12 % de mejora frente al intérprete tail-calling en macOS AArch64.
Sin embargo, workloads individuales van desde regresiones hasta mejoras muy grandes.
La documentación oficial informa resultados desde aproximadamente 15 % más lento hasta más de 100 % más rápido en benchmarks concretos.
Rendimiento de Python 3.15 de un vistazo
| Área | Python 3.14 | Python 3.15 | Por qué importa |
|---|---|---|---|
| JIT experimental | Temprano, con cobertura limitada | Nuevo tracing, registros y optimizaciones | Más cargas pueden beneficiarse |
| Startup/import | Imports eager tradicionales | Imports perezosos explícitos | Se pueden diferir dependencias opcionales |
| Windows | Configuración anterior | Intérprete tail-calling | Ganancias específicas de plataforma |
| Profiling | Herramientas existentes | profiling + Tachyon |
Mejor diagnóstico |
| Observabilidad nativa | Depende del build | Frame pointers por defecto | Mejor stack unwinding |
| Base64 | Implementación previa | ~2× encode, ~3× decode | Mejora dirigida |
| Base32/Base85 | Implementación previa | Reescritura en C | Grandes mejoras específicas |
| CSV sniffing | Baseline | csv.Sniffer.sniff() hasta 1,6× |
Útil en herramientas de descubrimiento |
La historia principal: el JIT experimental mejorado
Python 3.14 ya facilitaba probar el JIT.
Python 3.15 lo amplía con:
- nuevo frontend de tracing;
- más bytecode y control de flujo;
- asignación básica de registros;
- más optimizaciones;
- mejor generación de código;
- mejor unwinding.
La mayor cobertura permite que más código real entre en trazas optimizadas.
¿Qué significan realmente los números oficiales?
| Plataforma / comparación | Resultado oficial |
|---|---|
| Linux x86-64, JIT vs CPython optimizado estándar | 7–8 % |
| macOS AArch64, JIT vs intérprete tail-calling | 11–12 % |
| Workloads individuales | aproximadamente -15 % a >100 % |
Estas medias no son promesas para tu servicio, ETL, CLI o notebook.
Una aplicación CPU-bound en Python puro puede beneficiarse mucho más que una aplicación dominada por bases de datos, red o NumPy.
Mide tu código, no Python en abstracto
Puedes comenzar con un harness sencillo:
from statistics import median
from time import perf_counter
def benchmark(fn, iterations=10_000, repeats=7):
samples = []
for _ in range(repeats):
start = perf_counter()
for _ in range(iterations):
fn()
samples.append(perf_counter() - start)
return {
"best": min(samples),
"median": median(samples),
"worst": max(samples),
}
Y un workload representativo:
def workload():
values = [n * n for n in range(100)]
return sum(values)
print(benchmark(workload))
No reemplaza pyperformance ni pyperf. Solo enseña la metodología correcta.
Comparar Python 3.14 y 3.15
En Windows:
py -3.14 benchmark.py
py -3.15 benchmark.py
En sistemas con ejecutables separados:
python3.14 benchmark.py
python3.15 benchmark.py
Para que la comparación tenga sentido:
- usa la misma máquina;
- evita cargas paralelas;
- usa las mismas dependencias;
- calienta workloads largos;
- repite varias veces;
- compara medianas;
- separa startup de steady-state;
- mide flujos end-to-end;
- cambia una sola variable;
- registra el build exacto y el SO.
Prueba el JIT por separado
No mezcles “3.14 vs 3.15” con “JIT vs no JIT”.
Una mejor matriz:
| Run | Python | JIT |
|---|---|---|
| A | 3.14 | Off |
| B | 3.15 | Off |
| C | 3.15 | On |
Eso responde dos preguntas diferentes:
- ¿mejoró el runtime base?
- ¿ayuda el JIT experimental a este workload?
Los imports perezosos atacan startup, no throughput CPU
Los imports perezosos explícitos retrasan el trabajo hasta el primer uso:
lazy import json
lazy from pathlib import Path
print("CLI is ready")
def load_config(raw):
return json.loads(raw)
def output_path(name):
return Path(name)
En una aplicación con muchas funciones opcionales, esto evita trabajo de importación en rutas que nunca usan esas funciones. Las CLI, funciones serverless, gestores de paquetes, utilidades administrativas, sistemas de plugins y frameworks grandes con subsistemas opcionales son buenos candidatos.
Medir directamente el coste de importación
Python ofrece medición de imports:
python -X importtime app.py
Úsala para localizar imports pesados antes de hacerlos perezosos. Si el módulo siempre se usa inmediatamente, el coste solo se desplaza. Si una dependencia pesada solo se necesita en una pequeña parte de las ejecuciones, diferirla puede mejorar de forma material la ruta habitual.
Las mejoras de librería estándar pueden ser importantes
Base64
La documentación de 3.15 reporta aproximadamente 2× en codificación y 3× en decodificación.
Base32/Base85
Partes de estas implementaciones fueron reescritas en C con mejoras grandes.
CSV delimiter detection
csv.Sniffer.sniff() puede ser hasta 1,6× más rápido:
import csv
with open("incoming.csv", newline="", encoding="utf-8") as file:
sample = file.read(4096)
dialect = csv.Sniffer().sniff(sample)
print(dialect.delimiter)
Para herramientas que reciben muchos CSV desconocidos esto puede importar; para pipelines con delimitador conocido, no tanto.
Windows recibe un cambio importante de intérprete
Los binarios oficiales Windows 64 bits usan el intérprete tail-calling.
La documentación muestra mejoras fuertes en la configuración probada, pero no significa que todas las aplicaciones Windows sean 20 % más rápidas.
El profiling mejora, y eso puede importar más que la velocidad bruta
Python 3.15 añade profiling y Tachyon.
Tachyon puede:
- perfilar un PID;
- lanzar y perfilar scripts;
- perfilar módulos;
- muestrear CPU y wall-clock;
- analizar GIL y excepciones;
- producir datos para flame graphs.
Eso cambia el flujo de:
guess
→ optimize
→ hope
a:
measure
→ locate hot path
→ optimize
→ measure again
Frame pointers mejoran observabilidad del sistema
CPython 3.15 activa frame pointers por defecto cuando la plataforma lo soporta.
Eso facilita el stack unwinding en profilers del sistema, debuggers y herramientas eBPF.
¿Y free-threading?
Free-threading sigue evolucionando y Python 3.15 añade trabajo ABI/C-API importante.
Pero no es una promesa de rendimiento single-thread.
JIT, free-threading y CPython estándar deben tratarse como configuraciones distintas.
Qué significa esto para data engineers
PySpark
Gran parte del trabajo se ejecuta en Spark/JVM. Acelerar el driver Python no significa que una transformación Spark grande mejore 8 %.
pandas y NumPy
Muchas operaciones pesadas ocurren en código nativo.
ETL y orquestación
La lógica Python alrededor de metadatos, validación, imports y encoding puede beneficiarse más directamente.
Serverless y jobs cortos
El startup puede importar más que el throughput sostenido.
Relevancia por workload
| Workload | Relevancia probable de Python 3.15 |
|---|---|
| CLI/startup pesado | Potencial alto |
| Loops CPU en Python puro | Vale la pena medir |
| APIs web largas | Depende del workload |
| Serverless | Startup puede importar mucho |
| pandas/NumPy vectorizado | Menor impacto del intérprete |
| PySpark | Mucho trabajo fuera de CPython |
| Automation I/O-bound | Impacto modesto |
| Procesamiento Base64 | Puede haber ganancias específicas |
| Descubrimiento CSV | Sniffing más rápido |
| Apps con extensiones nativas | Depende de dependencias |
Plan práctico de benchmark
Si evaluara Python 3.15 para un servicio de producción, seguiría esta secuencia.
1. Documenta la baseline
Registra la versión de parche de Python 3.14, sistema operativo, CPU, dependencias, configuración y entradas representativas.
2. Cambia solo Python
Crea un entorno Python 3.15 con dependencias equivalentes y ejecuta la misma suite de pruebas.
3. Mide el arranque por separado
En CLI y aplicaciones cortas, separa el arranque y los imports de la ejecución sostenida.
4. Mide escenarios end-to-end
Mide operaciones de negocio: procesar 10 000 registros, completar una petición API, validar un archivo representativo, generar un informe o ejecutar un paso ETL local.
5. Prueba el JIT como variante separada
Compara la baseline de 3.15 con la misma versión y el JIT activado.
6. Perfila antes de optimizar
Comprueba con profiling si la ejecución de Python es realmente el cuello de botella.
7. Repite
Ejecuta suficientes muestras para distinguir una mejora real del ruido del sistema.
¿La performance sola justifica actualizar?
Normalmente, no.
También importan:
- compatibilidad de dependencias;
- imágenes de despliegue;
- CI;
- extensiones nativas;
- observabilidad;
- runtime administrado;
- riesgo operacional.
Pero Python 3.15 es particularmente interesante porque varias áreas mejoran simultáneamente.
Conclusión
La mejor forma de describirlo es:
Python 3.15 crea más oportunidades de mejora de rendimiento, pero todavía debes medir cuáles aplican a tu workload.
El JIT es más capaz, los imports perezosos reducen startup, algunos puntos de la librería estándar son más rápidos, Windows cambia de intérprete y el profiling mejora.
No existe un porcentaje universal.
Mide lo que realmente esperan tus usuarios. Para las decisiones de actualización relacionadas, consulta la comparación de Python 3.15 y 3.14. Para la evolución entre varias versiones, usa la guía de actualización de Python 3.11 a 3.15.
Referencias oficiales
- Python 3.15.0 release: https://www.python.org/downloads/release/python-3150/
- What’s New in Python 3.15: https://docs.python.org/3.15/whatsnew/3.15.html
- What’s New in Python 3.14: https://docs.python.org/3.14/whatsnew/3.14.html
- PEP 810 — Explicit lazy imports: https://peps.python.org/pep-0810/
- PEP 799 — Profiling package / Tachyon: https://peps.python.org/pep-0799/
- PEP 831 — Frame pointers by default: https://peps.python.org/pep-0831/
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Sigue aprendiendo
- Guía rápidaInspeccionar un DataFrame de pandasInspecciona un DataFrame de pandas de forma rápida y segura para entender su forma, columnas, tipos de datos, nulos, duplicados, distribuciones y valores sospechosos antes de transformar los datos.Abrir guía rápida
- ArtículoPython 3.15 vs 3.11: novedades y guía de actualizaciónDescubre los cambios de Python 3.11 a 3.15, las novedades de cada versión, los riesgos de compatibilidad y cómo planificar la actualización.Leer artículo
¿Qué debería crear después?
Estoy construyendo Javi Builds alrededor de problemas reales que enfrentan los ingenieros de datos. Dime qué tema te gustaría ver después.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.