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.

Por JaviPublicado Actualizado 26 min de lecturaIntermedio

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, sentinel y 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, lib2to3 y 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:

  • lazy solo está permitido a nivel de módulo. Dentro de una función, del cuerpo de una clase o de un bloque try/except, es un SyntaxError.
  • lazy from module import * y lazy 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=all o PYTHON_LAZY_IMPORTS=all. El valor por defecto es normal, que solo respeta la palabra clave lazy. Trata all como 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íneas import en archivos .pth quedan deprecadas sin aviso. Importa si mantienes herramientas que dependen de trucos con .pth.
  • bytearray.take_bytes() obtiene bytes de un bytearray sin 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 de locals() (PEP 667), lo que puede afectar a depuradores y al código que modifica locals().
  • 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.interpreters e InterpreterPoolExecutor para 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, @override y TypedDict para **kwargs.
  • 3.13: valores por defecto en parámetros de tipo, TypeIs, ReadOnly y @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 a annotationlib.get_annotations(). from __future__ import annotations queda deprecado, pero sigue funcionando.
  • 3.15: TypedDict cerrado, TypeForm, disjoint_base. La forma con argumentos de palabra clave NamedTuple("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, y base64, base32, base85 y csv.Sniffer má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 con perf en 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: venv ya no instala setuptools, y distutils desapareció. Los flujos antiguos basados en setup.py que dependían de alguno de los dos necesitan pip install setuptools o pasar a pyproject.toml.
  • 3.14: en Linux y otros Unix salvo macOS, multiprocessing y ProcessPoolExecutor arrancan ahora los procesos con forkserver en lugar de fork. El código que dependía de que los procesos hijos heredaran el estado global puede fallar con NameError o 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) lanza RuntimeError si no hay un event loop actual. Usa asyncio.run() o asyncio.Runner.
  • Método de arranque de multiprocessing (3.14): es forkserver en Linux. Usa get_context("fork") explícitamente si de verdad necesitas fork.
  • Secuencias de escape no válidas (3.12) como "\d": emiten un SyntaxWarning en lugar de un DeprecationWarning, 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 salvo database son ahora keyword-only. sqlite3.connect("db", 5.0) lanza TypeError; escribe timeout=5.0.
  • argparse (3.15): con add_argument("-f", "-foo"), dest es ahora "foo" en lugar de "f".
  • base64.urlsafe_b64decode() (3.15) ya no exige padding. Pasa padded=True si tu validación dependía del error.
  • assertWarns*() de unittest (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 %d pero sin año lanza ahora ValueError.
  • Tipado (3.15): NamedTuple("P", x=int) y un TypedDict("TD") sin campos ya no están soportados.

Deprecaciones que conviene resolver ya

  • Módulo profile: eliminación en 3.17. Usa profiling.tracing o cProfile.
  • Sistema de policies de asyncio (set_event_loop_policy() y APIs relacionadas): eliminación en 3.16. Usa asyncio.run(..., loop_factory=...) o asyncio.Runner.
  • typing.ByteString y collections.abc.ByteString: eliminación en 3.17. Usa collections.abc.Buffer.
  • Líneas import en archivos .pth: deprecadas por la PEP 829. Se ignoran cuando existe un archivo .start correspondiente.

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 cp315 para cada sistema operativo y CPU donde despliegas. Sin ellas, pip recurre 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 default o -X dev).
  • Codificación: los tests pasan en 3.11 con -X utf8, y -X warn_default_encoding no señala ningún argumento encoding= que falte.
  • Módulos eliminados: busca con grep distutils, imp, cgi, telnetlib, pipes, lib2to3, ast.Num, sre_ y pkgutil.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 import y 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 import puede 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ódulo csv estándar. read_csv de pandas ya usaba UTF-8 por defecto, así que su comportamiento no cambia. Los archivos antiguos exportados en cp1252 o latin-1 necesitan ahora un encoding= explícito.
  • Configuración: frozendict encaja bien con una configuración de job compartida entre threads o usada como clave de caché.
  • Diagnóstico: el modo attach de 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 clave lazy, 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

  1. Crea un entorno 3.15 junto al actual: py install 3.15 en Windows, el paquete de tu distribución o el instalador oficial en otros sistemas, y después python3.15 -m venv .venv315.
  2. Instala las dependencias desde tu lock file. Cualquier paquete que intente compilarse desde el código fuente te indica qué wheel falta.
  3. Ejecuta toda la suite de tests con los avisos visibles: python -X dev -m pytest.
  4. Ejecuta linters y type checkers en versiones que soporten 3.15.
  5. 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.
  6. 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=1 si te interesa el JIT.
  7. 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

Etiquetas

  • Python
  • Rendimiento
  • Concurrencia
  • Observabilidad