Python
Python 3.15 vs 3.11: novedades y guía de actualización
Descubre 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.
En este artículo
Python 3.15.0 se publicó el 9 de octubre de 2026. Si todavía usas Python 3.11, no vas una versión por detrás, sino cuatro. Y Python 3.11 solo recibe correcciones de seguridad hasta octubre de 2027.
Esta guía responde a una sola pregunta:
¿Qué cambió entre Python 3.11 y Python 3.15, y qué importa realmente a los desarrolladores?
Cada funcionalidad aparece con la versión en la que realmente llegó. Mucho de lo que se presenta como “nuevo en 3.15” llegó en 3.12, 3.13 o 3.14. Si actualizas directamente desde 3.11, recibes todo a la vez, incluidos todos los cambios incompatibles.
Todos los ejemplos de código se ejecutaron en la versión oficial de CPython 3.15.0. Cada uno indica la versión mínima que necesita.
Esta guía recorre los cambios de Python versión por versión, de 3.11 a 3.15. El hub de Python reúne el recorrido completo.
Respuesta rápida
- ¿3.15 es una actualización importante respecto a 3.11? Sí. El lenguaje, el tipado, los mensajes de error, las herramientas de profiling y el runtime han mejorado mucho. Algunas de las novedades más útiles para el código de aplicación son propias de 3.15:
lazy import,frozendict,sentinely UTF-8 como codificación por defecto. - Quién debería actualizar ya: los equipos que controlan su runtime (APIs, CLIs, contenedores, workers de automatización) y cuyas dependencias ya publican wheels para 3.15.
- Quién debería esperar: quienes usan plataformas gestionadas (notebooks, Spark, serverless) que todavía no ofrecen 3.15, y quienes tienen dependencias compiladas que aún no están listas.
- Principal advertencia: pasar de 3.11 a 3.15 supone absorber cuatro rondas de eliminaciones y cambios de comportamiento. Las dos que más pueden sorprenderte son UTF-8 como codificación de texto por defecto (3.15) y los módulos eliminados en 3.12 y 3.13 (
distutils,imp,cgi,telnetlib,lib2to3y otros). - Rendimiento: no existe una cifra oficial del tipo “3.15 es un X % más rápido que 3.11”, y este artículo no se la inventa. Las cifras verificadas dependen de la carga de trabajo y aparecen en la sección de rendimiento.
¿Ya usas 3.14? Consulta la comparación específica de Python 3.15 y 3.14. Para las cifras del JIT y un plan de medición reproducible, lee el análisis de rendimiento de Python 3.15.
De Python 3.11 a 3.15: cronología de versiones
| Versión | Publicación | Soporte (oct. 2026) | Cambios principales |
|---|---|---|---|
| 3.11 | Oct. 2022 | Solo seguridad, hasta oct. 2027 | CPython más rápido (alrededor de 1,25× vs 3.10 de media), ubicación precisa de errores en tracebacks, ExceptionGroup y except*, asyncio.TaskGroup, tomllib, typing.Self |
| 3.12 | Oct. 2023 | Solo seguridad, hasta oct. 2028 | Sentencia type y sintaxis genérica def f[T](), f-strings más flexibles, inlining de comprehensions, sys.monitoring, soporte de perf en Linux, itertools.batched; se elimina distutils |
| 3.13 | Oct. 2024 | Solo seguridad, hasta oct. 2029 | Nuevo REPL interactivo, tracebacks en color, build free-threaded experimental, JIT experimental (opción de compilación), copy.replace(), warnings.deprecated; se eliminan 19 módulos antiguos |
| 3.14 | Oct. 2025 | Corrección de bugs, hasta oct. 2030 | Build free-threaded con soporte oficial, anotaciones diferidas, template strings (t"..."), except A, B: sin paréntesis, concurrent.interpreters, compression.zstd, JIT incluido en los binarios de Windows/macOS (desactivado por defecto) |
| 3.15 | Oct. 2026 | Corrección de bugs, hasta oct. 2031 | lazy import, frozendict, sentinel, UTF-8 por defecto, unpacking en comprehensions, paquete profiling con el profiler por muestreo Tachyon, frame pointers por defecto, ABI estable abi3t para extensiones free-threaded, JIT mejorado (todavía experimental) |
Desde 3.13, cada versión recibe dos años de corrección de bugs y luego tres años de parches de seguridad. Python 3.15 tiene soporte hasta aproximadamente octubre de 2031.
Python 3.11 vs 3.15 de un vistazo
| Área | Python 3.11 | Python 3.15 (y cuándo cambió) |
|---|---|---|
| Intérprete | Intérprete adaptativo especializado (nuevo en 3.11) | La misma base, más inlining de comprehensions (3.12) y un intérprete tail-calling en los binarios oficiales de Windows x64 (3.15) |
| JIT | No hay | Experimental y desactivado por defecto. Opción de compilación en 3.13, incluido en los binarios de Windows/macOS en 3.14, muy mejorado en 3.15 |
| Threads multinúcleo | GIL siempre activo | Build free-threaded opcional: experimental en 3.13, con soporte oficial en 3.14, ABI estable para extensiones (abi3t) en 3.15 |
| Arranque/imports | Todos los imports son inmediatos | lazy import explícito (3.15) |
| Lenguaje | match, except* |
f-strings más flexibles (3.12), templates t"..." (3.14), except A, B: (3.14), [*x for x in xs] (3.15) |
| Tipos integrados | dict, sentinels con object() |
Built-ins frozendict y sentinel (3.15) |
| Tipado | Self, LiteralString, TypeVarTuple |
Alias type y sintaxis [T] (3.12), @override (3.12), TypeIs y ReadOnly (3.13), anotaciones diferidas (3.14), TypedDict cerrado y TypeForm (3.15) |
| Codificación de texto por defecto | Depende de la configuración regional (a menudo cp1252 en Windows) |
UTF-8 en todas partes (3.15) |
| Profiling | cProfile, profile |
sys.monitoring y soporte de perf (3.12), conexión segura de depuradores externos (3.14), paquete profiling y Tachyon (3.15), frame pointers por defecto (3.15) |
| Mensajes de error | Ubicación precisa (nuevo en 3.11) | Más sugerencias “Did you mean” (3.12–3.15), tracebacks en color (3.13), sugerencias de otros lenguajes como .push → .append (3.15) |
| Eliminaciones | Punto de partida | distutils, imp, asyncore (3.12); 19 módulos “dead batteries” y lib2to3 (3.13); clases antiguas de nodos ast (3.14); módulos sre_* y load_module() (3.15) |
Los cambios más importantes de Python 3.15
Estas funcionalidades son nuevas en 3.15. Ninguna existía en 3.14.
Lazy imports explícitos (PEP 810)
Qué es: una palabra clave contextual lazy. Un import lazy asigna el nombre de inmediato, pero no carga el módulo hasta que el nombre se usa por primera vez.
# Requiere Python 3.15+
lazy import decimal
import sys
print("decimal loaded at startup?", "decimal" in sys.modules)
price = decimal.Decimal("19.99")
print("decimal loaded after use?", "decimal" in sys.modules)
print(price * 3)
decimal loaded at startup? False
decimal loaded after use? True
59.97
lazy from pathlib import Path funciona de la misma forma.
Reglas que conviene conocer:
lazysolo está permitido a nivel de módulo. Dentro de una función, del cuerpo de una clase o de un bloquetry/except, es unSyntaxError.lazy from module import *ylazy from __future__ import ...no están permitidos.- Un error de import ya no aparece al arrancar, sino en el primer uso. Un módulo inexistente falla donde se usa, no donde se importa:
# Requiere Python 3.15+
lazy import does_not_exist
print("startup ok") # esto se imprime
does_not_exist.run() # aquí se lanza ModuleNotFoundError
- Puedes hacer lazy todos los imports sin tocar el código con
-X lazy_imports=alloPYTHON_LAZY_IMPORTS=all. El valor por defecto esnormal, que solo respeta la palabra clavelazy. Trataallcomo un experimento: los módulos con efectos secundarios al importarse (registro de plugins, parches a otros módulos) pueden cambiar de comportamiento.
Las librerías que todavía soportan versiones anteriores no pueden usar la palabra clave lazy, porque es un error de sintaxis en 3.14 y anteriores. La PEP 810 ofrece una alternativa compatible: una lista __lazy_modules__ a nivel de módulo. Python 3.15 hace lazy los imports de la lista, y las versiones anteriores simplemente ignoran la variable.
# Funciona en cualquier Python 3; lazy solo en 3.15+
__lazy_modules__ = ["decimal"]
import decimal
Cuándo es útil: CLIs con muchos subcomandos, aplicaciones con grandes árboles de dependencias, jobs de corta duración, funciones serverless y cualquier código que importe librerías pesadas en caminos que la mayoría de las ejecuciones nunca recorre.
¿Le importa a un desarrollador normal? Sí, si el tiempo de arranque te importa. Es una de las novedades más prácticas de 3.15. Mide antes y después con python -X importtime (disponible desde 3.7).
frozendict: un mapping inmutable integrado (PEP 814)
Qué es: un nuevo tipo integrado con la parte de solo lectura de la API de dict. Es hashable si sus claves y valores lo son. No es una subclase de dict.
# Requiere Python 3.15+
DEFAULTS = frozendict(env="dev", region="eu-west", retries=3)
prod = DEFAULTS | {"env": "prod"} # crea un nuevo frozendict
print(prod)
print(DEFAULTS["env"])
try:
DEFAULTS["env"] = "prod"
except TypeError as exc:
print(exc)
# Hashable: sirve como clave de dict o de caché
row_counts = {frozendict(table="orders", day="2026-10-01"): 1_204}
print(row_counts[frozendict(day="2026-10-01", table="orders")])
print(isinstance(DEFAULTS, dict))
frozendict({'env': 'prod', 'region': 'eu-west', 'retries': 3})
dev
'frozendict' object does not support item assignment
1204
False
Cuándo es útil: valores de configuración por defecto, metadatos compartidos entre threads, claves de caché formadas por varios campos y valores de retorno que quien llama no debe modificar. json, pickle, copy y pprint lo soportan.
Cuidado con: el código que comprueba isinstance(x, dict). Un frozendict no pasa esa comprobación. Usa collections.abc.Mapping si ambos tipos deben aceptarse.
Antes de 3.15, la alternativa habitual era types.MappingProxyType. Es una vista de solo lectura de un dict, que todavía puede cambiar por debajo, y no es hashable.
sentinel: un built-in para “no se pasó ningún valor” (PEP 661)
Qué es: un built-in que crea marcadores únicos con un repr legible, soporte de copia y de pickle, y uso en anotaciones de tipo.
# Requiere Python 3.15+
MISSING = sentinel("MISSING")
def get_setting(name: str, default: str | None | MISSING = MISSING) -> str | None:
settings = {"region": "eu-west", "proxy": None}
if name in settings:
return settings[name]
if default is MISSING:
raise KeyError(name)
return default
print(get_setting("proxy")) # None: el ajuste existe y vale None
print(get_setting("timeout", default=None)) # None: quien llama eligió None
print(MISSING)
None
None
MISSING
Cuándo es útil: cualquier API en la que None sea un valor legítimo, como ajustes de configuración, actualizaciones parciales o parámetros opcionales de una librería. Sustituye el patrón _MISSING = object(), cuyo repr es un <object object at 0x...> poco útil.
¿Le importa a un desarrollador normal? Es una pequeña mejora para el código de aplicación, y más útil para quienes escriben librerías.
UTF-8 pasa a ser la codificación por defecto (PEP 686)
Qué es: Python 3.15 funciona por defecto en modo UTF-8, sea cual sea la configuración regional del sistema. open(), Path.read_text() y el resto de E/S de texto sin encoding= explícito usan ahora UTF-8.
Probablemente es el cambio de comportamiento más importante para quien viene de 3.11, sobre todo en Windows. En un equipo Windows con configuración regional de Europa occidental, Python 3.11 usaba cp1252 cuando no se indicaba codificación.
# Python 3.15
import sys, locale
print(sys.flags.utf8_mode) # 1
print(locale.getpreferredencoding(False)) # utf-8
Qué puede romperse: los scripts que leen sin indicar la codificación archivos escritos en una página de códigos antigua. Ahora obtienen un UnicodeDecodeError o caracteres corruptos en lugar del texto correcto.
Cómo prepararte sin salir de 3.11:
# Python 3.10+: avisa donde no se indica la codificación
python -X warn_default_encoding -m pytest
# Python 3.7+: ejecuta los tests como se comportará 3.15
python -X utf8 -m pytest
Puedes desactivarlo en 3.15 con PYTHONUTF8=0 o -X utf8=0. La mejor solución sigue siendo pasar encoding= explícitamente siempre que leas o escribas archivos de texto.
Unpacking en comprehensions (PEP 798)
# Requiere Python 3.15+
batches = [["a.csv", "b.csv"], ["c.csv"], []]
files = [*batch for batch in batches]
print(files) # ['a.csv', 'b.csv', 'c.csv']
partitions = [{"orders": 120}, {"customers": 40}, {"orders": 125}]
latest = {**p for p in partitions}
print(latest) # {'orders': 125, 'customers': 40}
Sustituye a [x for batch in batches for x in batch] y a itertools.chain.from_iterable. Es cómodo, pero no es motivo suficiente para actualizar.
El paquete profiling y el profiler por muestreo Tachyon (PEP 799)
Qué es: un nuevo paquete profiling. profiling.tracing es el profiler determinista, el mismo que cProfile, que sigue disponible. profiling.sampling es Tachyon, un nuevo profiler estadístico por muestreo que puede muestrear a frecuencias muy altas y conectarse a un proceso que ya está en ejecución.
# Python 3.15+
python -m profiling.sampling run etl.py # tabla con las funciones más costosas
python -m profiling.sampling run --flamegraph -o flame.html etl.py # flame graph en HTML
python -m profiling.sampling run -m mypackage.job # perfilar un módulo
python -m profiling.sampling attach 12345 # conectarse a un PID en ejecución
python -m profiling.sampling dump 12345 # captura puntual de la pila
También ofrece --mode cpu|wall|gil|exception, --async-aware para tareas de asyncio y una vista de terminal --live.
Por qué importa: un profiler por trazado registra cada llamada y ralentiza el programa, lo que puede distorsionar el resultado. Un profiler por muestreo examina la pila periódicamente, así que encaja mejor con cargas largas o parecidas a producción. “Conectarse a un PID” es justo lo que necesitas cuando un worker está bloqueado o lento y no puedes reiniciarlo con el profiling activado.
Deprecación: el módulo profile, escrito en Python puro, está deprecado y su eliminación está prevista para 3.17. cProfile se mantiene.
Frame pointers activados por defecto (PEP 831)
CPython 3.15 se compila con frame pointers en las plataformas compatibles. No lo notarás en tu código. Importa a los ingenieros de plataforma y de rendimiento porque los profilers de sistema (perf, herramientas basadas en eBPF, profilers continuos) reconstruyen de forma más fiable las pilas de llamadas mixtas Python/nativas.
Tipado: TypedDict cerrado, TypeForm, disjoint_base
# Requiere Python 3.15+ (estas reglas las aplica el type checker, no el runtime)
from typing import TypedDict
class Row(TypedDict, closed=True): # ninguna clave además de estas
id: int
name: str
class Metrics(TypedDict, extra_items=float): # claves extra permitidas, valores float
run_id: str
m: Metrics = {"run_id": "r1", "rows_per_sec": 1250.0}
Los TypedDict cerrados (PEP 728) sirven para tipar payloads JSON y registros en los que una clave inesperada es un bug. TypeForm (PEP 747) permite anotar funciones que reciben un tipo como valor, como validadores y helpers del estilo de cast. @typing.disjoint_base (PEP 800) interesa sobre todo a quienes escriben type checkers y stubs.
Tu type checker tiene que soportar estas PEP para que sirvan de algo. Revisa tu versión de mypy o pyright.
Otros cambios de 3.15 que conviene conocer
- Mejores mensajes de error. Estas sugerencias aparecen en los tracebacks:
AttributeError: 'list' object has no attribute 'push'. Did you mean '.append'?
AttributeError: 'dict' object has no attribute 'put'. Use d[k] = v.
math.integer: un nuevo módulo que agrupa las funciones para enteros (comb,factorial,gcd,isqrt,lcm,perm).- Archivos de arranque de paquetes (PEP 829): los paquetes pueden declarar puntos de entrada de arranque en archivos
.start. Las líneasimporten archivos.pthquedan deprecadas sin aviso. Importa si mantienes herramientas que dependen de trucos con.pth. bytearray.take_bytes()obtiene bytes de unbytearraysin copiarlos.- ABI estable free-threaded (
abi3t, PEP 803): las extensiones en C ya pueden publicar una única wheel para builds free-threaded en lugar de una por versión de Python. Es invisible para quien desarrolla aplicaciones, pero debería ayudar a que los paquetes soporten el free-threading.
Ejemplos prácticos: lo que también te aportan 3.12 a 3.14
Si vienes de 3.11, estas funcionalidades anteriores también son nuevas para ti. Cada ejemplo indica su versión mínima. Todos funcionan en 3.15.
# Requiere Python 3.12+: sintaxis genérica, alias de tipo, f-strings, batched
from itertools import batched
type Batch[T] = list[T]
def first[T](items: list[T]) -> T:
return items[0]
print(list(batched(range(7), 3))) # [(0, 1, 2), (3, 4, 5), (6,)]
tables = ["orders", "customers"]
print(f"tables: {", ".join(tables)}") # reutilizar la misma comilla es un SyntaxError en 3.11
# Requiere Python 3.13+: copy.replace para registros inmutables
import copy
from dataclasses import dataclass
@dataclass(frozen=True)
class Job:
name: str
retries: int = 3
print(copy.replace(Job("load_orders"), retries=5))
# Job(name='load_orders', retries=5)
# Requiere Python 3.14+: template strings y except sin paréntesis
from string.templatelib import Interpolation
table = "orders"
query = t"SELECT * FROM {table}"
values = [part.value for part in query if isinstance(part, Interpolation)]
print(type(query).__name__, values) # Template ['orders']
try:
int("x")
except ValueError, TypeError:
print("caught")
Las template strings son útiles porque, a diferencia de las f-strings, no producen una cadena inmediatamente. Una librería recibe por separado las partes literales y los valores interpolados, así que puede escapar o parametrizar esos valores de forma segura. SQL y HTML son los casos de uso evidentes.
Qué cambió entre 3.11 y 3.15 más allá de la sintaxis
Intérprete y runtime
- 3.12 hizo inlining de las comprehensions de listas, dicts y sets, lo que las hace hasta 2× más rápidas según las notas de la versión 3.12.
- 3.13 incluyó un build free-threaded experimental (un intérprete aparte, normalmente llamado
python3.13t) y un JIT experimental que había que activar al compilar. También definió la semántica delocals()(PEP 667), lo que puede afectar a depuradores y al código que modificalocals(). - 3.14 dio soporte oficial al build free-threaded (PEP 779), con una penalización de alrededor del 5–10 % en un solo thread según las notas de la versión. Los binarios de Windows y macOS empezaron a incluir el JIT, desactivado por defecto. 3.14 añadió además
concurrent.interpreterseInterpreterPoolExecutorpara ejecutar varios intérpretes aislados en un mismo proceso (PEP 734). - 3.15 mejoró el JIT e hizo que los binarios oficiales de Windows x64 usen el intérprete tail-calling. En macOS, el instalador oficial instala ahora por defecto el soporte de free-threading.
Tipado
- 3.12:
type Alias = ...,def f[T](x: T) -> T,@overrideyTypedDictpara**kwargs. - 3.13: valores por defecto en parámetros de tipo,
TypeIs,ReadOnlyy@warnings.deprecated. - 3.14: las anotaciones se evalúan de forma diferida (PEP 649/749), así que las referencias adelantadas ya no necesitan comillas. El código que lee
__annotations__directamente debería pasar aannotationlib.get_annotations().from __future__ import annotationsqueda deprecado, pero sigue funcionando. - 3.15:
TypedDictcerrado,TypeForm,disjoint_base. La forma con argumentos de palabra claveNamedTuple("P", x=int)ya no está soportada.
Biblioteca estándar
- 3.11:
tomllib,asyncio.TaskGroup,asyncio.timeout(). - 3.12:
itertools.batched,pathlib.Path.walk(). - 3.13:
copy.replace(). - 3.14:
compression.zstd(Zstandard en la biblioteca estándar), introspección de asyncio y resaltado de sintaxis en el REPL. - 3.15:
frozendict,sentinel,profiling,math.integer, ybase64,base32,base85ycsv.Sniffermás rápidos.
Arranque e imports
Python 3.11 aceleró el arranque alrededor de un 10–15 % congelando los módulos del núcleo. Python 3.15 es la primera versión que te permite diferir los imports a ti, con lazy import. Nada entre 3.12 y 3.14 lo permitía.
Depuración y observabilidad
- 3.12:
sys.monitoring(PEP 669) para profilers, depuradores y herramientas de cobertura de bajo coste, e integración conperfen Linux mediante-X perf. - 3.13: un nuevo REPL con edición multilínea y tracebacks en color por defecto.
- 3.14: una interfaz segura para depuradores externos (PEP 768), que permite conectar un depurador a un proceso en ejecución.
- 3.15: Tachyon, frame pointers y mejores sugerencias de error.
Packaging y flujo de trabajo
- 3.12:
venvya no instalasetuptools, ydistutilsdesapareció. Los flujos antiguos basados ensetup.pyque dependían de alguno de los dos necesitanpip install setuptoolso pasar apyproject.toml. - 3.14: en Linux y otros Unix salvo macOS,
multiprocessingyProcessPoolExecutorarrancan ahora los procesos conforkserveren lugar defork. El código que dependía de que los procesos hijos heredaran el estado global puede fallar conNameErroro errores de pickle. - 3.15: las descargas oficiales para Windows llevan al gestor de instalación de Python (
py install 3.15).
Rendimiento: qué está realmente verificado
Conviene separar las funcionalidades del lenguaje de las mejoras de la implementación CPython. Los lazy imports son una funcionalidad del lenguaje: funcionan en cualquier implementación de Python 3.15 y los controlas desde el código. El JIT, el intérprete tail-calling y los frame pointers son detalles de implementación de CPython: su efecto depende del build, de la plataforma y de la carga de trabajo.
Estas son las cifras publicadas por el propio proyecto CPython. Este artículo no añade ninguna otra.
| Cambio | Versión | Cifra publicada | Contexto |
|---|---|---|---|
| Faster CPython | 3.11 | Entre un 10 y un 60 % más rápido que 3.10; alrededor de 1,25× de media | Suite de benchmarks pyperformance |
| Inlining de comprehensions | 3.12 | Comprehensions hasta 2× más rápidas | Microbenchmarks centrados en comprehensions |
| Build free-threaded | 3.14 | Penalización del 5–10 % en un solo thread | El precio de eliminar el GIL; las ganancias solo llegan con threads en paralelo |
| JIT | 3.15 | 7–8 % de media geométrica en x86-64 Linux; 11–12 % en AArch64 macOS | Según el benchmark, desde un 15 % más lento hasta más de un 100 % más rápido |
| Intérprete tail-calling | 3.15 (binarios de Windows x64) | 15–20 % frente al intérprete switch-case | Media geométrica de pyperformance en Windows x86-64 |
base64 |
3.15 | Codificación 2× más rápida, decodificación 3× más rápida | Solo si tu carga codifica o decodifica base64 |
| Base32 / Base85 / Ascii85 / Z85 | 3.15 | Unos dos órdenes de magnitud más rápidos | Reescritos en C |
csv.Sniffer.sniff() |
3.15 | Hasta 1,6× más rápido | Solo la detección del delimitador, no csv.reader |
Qué significa en la práctica:
- No existe una cifra oficial de extremo a extremo “3.11 → 3.15”. Tu ganancia depende de tu carga de trabajo. En trabajo con datos, gran parte del tiempo de ejecución suele estar en librerías nativas (NumPy, Arrow, drivers de bases de datos), y las mejoras del intérprete no las aceleran.
- El JIT sigue siendo experimental y está desactivado por defecto. En los binarios oficiales de Windows y macOS se activa con
PYTHON_JIT=1. Mide tu propia carga con y sin él. Algunos benchmarks van más lentos. - El free-threading es otro build, no una opción que se activa. Ayuda al código Python CPU-bound repartido entre varios threads, y solo si todas tus extensiones en C lo soportan. El código de un solo thread va algo más lento.
- Mide el arranque y el régimen estable por separado. Los lazy imports mejoran el tiempo de arranque. El JIT y el trabajo en el intérprete afectan a los bucles largos.
# Arranque: ¿qué imports cuestan más?
python -X importtime -c "import mypackage.cli" 2> imports.log
# Régimen estable: comparar la misma carga entre versiones
python3.11 bench_transform.py
python3.15 bench_transform.py
PYTHON_JIT=1 python3.15 bench_transform.py
Cambios incompatibles y eliminaciones (3.11 → 3.15)
Actualizar directamente desde 3.11 significa asumir de golpe todas las eliminaciones de 3.12 a 3.15. Estas son las que más probablemente afecten a proyectos reales.
Módulos y APIs eliminados
| Eliminado en | Qué | Sustituto |
|---|---|---|
| 3.12 | distutils |
setuptools, builds basados en pyproject.toml |
| 3.12 | imp |
importlib |
| 3.12 | asynchat, asyncore |
asyncio |
| 3.13 | cgi, cgitb, crypt, telnetlib, pipes, nntplib, imghdr, sndhdr, uu, xdrlib, aifc, audioop, chunk, mailcap, msilib, nis, ossaudiodev, spwd, sunau (PEP 594) |
Paquetes de terceros o equivalentes con email, subprocess, shlex |
| 3.13 | 2to3 y lib2to3 |
Parsers modernos como LibCST o Parso |
| 3.14 | ast.Num, ast.Str, ast.Bytes, ast.NameConstant, ast.Ellipsis |
ast.Constant |
| 3.14 | pkgutil.find_loader(), pkgutil.get_loader() |
importlib.util.find_spec() |
| 3.15 | sre_compile, sre_constants, sre_parse |
re |
| 3.15 | Loader.load_module() de importlib |
exec_module() |
| 3.15 | http.server.CGIHTTPRequestHandler |
Un servidor de aplicaciones de verdad |
| 3.15 | PurePath.is_reserved(), platform.java_ver(), types.CodeType.co_lnotab |
Consulta el What’s New de 3.15 |
Cambios de comportamiento que rompen código sin error de import
- Codificación UTF-8 por defecto (3.15). Ver arriba. Es el más habitual.
asyncio.get_event_loop()(3.14) lanzaRuntimeErrorsi no hay un event loop actual. Usaasyncio.run()oasyncio.Runner.- Método de arranque de
multiprocessing(3.14): esforkserveren Linux. Usaget_context("fork")explícitamente si de verdad necesitasfork. - Secuencias de escape no válidas (3.12) como
"\d": emiten unSyntaxWarningen lugar de unDeprecationWarning, así que aparecen avisos en código que antes era silencioso. Usa cadenas raw:r"\d". - Anotaciones (3.14): se evalúan de forma diferida. Las librerías que inspeccionan
__annotations__al crear las clases pueden comportarse de otra manera. sqlite3.connect()(3.15): todos los parámetros salvodatabaseson ahora keyword-only.sqlite3.connect("db", 5.0)lanzaTypeError; escribetimeout=5.0.argparse(3.15): conadd_argument("-f", "-foo"),destes ahora"foo"en lugar de"f".base64.urlsafe_b64decode()(3.15) ya no exige padding. Pasapadded=Truesi tu validación dependía del error.assertWarns*()deunittest(3.15) ya no se traga avisos que no corresponden, así que pueden aparecer en los tests avisos que antes quedaban ocultos.datetime.strptime()(3.15) con%dpero sin año lanza ahoraValueError.- Tipado (3.15):
NamedTuple("P", x=int)y unTypedDict("TD")sin campos ya no están soportados.
Deprecaciones que conviene resolver ya
- Módulo
profile: eliminación en 3.17. Usaprofiling.tracingocProfile. - Sistema de policies de asyncio (
set_event_loop_policy()y APIs relacionadas): eliminación en 3.16. Usaasyncio.run(..., loop_factory=...)oasyncio.Runner. typing.ByteStringycollections.abc.ByteString: eliminación en 3.17. Usacollections.abc.Buffer.- Líneas
importen archivos.pth: deprecadas por la PEP 829. Se ignoran cuando existe un archivo.startcorrespondiente.
Checklist de compatibilidad
Antes de actualizar:
- Dependencias: cada paquete fijado tiene una versión que soporta 3.15. Revisa los classifiers de PyPI, los changelogs y los archivos publicados para cada versión, no solo que “se instala”.
- Paquetes compilados/nativos: existen wheels
cp315para cada sistema operativo y CPU donde despliegas. Sin ellas,piprecurre a compilar desde el código fuente, lo que falla o se comporta de otra forma en CI. - Tests: la suite completa pasa en 3.15 con los avisos visibles (
-W defaulto-X dev). - Codificación: los tests pasan en 3.11 con
-X utf8, y-X warn_default_encodingno señala ningún argumentoencoding=que falte. - Módulos eliminados: busca con
grepdistutils,imp,cgi,telnetlib,pipes,lib2to3,ast.Num,sre_ypkgutil.find_loader. - Imágenes de CI: la imagen del runner o la action de setup de tu CI ofrece 3.15.
- Imágenes base de Docker: existe el tag 3.15 exacto que piensas usar para tu distribución (slim, Alpine, distroless).
- Linters, formateadores y type checkers: tu versión de Ruff, Black, mypy o pyright sabe parsear
lazy importy entiende las novedades de tipado. Una herramienta que no sepa parsear la sintaxis fallará en cualquier archivo que la use. - pandas, PySpark y librerías de datos: cada una soporta oficialmente 3.15 en la versión que fijas (ver la siguiente sección).
- Runtimes cloud: tu plataforma serverless o gestionada ofrece un runtime 3.15. No lo des por hecho.
- Agentes de observabilidad: los agentes de APM, tracing y profiling que se enganchan al intérprete soportan 3.15.
Python 3.15 para data engineers
La distinción clave
Que exista una nueva versión de CPython no significa que tu plataforma de datos la ejecute. Los runtimes de Spark gestionados, los servicios de notebooks, Microsoft Fabric, Databricks, las funciones cloud y los servicios de orquestación deciden cada uno qué versión de Python ofrecen, y normalmente van por detrás de las nuevas versiones de CPython. Mientras la documentación del runtime de tu plataforma no mencione Python 3.15, ninguna de las novedades de 3.15 de este artículo estará disponible para tus notebooks o jobs en esa plataforma.
Con PySpark hay una restricción adicional: el driver y los workers deben ejecutar la misma versión menor de Python. No puedes usar 3.15 en el driver si los workers del clúster usan una versión anterior.
Qué ayuda donde sí controlas el runtime
- Scripts ETL y CLIs:
lazy importpuede reducir bastante el tiempo de arranque de herramientas que importan pandas, PyArrow, SDKs cloud y drivers de bases de datos en caminos que la mayoría de las ejecuciones no recorre. Importa en jobs cortos y planificados con frecuencia. - Orquestación: los planificadores que parsean repetidamente los archivos de definición de pipelines pagan el coste de los imports cada vez. Los lazy imports en esos módulos de definición encajan de forma natural, una vez que tu orquestador soporte 3.15.
- Manejo de archivos: UTF-8 por defecto elimina toda una categoría de bugs con CSV del tipo “funciona en Linux, falla en Windows” al usar
open()y el módulocsvestándar.read_csvde pandas ya usaba UTF-8 por defecto, así que su comportamiento no cambia. Los archivos antiguos exportados encp1252olatin-1necesitan ahora unencoding=explícito. - Configuración:
frozendictencaja bien con una configuración de job compartida entre threads o usada como clave de caché. - Diagnóstico: el modo
attachde Tachyon permite perfilar un worker de Python lento y de larga duración sin reiniciarlo. Recuerda que con PySpark la mayor parte del trabajo se ejecuta en la JVM y el profiler solo ve la parte de Python. - Free-threading: puede hacer útiles los threads para transformaciones CPU-bound en Python puro, pero solo cuando toda tu pila nativa (NumPy, pandas, PyArrow, drivers) soporte el build free-threaded. Pruébalo como un proyecto aparte, no como parte de la actualización.
pandas, notebooks y librerías compartidas
- Revisa las versiones de Python soportadas en las notas de versión de las versiones exactas de pandas, NumPy y PyArrow que fijas. No supongas que “el último pandas” soporta una versión de Python publicada la semana pasada.
- Los kernels de notebooks dependen del entorno en el que se ejecutan. Un kernel 3.15 necesita su propio entorno con paquetes compatibles con 3.15.
- Las librerías internas compartidas entre notebooks gestionados y jobs autogestionados deben seguir soportando la versión de Python más antigua de tus plataformas. Usa
__lazy_modules__en lugar de la palabra clavelazy, y evita los built-ins exclusivos de 3.15 en el código compartido hasta que todas las plataformas ofrezcan 3.15.
Para practicar con datos, consulta cómo leer archivos CSV con pandas, cómo inspeccionar un DataFrame, cómo filtrar filas con pandas y cómo acelerar los notebooks de Fabric.
¿Deberías actualizar de Python 3.11 a 3.15?
| Actualiza ya si… | Prueba primero si… | Espera si… |
|---|---|---|
| Controlas el runtime (contenedor, VM, CLI) | Usas muchas extensiones compiladas o paquetes nativos poco comunes | Tu plataforma gestionada (Spark, notebooks, serverless) no ofrece 3.15 |
| Tus dependencias clave ya publican wheels para 3.15 | Trabajas en Windows y lees o escribes archivos sin encoding= |
Una dependencia crítica no ha anunciado soporte para 3.15 |
| El tiempo de arranque importa y los lazy imports ayudarían | Dependes de multiprocessing con la semántica de fork en Linux |
Tus linters, type checkers o agentes de APM todavía no soportan 3.15 |
| Empiezas un servicio nuevo | Tu código o tus librerías leen __annotations__ directamente |
Estás en mitad de una release en un sistema regulado o congelado |
| Necesitas una versión con soporte hasta 2031 | Quieres evaluar el JIT o el free-threading |
Si no puedes ir directamente a 3.15, pasar de 3.11 a 3.14 es un paso intermedio razonable. Obtienes la mayor parte de las mejoras acumuladas, con un ecosistema más ampliamente compatible hoy y soporte hasta 2030.
Plan de migración
- Crea un entorno 3.15 junto al actual:
py install 3.15en Windows, el paquete de tu distribución o el instalador oficial en otros sistemas, y despuéspython3.15 -m venv .venv315. - Instala las dependencias desde tu lock file. Cualquier paquete que intente compilarse desde el código fuente te indica qué wheel falta.
- Ejecuta toda la suite de tests con los avisos visibles:
python -X dev -m pytest. - Ejecuta linters y type checkers en versiones que soporten 3.15.
- Revisa avisos y deprecaciones. Corrige ya todo lo que se vaya a eliminar en 3.16 o 3.17, mientras todavía es solo un aviso.
- Mide las cargas críticas. Mide por separado el tiempo de arranque y el rendimiento en régimen estable, en 3.11 y en 3.15, con y sin
PYTHON_JIT=1si te interesa el JIT. - Despliega de forma gradual: primero la matriz de CI, luego staging y después una instancia canary. Compara tasa de errores, CPU, memoria y latencia antes de extenderlo a todas las instancias.
Conclusión
Python 3.15 no es un único cambio espectacular. Es el momento en que cuatro años de trabajo en CPython se vuelven realmente aprovechables: un runtime maduro, un build free-threaded opcional, un JIT que empieza a dar resultados, un profiling mucho mejor y añadidos prácticos al lenguaje como lazy import, frozendict y sentinel.
Para un equipo en 3.11, la decisión depende sobre todo de las dependencias y las plataformas, no de Python en sí. Si controlas tu runtime y tus dependencias soportan 3.15, empieza a probar ya, empezando por el cambio a UTF-8. Si una plataforma gestionada decide tu versión de Python, planifica la actualización para cuando ofrezca 3.15, y mantén el código compartido compatible con la versión anterior hasta entonces.
En cualquier caso, 3.11 llega al final de su vida en octubre de 2027. La actualización llegará igualmente, y es más fácil hacerla a tu propio ritmo.
Fuentes oficiales
- What’s New in Python 3.15: https://docs.python.org/3.15/whatsnew/3.15.html
- Publicación de Python 3.15.0: https://www.python.org/downloads/release/python-3150/
- Calendario de Python 3.15 (PEP 790): https://peps.python.org/pep-0790/
- Estado de las versiones de Python: https://devguide.python.org/versions/
- PEP 810 (lazy imports explícitos): https://peps.python.org/pep-0810/
- PEP 814 (frozendict): https://peps.python.org/pep-0814/
- PEP 661 (valores sentinel): https://peps.python.org/pep-0661/
- PEP 686 (modo UTF-8 por defecto): https://peps.python.org/pep-0686/
- PEP 799 (paquete de profiling): https://peps.python.org/pep-0799/
- What’s New in Python 3.14: https://docs.python.org/3.14/whatsnew/3.14.html
- What’s New in Python 3.13: https://docs.python.org/3.13/whatsnew/3.13.html
- What’s New in Python 3.12: https://docs.python.org/3.12/whatsnew/3.12.html
- What’s New in Python 3.11: https://docs.python.org/3.11/whatsnew/3.11.html
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Sigue aprendiendo
- Guía rápidaDepurar problemas comunes de pandasDiagnostica fallos comunes de pandas relacionados con dtypes, valores faltantes, joins, asignación encadenada, datos duplicados, errores de fechas, presión de memoria y cambios inesperados en el número de filas.Abrir guía rápida
- ArtículoRendimiento 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.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.