La función integrada vars() en Python devuelve el diccionario de atributos (__dict__) de un objeto. Es una herramienta útil para inspeccionar el estado interno de instancias, clases o contextos de ejecución.

En este artículo, veremos ejemplos prácticos de uso, situaciones comunes y precauciones para evitar errores al usar vars().

Sintaxis de vars()

vars([obj])

obj (opcional): El objeto del que se quiere obtener el diccionario __dict__.
Si no se proporciona, vars() devuelve las variables locales del contexto actual.

Ejemplos prácticos

1. vars() con un objeto que tiene __dict__

class User:
    def __init__(self, name: str, role: str):
        self.name = name
        self.role = role

print(vars(User("Alice", "admin"))) # {'name': 'Alice', 'role': 'admin'}

Aquí, vars() devuelve el diccionario con las propiedades y valores internos de la instancia User.

2. vars() sin argumentos — contexto local

x = 42
y = "Python"

print(vars()) # {'x': 42, 'y': 'Python', ...}

En este caso, vars() devuelve el diccionario de variables locales.
Es equivalente a locals() en la práctica, aunque locals() tiene un comportamiento específico según la implementación de Python (por ejemplo, en CPython).

3. vars() con clases que usan __slots__

class WithoutDict:
    __slots__ = ['data']
    def __init__(self, data: int):
        self.data = data

vars(WithoutDict(5)) # TypeError: vars() argument must have __dict__ attribute

Si la clase define __slots__ sin incluir __dict__, no habrá diccionario de atributos y vars() lanzará TypeError.

Para que funcione, debes incluir explícitamente __dict__ en __slots__:

class WithDictInSlots:
    __slots__ = ['data', '__dict__']
    def __init__(self, data: int):
        self.data = data

print(vars(WithDictInSlots(5))) # {'data': 5}

Es por eso que antes de llamar a vars(), se recomienda compruebar si el objeto tiene un __dict__:

if hasattr(obj, '__dict__'):
    attrs = vars(obj)

Esto evita excepciones y mejora la robustez del código.

Conclusión

vars() es simple, directa y muy útil para depuración rápida e inspección de objetos en Python.
Sin embargo:

• Comprueba que el objeto tenga __dict__.
• Usa alternativas como dir() o inspect.getmembers() si necesitas información más completa.
• Con __slots__ debes incluir explícitamente __dict__ si quieres compatibilidad con vars().

En Python existen operadores poco conocidos pero extremadamente útiles. Uno de ellos es el operador Walrus (:=), introducido en Python 3.8 mediante el PEP 572. Este operador permite asignar un valor a una variable dentro de una expresión, lo que lo hace ideal para evitar código redundante y escribir aplicaciones más limpias y concisas.

¿Qué problema resuelve?

Antes de Python 3.8, cuando era necesario asignar un valor y evaluarlo dentro de una condición, se solía repetir la misma expresión en diferentes partes del código. Un ejemplo clásico:

line = input("User input: ")
while line != "":
    print(f"Input: {line}")
    line = input("User input: ")

Este patrón obliga a repetir la llamada a input(...), generando duplicación innecesaria.

Con el operador Walrus (:=), es posible realizar la asignación directamente dentro de la condición, eliminando duplicación y mejorando la legibilidad:

while (line := input("User input: ")) != "":
    print(f"Input: {line}")

El resultado es un código más compacto, fácil de mantener y más claro de leer.

¿Dónde más puede usarse?

Además de bucles while, el operador Walrus también puede utilizarse en:

• List comprehensions cuando se desea filtrar y guardar valores temporales:

result = [y for x in data if (y := process(x)) is not None]

• Condicionales anidadas, donde calcular un valor varias veces penaliza el rendimiento.

El operador walrus no solo mejora la legibilidad, sino que también puede reducir el costo computacional en estructuras intensivas si se usa correctamente.

¿Cuándo se recomienda usar?

El uso del operador Walrus (:=) es recomendable especialmente cuando:

• Necesitas asignar y evaluar en una sola expresión
• Quieres evitar llamadas redundantes a funciones costosas.
• Buscas mejorar la legibilidad manteniendo el código compacto y expresivo

Consideraciones importantes

• Compatibilidad: Aunque el soporte oficial de Python 3.8 terminó en 2024 (ver cronograma), aún existen aplicaciones legacy en versiones anteriores. Asegúrate de que tu entorno de ejecución soporte el operador.
• Legibilidad: No abuses del operador. Si su uso compromete la claridad de la expresión, es mejor dividir el código en pasos separados.

Conclusión

El operador Walrus (:=) es una adición poderosa al lenguaje Python que permite asignar valores dentro de expresiones, especialmente útil en bucles, comprensiones de listas y condiciones complejas. Usado con criterio, te permite escribir código más limpio, conciso y eficiente, sin sacrificar claridad.

Si trabajas con Python 3.8 o superior y aún no lo has integrado en tu flujo de trabajo, este es un buen momento para hacerlo.

Uno de los retos más persistentes en el ecosistema Python es crear aplicaciones Python portables, que aíslen correctamente el manejo de dependencias y garanticen una distribución más confiable. Aunque los contenedores han mejorado considerablemente la portabilidad, todavía enfrentan desafíos relacionados con el tamaño de imagen y los tiempos de construcción y despliegue. En este artículo comparto mi experiencia utilizando PEX (Python EXecutable), una herramienta que permite empaquetar aplicaciones Python junto con todas sus dependencias en un único archivo ejecutable. Esta solución no solo mejora la portabilidad y reproducibilidad, sino que en algunos casos también puede ayudar a reducir el tiempo de arranque, un factor clave en entornos escalables y de alta demanda.

¿Qué es PEX?

PEX (Python EXecutable) es una herramienta de código abierto, desarrollada originalmente por Twitter, cuyo propósito es empaquetar una aplicación Python, todas sus dependencias (incluso las transitivas), y su punto de entrada en un solo archivo .pex.

Este ejecutable y puede trasladarse a cualquier sistema que tenga un intérprete Python compatible. Incluso es posible empaquetar el propio intérprete dentro del ejecutable, gracias a las distribuciones Python Standalone Builds de CPython, lo que elimina por completo la necesidad de tener Python preinstalado en el host de destino.

¿Por qué usar PEX?

PEX es una solución madura que resuelve varios problemas comunes en proyectos Python, tanto en desarrollo como en producción. A continuación, detallo algunos de sus beneficios clave:

1. Portabilidad real

El archivo .pex es completamente autocontenible, es decir, puedes moverlo de un entorno a otro sin preocuparte por replicar entornos virtuales, versiones de dependencias o configuraciones específicas.

En entornos más exigentes, puedes usar la opción –scie eager para incluir el intérprete Python directamente en el binario, lo que resulta ideal para despliegues en entornos edge, servidores bare-metal o funciones serverless.

2. Reproducibilidad garantizada

Al ser un artefacto autocontenido, PEX fija versiones exactas de todas las dependencias, lo que garantiza ejecuciones consistentes sin importar el entorno donde se ejecute el binario. Esta característica ayuda a mitigar errores comunes provocados por actualizaciones inesperadas en PyPI, así como inconsistencias entre entornos de desarrollo, pruebas y producción mal replicados.

3. Contenedores más livianos y seguros

Una de las ventajas más significativas de PEX es su integración con contenedores:

• Permite utilizar imágenes base minimalistas (python:slim, scratch, etc.).
• Elimina la necesidad de instalar pip, compilar dependencias o copiar el código fuente en la imagen final.
• Produce imágenes más pequeñas, más seguras y más rápidas de construir y desplegar.

Caso práctico: optimización de imágenes en MCP OpenAPI Proxy

Recientemente, integré PEX en el proyecto MCP OpenAPI Proxy, y logré reducir el tamaño de la imagen Docker de 152 MB a 134 MB. Esta mejora reduce el consumo de ancho de banda al distribuir contenedores y mejora la eficiencia en entornos con recursos limitados, como en despliegues en el Edge.

FROM python:3.12-slim-bookworm AS builder

COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/

WORKDIR /app

COPY . /app/

# Sincronización de dependencias y creación del ejecutable PEX
RUN --mount=type=cache,target=/root/.cache/uv \
    uv sync --locked --no-editable && \
    uvx pex -o mcp-proxy -c mcp-proxy --sh-boot --include-tools .

¿Y el desempeño?

Aunque PEX mejora portabilidad y tamaño, no necesariamente siempre puede llegar a reducir el tiempo de arranque. En las puebas de rendimiento que realicé usando hyperfine para comparar dos imágenes: una con PEX y otra con una estrategia anterior.

$ hyperfine 'docker run --rm pex --help' 'docker run --rm previous --help'

Resultados:

Benchmark 1: docker run --rm pex --help
  Time (mean ± σ):      2.643 s ±  0.040 
  Range (min … max):    2.585 s …  2.718 s    [10 runs]

Benchmark 2: docker run --rm previous --help
  Time (mean ± σ):      2.207 s ±  0.018 s
  Range (min … max):    2.180 s …  2.238 s    [10 runs]

Summary:
  'docker run --rm previous --help' ran
   1.20 ± 0.02 times faster than 'docker run --rm pex --help'

Conclusión: La imagen previa fue aproximadamente 1.2 veces más rápida en tiempo de arranque.

Esta diferencia puede no ser crítica en muchos escenarios, pero sí es relevante en aplicaciones serverless o de escalado rápido, donde cada milisegundo cuenta. Como siempre, es importante evaluar el equilibrio entre portabilidad, rendimiento y simplicidad de operación.

Conclusión

PEX es una herramienta poderosa, flexible y madura para desarrollar aplicaciones Python portables, reproducibles y eficientes.

Combinado con herramientas modernas como uv y estrategias multibuild en contenedores, permite construir imágenes más ligeras y robustas, con menos complejidad y más previsibilidad.

Si trabajas con Python en producción, o simplemente buscas formas más limpias y portables de entregar tus aplicaciones, vale la pena experimentar con PEX. Sus ventajas lo convierten en una herramienta imprescindible en el arsenal de cualquier desarrollador Python profesional.