Novedades Python 3.13

Principales características nuevas de Python 3.13

Python 3.13 introduce mejoras significativas en rendimiento, sintaxis y funcionalidades que optimizan el desarrollo y la ejecución de aplicaciones. Esta versión continúa la evolución del lenguaje con características que facilitan la escritura de código más limpio y eficiente.

Mejoras en el sistema de tipos

Python 3.13 refuerza su sistema de tipado gradual con nuevas características que mejoran la verificación estática de tipos sin sacrificar la flexibilidad dinámica del lenguaje.

Tipos genéricos autónomos

Ahora es posible definir tipos genéricos sin necesidad de heredar de typing.Generic, lo que simplifica la creación de anotaciones de tipo:

from typing import TypeVar

T = TypeVar('T')

# Nuevo en Python 3.13: tipo genérico autónomo
class Box[T]:  # Sin necesidad de heredar de Generic[T]
    def __init__(self, value: T) -> None:
        self.value = value
        
    def get(self) -> T:
        return self.value

# Uso
int_box = Box[int](42)
str_box = Box[str]("Hello")

Mejoras en TypedDict

Se ha mejorado el soporte para TypedDict con la posibilidad de definir campos opcionales de manera más intuitiva:

from typing import TypedDict, NotRequired

# Nuevo en Python 3.13: sintaxis mejorada para campos opcionales
class UserProfile(TypedDict):
    name: str
    age: int
    email: NotRequired[str]  # Campo opcional
    address: NotRequired[str]  # Campo opcional

# Un diccionario válido sin los campos opcionales
user: UserProfile = {"name": "Ana", "age": 28}

Optimizaciones de rendimiento

Nuevo intérprete más rápido

Python 3.13 incluye mejoras significativas en el intérprete que reducen el tiempo de ejecución de código:

# Las operaciones con cadenas son hasta un 30% más rápidas
def concatenar_cadenas(n: int) -> str:
    resultado = ""
    for i in range(n):
        resultado += str(i)
    return resultado

# Las operaciones con diccionarios también se han optimizado
def operaciones_diccionario(n: int) -> dict:
    d = {}
    for i in range(n):
        d[f"clave_{i}"] = i * 2
    return d

Mejoras en la gestión de memoria

Se ha optimizado el recolector de basura para reducir las pausas y mejorar la eficiencia en la gestión de memoria:

# Código que crea y destruye muchos objetos
# se beneficia de las mejoras en el recolector de basura
def crear_objetos_temporales(n: int) -> None:
    for _ in range(n):
        # Estos objetos se liberan más eficientemente en Python 3.13
        [list(range(100)) for _ in range(1000)]

Nuevas características del lenguaje

Operador de unión de patrones

Python 3.13 introduce el operador | para unir patrones en las estructuras match/case, permitiendo una sintaxis más concisa:

def analizar_valor(valor):
    match valor:
        # Nuevo en Python 3.13: unión de patrones con |
        case int() | float() as num if num > 0:
            return f"Número positivo: {num}"
        case str() | bytes() as texto:
            return f"Texto de longitud {len(texto)}"
        case _:
            return "Otro tipo de valor"

print(analizar_valor(42))       # "Número positivo: 42"
print(analizar_valor("Python")) # "Texto de longitud 6"

Mejoras en f-strings

Las f-strings ahora permiten expresiones más complejas y anidamiento de llaves de manera más intuitiva:

nombre = "Python"
version = 3.13

# Nuevo en Python 3.13: sintaxis mejorada para f-strings
mensaje = f"Bienvenido a {nombre} {version}"
print(mensaje)  # "Bienvenido a Python 3.13"

# Anidamiento de llaves más intuitivo
datos = {"lenguaje": "Python", "versión": 3.13}
print(f"Usando {datos['lenguaje']} {datos['versión']}")  # "Usando Python 3.13"

Mejoras en la biblioteca estándar

Nuevo módulo asyncio.taskgroup

Python 3.13 introduce un nuevo módulo para gestionar grupos de tareas asíncronas de manera más eficiente:

import asyncio
from asyncio.taskgroup import TaskGroup

async def tarea(nombre: str, segundos: float) -> str:
    await asyncio.sleep(segundos)
    return f"Tarea {nombre} completada"

async def main():
    # Nuevo en Python 3.13: TaskGroup para gestionar tareas relacionadas
    async with TaskGroup() as tg:
        # Crear varias tareas que se ejecutan concurrentemente
        tarea1 = tg.create_task(tarea("A", 1.0))
        tarea2 = tg.create_task(tarea("B", 0.5))
        tarea3 = tg.create_task(tarea("C", 1.5))
    
    # Todas las tareas están completadas cuando salimos del bloque with
    resultados = [tarea1.result(), tarea2.result(), tarea3.result()]
    print(resultados)

asyncio.run(main())

Mejoras en el módulo pathlib

El módulo pathlib ha sido mejorado con nuevos métodos para operaciones comunes con archivos:

from pathlib import Path

# Nuevo en Python 3.13: método walk() para recorrer directorios
def listar_archivos_python(directorio: str) -> list[str]:
    ruta = Path(directorio)
    archivos_python = []
    
    # Método walk() similar a os.walk pero con la API de Path
    for ruta_actual, directorios, archivos in ruta.walk():
        for archivo in archivos:
            if archivo.suffix == '.py':
                archivos_python.append(str(ruta_actual / archivo))
                
    return archivos_python

# Nuevo método copy() para copiar archivos
def copiar_archivo(origen: str, destino: str) -> None:
    Path(origen).copy(Path(destino))

Mejoras en la seguridad

Validación mejorada de entradas

Python 3.13 incluye mejoras en la validación de entradas para prevenir vulnerabilidades:

import json
from json.decoder import JSONDecodeError

def procesar_json_seguro(entrada: str) -> dict:
    try:
        # Validación mejorada en Python 3.13
        datos = json.loads(entrada, parse_constant=lambda x: None)
        return datos
    except JSONDecodeError:
        return {"error": "Formato JSON inválido"}
    except Exception as e:
        return {"error": f"Error inesperado: {str(e)}"}

Mejoras en el módulo ssl

El módulo ssl ha sido actualizado para soportar los protocolos de seguridad más recientes:

import ssl
import socket

def crear_conexion_segura(host: str, puerto: int) -> socket.socket:
    # Configuración de contexto SSL con opciones de seguridad mejoradas
    contexto = ssl.create_default_context()
    
    # Nuevas opciones de seguridad en Python 3.13
    contexto.minimum_version = ssl.TLSVersion.TLSv1_3
    contexto.set_ciphers('HIGH:!aNULL:!eNULL:!MD5:!3DES')
    
    # Crear socket y envolver con SSL
    sock = socket.create_connection((host, puerto))
    return contexto.wrap_socket(sock, server_hostname=host)

Mejoras en el manejo de excepciones

Python 3.13 introduce mejoras en el manejo de excepciones para facilitar la depuración y el mantenimiento del código:

# Nuevo en Python 3.13: notas en excepciones
def dividir(a: int, b: int) -> float:
    try:
        return a / b
    except ZeroDivisionError as e:
        # Añadir información contextual a la excepción
        e.add_note(f"Intento de división por cero: {a} / {b}")
        raise

# Captura de excepciones con información adicional
try:
    resultado = dividir(10, 0)
except ZeroDivisionError as e:
    print(f"Error: {e}")
    # Acceder a las notas de la excepción
    for nota in e.__notes__:
        print(f"Nota: {nota}")

Nuevo intérprete interactivo (REPL)

Una de las incorporaciones más visibles de Python 3.13 es un nuevo REPL escrito en Python, basado en el de PyPy. Sustituye al intérprete interactivo clásico en la mayoría de plataformas y aporta edición multilínea real, coloreado de sintaxis, pegado de bloques completos sin indentación errónea y atajos dedicados.

>>> def factorial(n):
...     if n <= 1:
...         return 1
...     return n * factorial(n - 1)
...
>>> factorial(5)
120

Los atajos más útiles dentro del nuevo REPL son:

• F1: abre la ayuda interactiva sin salir del indicador.
• F2: muestra el historial navegable.
• F3: activa el modo paste, útil para pegar código con indentación sin que el intérprete reformatee las líneas.
• exit y quit funcionan como comandos, ya no es necesario escribir exit().

El nuevo REPL puede desactivarse estableciendo la variable de entorno PYTHON_BASIC_REPL=1 si se necesita el comportamiento heredado, por ejemplo en entornos que no soportan secuencias ANSI.

Mensajes de error más informativos

El intérprete ofrece mensajes de error más orientados a solución. Ante un nombre no definido, sugiere imports habituales, y ante argumentos con nombre incorrecto sugiere el nombre más próximo.

>>> pth = pathlib.Path("/tmp")
NameError: name 'pathlib' is not defined. Did you forget to import 'pathlib'?

>>> open("datos.txt", encodng="utf-8")
TypeError: open() got an unexpected keyword argument 'encodng'. Did you mean 'encoding'?

Esta mejora es particularmente útil cuando se aprende Python o se depura rápido en el REPL, y no requiere ningún cambio en el código del usuario.

JIT experimental y build sin GIL

Python 3.13 introduce dos cambios de bajo nivel que, aunque son experimentales, marcan la dirección del lenguaje para los próximos años.

• JIT experimental (PEP 744): un compilador just-in-time que traduce fragmentos de bytecode a código máquina. Se activa en tiempo de compilación con --enable-experimental-jit y todavía no proporciona mejoras significativas en todos los escenarios.
• Free-threaded build (PEP 703): una variante del intérprete que elimina el GIL (Global Interpreter Lock). Se habilita con --disable-gil al compilar y permite que varios hilos ejecuten bytecode Python en paralelo en CPUs de múltiples núcleos.

La gestión de memoria en CPython combina dos mecanismos independientes: el contador de referencias por objeto incrementa con cada nueva referencia y decrementa al perderlas, liberando memoria al llegar a cero, mientras que el recolector de ciclos generacional detecta y libera ciclos de referencias que el refcount por sí solo no puede romper.

Con free-threading activado, el refcount pasa a ser atómico y la presión sobre el recolector sube, por lo que los beneficios se ven en cargas con muchos hilos concurrentes, no en scripts lineales.

Ninguna de las dos funcionalidades está activa por defecto. Las distribuciones oficiales habituales, como las de python.org, incluyen el build estándar con GIL. Para usarlas conviene consultar la documentación y ser consciente de que el rendimiento y la estabilidad pueden variar respecto a la versión clásica.

Novedades del módulo typing

El módulo typing incorpora varios añadidos que refinan el tipado estático:

• typing.ReadOnly (PEP 705): marca campos de TypedDict como inmutables para el verificador de tipos.
• typing.TypeIs (PEP 742): una forma más precisa de TypeGuard que también reduce el tipo en la rama negativa.
• warnings.deprecated (PEP 702): decorador que señala funciones o clases como obsoletas de forma reconocible por los verificadores de tipos.

from typing import TypedDict, ReadOnly, TypeIs
from warnings import deprecated

class Config(TypedDict):
    version: ReadOnly[str]
    flags: dict[str, bool]

def es_lista_de_enteros(valor: object) -> TypeIs[list[int]]:
    return isinstance(valor, list) and all(isinstance(x, int) for x in valor)

@deprecated("Usa nueva_api en su lugar")
def vieja_api() -> None:
    ...

Nuevos métodos en pathlib

pathlib suma métodos que antes requerían combinar el módulo con funciones de shutil o os:

• Path.full_match(patron): coincidencia contra patrones glob a lo largo de toda la ruta, no solo del nombre.
• Path.from_uri(uri): construye un Path a partir de un URI file://.
• Parámetro case_sensitive en glob() y rglob(): control explícito de la sensibilidad a mayúsculas, útil al comparar nombres de ficheros en Windows y macOS.

from pathlib import Path

ruta = Path("/var/log/nginx/access.log")
print(ruta.full_match("/var/log/**/*.log"))  # True

desde_uri = Path.from_uri("file:///etc/hosts")
print(desde_uri)  # /etc/hosts

proyecto = Path("src")
for archivo in proyecto.glob("**/*.py", case_sensitive=False):
    print(archivo)

Módulos retirados en 3.13

Python 3.13 completa la retirada iniciada en PEP 594 de módulos heredados de la biblioteca estándar. Entre los eliminados figuran cgi, cgitb, smtpd, telnetlib, nntplib, mailcap, aifc, audioop, chunk, sunau, uu, xdrlib, lib2to3 y pipes. También desaparecen los alias typing.io y typing.re.

El código que dependa de estos módulos debe migrarse antes de actualizar. Para muchos hay sustitutos en PyPI o en otros módulos de la biblioteca estándar. Por ejemplo, cgi se sustituye por frameworks web modernos como Flask o FastAPI, y telnetlib por la biblioteca externa telnetlib3.

Base64 Z85 y copy.replace

Dos utilidades menores que simplifican tareas frecuentes:

• base64.z85encode y base64.z85decode implementan la codificación Z85, común en protocolos de ZeroMQ y Ethereum.
• copy.replace(obj, /, **changes) devuelve una copia del objeto con los campos indicados reemplazados, de forma análoga a dataclasses.replace, pero genérica.

import base64
from copy import replace
from dataclasses import dataclass

datos = base64.z85encode(b"\x86\x4f\xd2\x6f\xb5\x59\xf7\x5b")
print(datos)  # b'HelloWorld'

@dataclass
class Usuario:
    nombre: str
    edad: int

u = Usuario("Ana", 30)
u2 = replace(u, edad=31)
print(u2)  # Usuario(nombre='Ana', edad=31)

Mejoras en la compatibilidad con otras tecnologías

Python 3.13 mejora la interoperabilidad con otras tecnologías y sistemas:

# Mejor soporte para integración con C/C++
from ctypes import cdll, c_int, c_double

# Cargar biblioteca compartida
lib = cdll.LoadLibrary("./libejemplo.so")

# Definir tipos de argumentos y retorno
lib.calcular.argtypes = [c_int, c_double]
lib.calcular.restype = c_double

# Llamar a función C desde Python
resultado = lib.calcular(42, 3.14)
print(f"Resultado de la función C: {resultado}")