top of page

Muru Examina las Disyuntivas de las Importaciones Perezosas de Python

hace 17 minutos
13 min de lectura
Illustrative photograph. Photo: Bibek ghosh / Pexels.

El informe para desarrolladores de Muru del 22 de noviembre cuestiona una optimización habitual: hacer que las aplicaciones Python arranquen más rápido puede ralentizar sus primeras solicitudes. La última entrega de Graham Dumpleton examina dónde trasladan trabajo las importaciones diferidas, quién espera por él y si los workers pierden oportunidades de compartir memoria.

El proyecto es un servidor Rust asistido por IA orientado a aplicaciones Python que utilizan ASGI, una interfaz de aplicación asíncrona, y WSGI, su equivalente síncrono. Dumpleton presentó el trabajo a principios de noviembre. La novedad es su análisis del comportamiento de las importaciones, no el lanzamiento de un nuevo servidor ni un hito de rendimiento verificado de forma independiente.

La decisión central consiste en cargar dependencias antes de crear los procesos worker, que gestionan las solicitudes, o cargarlas cuando las solicitudes las necesitan por primera vez. Gunicorn ya ofrece una opción relacionada de precarga. El argumento de Dumpleton cuestiona a los desarrolladores que consideran un arranque más corto como evidencia suficiente de un mejor rendimiento de la aplicación, especialmente cuando su despliegue ya protege a los usuarios de las demoras de inicio.

Muru Convierte los Costes de Importación en el Nuevo Foco

El último informe aborda la optimización de importaciones como una decisión de carga de trabajo, con consecuencias que van más allá del arranque de la aplicación.

El análisis de importaciones perezosas de Dumpleton sigue entregas anteriores sobre arquitectura de workers, lanzamientos, herramientas de desarrollo y trazado de solicitudes. Conecta esas piezas mediante una pregunta práctica: ¿cuándo debe una aplicación asumir el coste de cargar sus dependencias?

Una importación carga e inicializa un módulo Python, una unidad de código reutilizable. Esa operación puede activar importaciones adicionales, creando una cadena de trabajo. Por tanto, una función que requiere una biblioteca de hojas de cálculo puede cargar más que el código de aplicación que nombra directamente.

Las importaciones perezosas aplazan esa carga hasta que el código utiliza por primera vez el nombre importado. Su atractivo es sencillo: las dependencias que permanecen sin usar no tienen por qué consumir tiempo de arranque. En aplicaciones con funciones opcionales, esto puede evitar trabajo por completo.

Un servidor web añade otra consideración. Según Dumpleton, el servidor importa una aplicación en un proceso host antes de crear workers. Ese orden permite que los workers hereden módulos ya cargados, lo que modifica tanto cuándo ocurre el trabajo como con qué frecuencia.

Su ejemplo utiliza Flask, un framework web de Python, para crear una pequeña tienda. Un informe de inventario depende de pandas, una biblioteca de análisis de datos. Las descargas de hojas de cálculo dependen de openpyxl, una biblioteca para crear y leer libros de Excel.

Estas funciones tienen disposiciones de importación distintas. El informe carga su dependencia dentro de la función que gestiona la solicitud. La función de hojas de cálculo incorpora inicialmente su dependencia a la aplicación durante el arranque. Por tanto, el ejemplo expone carga diferida y carga anticipada dentro de la misma aplicación.

Dumpleton ejecuta el ejemplo en Python 3.14 con dos workers. Describe herramientas para inspeccionar las importaciones del host junto con los módulos cargados posteriormente por workers individuales. La comparación importante abarca ambas etapas, en lugar de detenerse cuando la aplicación queda disponible.

Esto hace que el informe sea más específico que una recomendación general de aplazar bibliotecas pesadas. Pregunta si las dependencias permanecen sin usar durante ciclos de vida reales de los workers. Una biblioteca que todos los workers terminan necesitando plantea un cálculo distinto de otra que la mayoría de los workers nunca utiliza.

El momento también importa. El resumen sobre servidores Python de Simon Willison del 21 de noviembre destacó el proyecto y su detallado relato de desarrollo. La entrega del 22 de noviembre añade una cuestión concreta de optimización a esa introducción más amplia. Ninguna fecha de publicación demuestra que el servidor haya completado una validación en producción.

Un Arranque Más Rápido No Siempre Llega a los Usuarios

Un arranque más corto importa de forma distinta cuando los workers existentes siguen atendiendo tráfico y cuando un visitante espera a que una aplicación despierte.

Dumpleton describe un modelo de despliegue que inicia una versión de reemplazo junto a la versión que ya atiende solicitudes. El tráfico se desplaza después de que el reemplazo está listo. Con este esquema, las importaciones de la aplicación consumen tiempo de despliegue sin retrasar necesariamente a los visitantes que utilizan la versión existente.

La preparación es la comprobación que determina si una instancia puede aceptar tráfico. Si esa comprobación espera a la carga de la aplicación y a la inicialización de los workers, los usuarios no encuentran esos costes de arranque mediante el enrutamiento habitual. Aplazar dependencias puede trasladar trabajo antes oculto a solicitudes visibles.

Esta distinción sitúa a los desarrolladores de aplicaciones y a los responsables de despliegue en el mismo camino de decisión. Los desarrolladores pueden reducir el tiempo que tarda en cargarse su aplicación. Los operadores deben determinar si esa reducción mejora la velocidad de despliegue, la latencia de usuarios, el uso de recursos o alguna combinación.

Los contenedores, entornos aislados de ejecución de aplicaciones, crean una situación relacionada. Un inicio más rápido puede ayudar a que instancias adicionales estén disponibles antes. Eso sigue siendo útil incluso cuando el enrutamiento mantiene las solicitudes alejadas hasta que esas instancias superan sus comprobaciones de preparación.

Sin embargo, proteger la carga inicial de la aplicación no protege automáticamente cada función opcional. Un worker puede estar listo para atender sus rutas principales y seguir careciendo de una dependencia necesaria para un endpoint menos frecuente. La primera solicitud que alcance ese endpoint asume el coste diferido.

El escalado a cero cambia de nuevo el equilibrio. Esto supone detener la capacidad de servicio inactiva hasta que regrese el tráfico. Dumpleton describe un caso en el que el propio host se ha detenido, dejando a la siguiente solicitud esperando el arranque de la aplicación.

Aquí, evitar una importación innecesaria puede reducir directamente la espera del visitante. Pero el beneficio depende de qué función solicite ese visitante. Despertar la aplicación rápidamente ayuda menos si la misma solicitud activa inmediatamente la dependencia diferida.

El desarrollo introduce otra prioridad legítima. Recargar significa reiniciar la ejecución de la aplicación después de un cambio de código. Cuando esto ocurre repetidamente, evitar dependencias no utilizadas puede acortar el ciclo de retroalimentación para los desarrolladores que trabajan en funciones no relacionadas.

Son experiencias separadas con medidas de éxito distintas. Una recarga de desarrollo, un despliegue de producción protegido y una solicitud que despierta una aplicación detenida no deberían compartir un veredicto de optimización solo porque cada uno implica un arranque.

La respuesta necesaria es medir mejor en todas las etapas del despliegue. Los equipos que evalúan importaciones perezosas deben identificar quién espera, qué dependencias pasan al manejo de solicitudes y si las mejoras de arranque resisten tráfico realista.

Ese requisito también limita las afirmaciones generales sobre rendimiento. Una carga del host más rápida demuestra que una etapa se hizo más corta. No demuestra que la aplicación atienda a los usuarios más rápido, gestione más tráfico o consuma menos memoria durante toda su vida útil.

Cargar Una Vez Compite con Cargar Bajo Demanda

La principal disyuntiva consiste en pagar una vez antes de que se inicien los workers frente a pagar después en cada worker que necesita una dependencia.

El diseño pre-fork del servidor crea workers copiando un proceso inicializado. La memoria copy-on-write permite que esos procesos compartan inicialmente páginas de memoria hasta que los cambios exigen copias privadas. Cargar módulos de antemano puede, por tanto, facilitar el uso compartido entre workers.

Aplazar una importación cambia esa secuencia. Cada worker que necesita por primera vez el módulo lo carga por separado. Los workers que nunca lo necesitan evitan ese trabajo, mientras que los que sí lo necesitan asumen la inicialización durante su propia ejecución.

Por ello, el número de workers que utilizan una dependencia importa más que su coste de importación por sí solo. Una dependencia costosa puede ser una candidata sensata para aplazarse cuando pocos workers encuentran su función. La misma dependencia se vuelve menos atractiva cuando todos los workers terminan cargándola.

La elección subyacente es anterior a este proyecto. La opción documentada de precarga de aplicaciones de Gunicorn carga el código de la aplicación antes de que los workers hagan fork. Su documentación describe posibles ahorros de memoria y un arranque más rápido del servidor, al tiempo que analiza diferencias en la recarga de aplicaciones.

Esa comparación ofrece al nuevo informe un punto de referencia consolidado. La precarga es en sí misma una estrategia de servicio existente. El énfasis distintivo aquí es conectar los costes de importación del host con evidencia sobre lo que cargan posteriormente los workers individuales.

La arquitectura de procesos también limita las comparaciones. El modelo de procesos worker documentado de Uvicorn utiliza spawning en lugar de pre-forking para su gestor multiproceso integrado. Spawning inicia procesos separados, por lo que no se aplican supuestos idénticos sobre el estado heredado de la aplicación.

Estas diferencias no identifican un ganador universal entre servidores. Establecen por qué los consejos sobre importaciones deben nombrar el modelo de despliegue. Un resultado obtenido con módulos heredados no puede describir automáticamente una configuración de servidor que inicia workers de forma independiente.

El ejemplo de tienda de Dumpleton hace tangible la distinción. Inicialmente, solo un worker necesita la dependencia de hojas de cálculo. El otro evita cargarla. Más adelante, descargas adicionales llegan a ambos workers, cambiando la evidencia detrás de la recomendación anterior.

La función de informes avanza en la dirección opuesta. Ambos workers cargan su dependencia diferida, duplicando trabajo que el host podría haber realizado antes de crearlos. Según Dumpleton, precargar explícitamente ese módulo traslada la inicialización fuera de esas primeras solicitudes de informes.

Los ciclos de vida de los workers complican aún más el panorama. Un worker de larga duración tiene más oportunidades de encontrar una función poco frecuente. Un worker reemplazado antes de que llegue esa solicitud podría evitar la dependencia durante toda su vida útil.

La distribución del tráfico importa por la misma razón. Una función puede representar una pequeña proporción de solicitudes y, aun así, terminar llegando a cada worker de larga duración. Describirla como “rara” no demuestra que aplazarla ahorre trabajo en todo el conjunto de servicio.

Por tanto, la cuestión económica es operativa, no estilística. Los equipos deben sopesar la demora de arranque, la latencia del primer uso y el uso compartido de memoria frente a la frecuencia con la que las dependencias permanecen sin usar. Una preferencia por importaciones anticipadas o perezosas no puede sustituir esos datos de carga de trabajo.

Las Primeras Solicitudes Revelan Dónde se Trasladó el Trabajo

La evidencia más sólida del informe es la conexión entre una carga del host más corta y el trabajo de importación que aparece dentro de las solicitudes.

Dumpleton mide la carga del host de la tienda con el registro de importaciones desactivado, reconociendo que el perfilado añade trabajo. El perfilado es la recopilación de mediciones de ejecución utilizada para localizar costes. Separar las ejecuciones de diagnóstico de las comparaciones de tiempo ayuda a evitar confundir la sobrecarga de medición con el comportamiento de la aplicación.

En cinco inicios para cada configuración, informa de una carga mediana del host de 83 milisegundos sin aplazamiento y de 35 milisegundos con él. Una mediana es la observación central después de ordenar las mediciones. Estas cifras describen su ejemplo, no un benchmark general de servidores.

El trabajo diferido aparece entonces en la solicitud de hoja de cálculo. La cabecera de su ejemplo atribuye 52.03 milisegundos a la importación de módulos dentro de una respuesta de aplicación que tarda 56.89 milisegundos. Por tanto, la carga más corta del host no significa que la dependencia se haya vuelto más barata de inicializar.

El servidor expone esas mediciones mediante Server-Timing, una cabecera de respuesta HTTP que los navegadores pueden mostrar como información de tiempos. Su entrada de importación distingue la carga de módulos de otras tareas de solicitud. Esto ofrece a los desarrolladores una forma de conectar un cambio de inicio con su efecto posterior.

Otra distinción aparece cuando las solicitudes se solapan. El bloqueo de importación de Python coordina la inicialización de módulos para que la ejecución concurrente no inicialice de forma independiente el mismo módulo. Una solicitud que espera ese bloqueo puede sufrir retraso sin realizar la importación por sí misma.

En el ejemplo de informe concurrente de Dumpleton, una solicitud carga la dependencia mientras otra espera. Las cabeceras registradas distinguen el tiempo de importación del tiempo de espera de importación. Ambas solicitudes experimentan el episodio de inicialización, aunque solo una realiza la carga.

Esa observación amplía el coste más allá de un único visitante inicial desafortunado. Las solicitudes que comparten un worker pueden encontrar retrasos relacionados cuando necesitan un módulo cuya inicialización sigue sin terminar. Contar solo la solicitud que lo importó subestima la experiencia.

Según el informe, precargar el módulo de informes cambia esas primeras respuestas. Dumpleton registra primeras solicitudes de informe de entre 4,5 y 9 milisegundos después de trasladar la dependencia a la carga del host. Son resultados comunicados por el autor a partir de la aplicación de ejemplo.

El ejemplo respalda una conclusión acotada: cambiar la ubicación de la importación modificó dónde empleaba tiempo esta aplicación. No establece una ventaja de rendimiento en producción, una reducción general de memoria ni superioridad frente a servidores competidores.

El contexto de las herramientas ayuda a explicar por qué Dumpleton enfatiza la evidencia de las solicitudes. Su entrega anterior sobre trazado de solicitudes conecta las operaciones de la aplicación con los diagnósticos de desarrollo. Ese ejemplo utiliza una tienda para revelar consultas repetidas a la base de datos y llamadas salientes.

Son ejemplos construidos, no resultados de despliegues de clientes. Su valor reside en ilustrar qué pueden inspeccionar los desarrolladores. El informe de importaciones amplía ese enfoque al conectar la carga del host, los costes del primer uso y los workers que finalmente necesitaron cada módulo.

La compatibilidad con Python mantiene el veredicto condicionado

La compatibilidad del lenguaje hace más fácil expresar el aplazamiento, pero la compatibilidad y el uso real siguen determinando si ayuda.

La especificación de importaciones explícitas diferidas de Python se dirige a Python 3.15 y define la carga de módulos cuando los nombres importados se usan por primera vez. También proporciona una declaración transitoria de módulo que los intérpretes anteriores ignoran. Por ello, la sintaxis nueva y las declaraciones compatibles con versiones anteriores requieren un tratamiento distinto.

Dumpleton describe el uso de unwrapt, su paquete de aplazamiento de importaciones, para admitir un comportamiento de aplazamiento seleccionado en versiones anteriores de Python. Esta distinción importa a los equipos que dan soporte a varios intérpretes. Escribir una declaración no garantiza por sí solo el mismo comportamiento de ejecución en todas partes.

Su informe identifica una limitación específica del enfoque para versiones anteriores: unwrapt puede diferir una importación simple, mientras que la compatibilidad nativa también puede diferir una importación from-import. Una importación from-import vincula nombres seleccionados de un módulo. Por tanto, parte del código de la aplicación necesita reescribirse antes de que el mecanismo de versiones anteriores pueda diferirlo.

Incluso un aplazamiento exitoso puede no ahorrar nada cuando la inicialización usa inmediatamente la dependencia. La biblioteca de hojas de cálculo de la tienda ofrece un ejemplo: se utiliza una dependencia anidada mientras su módulo importador sigue cargándose. Retrasar esa importación simplemente la pospone dentro de la misma secuencia de inicialización.

Este es un límite útil para las sugerencias automatizadas. Una importación puede parecer costosa en un informe sin representar trabajo evitable. Las herramientas deben distinguir las dependencias que permanecen sin tocar de las dependencias requeridas inmediatamente para construir el estado del módulo importador.

La misma cautela se aplica a los consejos derivados del tráfico. Un informe de worker cubre las solicitudes ya observadas. Si no se ha utilizado una función opcional, la ausencia de una importación solo demuestra que el tráfico muestreado no la necesitó.

Una muestra más amplia puede invertir la recomendación. Dumpleton muestra cómo la dependencia de hojas de cálculo pasa de un worker a ambos tras más descargas. Ese cambio ilustra por qué los desarrolladores deberían revisar las conclusiones después de tráfico representativo, en vez de tratar una recomendación temprana como permanente.

También existe una brecha de verificación. Los ejemplos proceden del autor del proyecto y no se han reproducido aquí de forma independiente. Una salida detallada mejora la capacidad de inspección, pero no puede sustituir las pruebas externas en distintas aplicaciones, dependencias y entornos de despliegue.

La asistencia de IA añade otra razón para examinar cuidadosamente la evidencia. Willison describe el proyecto como asistido por IA, mientras Dumpleton enfatiza su responsabilidad de decidir qué sigue siendo inadecuado. Ni el lenguaje de implementación ni el método de desarrollo establecen la fiabilidad operativa.

Eso no exige descartar el trabajo. Significa separar el comportamiento documentado de una confianza más amplia. La visibilidad de las importaciones puede ser útil mientras persisten preguntas sobre compatibilidad, gestión de fallos, mantenimiento y rendimiento fuera del ejemplo.

Para los equipos de ingeniería, estas distinciones deben formar parte de un registro compartido de experimentos y decisiones. Una base de conocimiento consultable puede conservar los supuestos de carga de trabajo junto con los resultados. Sin esos supuestos, una optimización exitosa puede convertirse en una orientación engañosa al copiarse en otro servicio.

Qué reforzaría el caso a continuación

La siguiente evidencia útil consiste en un comportamiento reproducible entre cargas de trabajo, versiones de intérprete y poblaciones cambiantes de workers.

La primera señal es la reproducción independiente de los resultados sobre la ubicación de las importaciones. Las pruebas deberían seguir las dependencias desde la inicialización del host hasta la creación de workers y las primeras solicitudes. También deberían comparar las solicitudes posteriores, para que una breve mejora en el inicio no oculte costes repetidos de los workers.

Una reproducción convincente revelaría las dependencias de la aplicación, las versiones del intérprete, el número de workers y la composición del tráfico. Las mediciones de memoria ayudarían a comprobar el argumento de compartición junto con los tiempos. La evidencia de que persisten las mismas relaciones reforzaría el análisis central de compensaciones del informe.

Los resultados que varíen sustancialmente seguirían siendo informativos. Delimitarían dónde se aplican las mediciones e identificarían qué dependencias o decisiones de despliegue predominan. El objetivo es comprender el límite del comportamiento, en lugar de obtener una cifra aislada impresionante.

La segunda señal es evidencia de compatibilidad que abarque el aplazamiento nativo y el de versiones anteriores. Los equipos necesitan saber si las importaciones seleccionadas se difieren como se pretende y si el uso de dependencias durante el inicio cancela los ahorros esperados. También necesitan diagnósticos claros cuando una forma de importación recibe un tratamiento distinto.

Las pruebas de compatibilidad exitosas reforzarían la confianza para aplicar la misma política en los entornos admitidos. Las sorpresas repetidas debilitarían el argumento para una adopción amplia y favorecerían un uso más selectivo. La documentación debería hacer visibles esas diferencias antes de que los equipos modifiquen la carga de la aplicación.

La tercera señal es la observación a lo largo de ciclos de vida realistas de los workers. Un registro de despliegue útil rastrearía qué workers cargan cada dependencia opcional conforme llega tráfico y cambia la capacidad. Eso comprobaría si las funciones aparentemente poco frecuentes siguen siéndolo a nivel de worker.

Si la mayoría de los workers evita una dependencia antes de ser reemplazada, el aplazamiento tiene un argumento más sólido para evitar una inicialización innecesaria. Si casi todos los workers la cargan, merece reconsiderarse la precarga. Cualquiera de los dos resultados convertiría una suposición sobre el tráfico en evidencia sobre el conjunto de servicio.

Estas señales también mantienen centrada la evaluación. Una lista creciente de funciones no resolvería por sí sola la cuestión de las importaciones. Lo que importa es si los diagnósticos ayudan a los equipos a elegir una política que mejore su combinación real de inicio, latencia de solicitudes y uso de recursos.

Para los lectores que consideren Muru, comiencen con una aplicación cuyas dependencias opcionales y comportamiento de despliegue ya entiendan. Conserven la línea de base, identifiquen quién espera durante el inicio y comparen las solicitudes del primer uso con el tráfico posterior. Mantengan las mediciones vinculadas a ciclos de vida específicos de los workers y versiones del intérprete. Pregúntense si una importación evitada sigue evitándose o simplemente reaparece en todos los workers tras suficientes solicitudes. Consideren la tienda publicada como un ejemplo comprobable y examinen después si su propia aplicación sigue el mismo patrón. Lean los informes subyacentes antes de cambiar la configuración de producción y conserven las condiciones detrás de cada resultado. La decisión que vale la pena tomar es cuándo debe su aplicación pagar por sus dependencias, respaldada por evidencia sobre las personas y los procesos que, de otro modo, pagarán más tarde.

 
 

Empieza gratis

Un asistente de IA local-first con gestión del conocimiento personal

Para ofrecer una mejor experiencia con la IA,

actualmente remio solo es compatible con Windows 10+ (x64) y M-Chip Macs.

Tu aliado de IA para el trabajo
Haz más con remio

Planifica. Crea. Entrega.
Todo en un solo lugar.

bottom of page