Módulos y paquetes — Importar desde otros archivos

Las aplicaciones Python suelen construirse repartiendo el trabajo entre varios archivos y conectándolos entre sí. Este artículo recorre las unidades llamadas módulos y paquetes, además de cómo la sentencia import trae funciones desde otro archivo.

Módulo vs paquete vs librería

Python organiza el código en tres tamaños: módulo → paquete → librería. Un módulo es un único archivo .py, un paquete es una carpeta de módulos y una librería es el siguiente nivel — un paquete distribuible.

Librería estándar vs librería de terceros

Python viene con una librería estándar lista para usar, y existen librerías de terceros que se instalan aparte. Las estándar como math, os y json funcionan con un simple import. Las de terceros como pandas o requests necesitan primero pip install nombre_del_paquete.

Prueba la librería estándar math.

① Imprime el techo entero de 1.7 con math.ceil(1.7).

② Imprime la raíz cuadrada de 3 con math.sqrt(3).

(Si lo ejecutas correctamente, aparecerá la explicación.)

Importar tus propios módulos

Puedes importar tus propios archivos .py igual que la librería estándar. Cuando ejecutas Python localmente, coloca main.py y el archivo que quieres importar (math_utility.py) en la misma carpeta — eso es todo. Los archivos de la misma carpeta se cargan con un simple import math_utility desde main.py (sin sufijo .py en la sentencia import).

math_utility.py está adjunto a la izquierda (ábrelo desde 📂 Files para inspeccionarlo).

① Cárgalo con import math_utility.

② Llama intencionadamente a add(10, 20) sin el prefijo del módulo y confirma con try/except que obtienes un NameError — import math_utility solo trae el nombre math_utility mismo al ámbito de main, así que add no es directamente invocable.

③ Después imprime math_utility.add(10, 20) y math_utility.multiply(5, 5) con el prefijo del nombre del módulo — la forma correcta de llamarlos.

import ejecuta el archivo entero una sola vez

Cuando escribes import math_utility, Python ejecuta math_utility.py de arriba abajo una sola vez. Las definiciones de función (def) se registran en memoria en ese momento, así que después puedes llamarlas como math_utility.add(...). Los cuerpos de esas funciones no se ejecutan durante el import — solo el código fuera de cualquier función (el nivel superior del módulo).

No ejecutes trabajo pesado en el nivel superior del módulo

El nivel superior es el código que está en la indentación más exterior — fuera de cualquier función o clase. Python lo ejecuta de arriba abajo cada vez que se importa el módulo. Poner trabajo pesado ahí (conexiones a BD, cargar archivos enormes, bucles infinitos) significa que simplemente importar el módulo tarda eternidades. Mantén la lógica pesada dentro de funciones y deja en el nivel superior solo definiciones e inicialización mínima.

Distinguir ejecución directa de import — __name__

Los archivos Python vienen en dos sabores: scripts ejecutados directamente (los lanzas con python xxx.py) y módulos importados por otra cosa. El mismo archivo puede jugar ambos papeles, y muchas veces necesitas distinguir cuál está pasando — por ejemplo, «ejecuta una prueba rápida solo cuando el archivo se ejecuta directamente».

La comprobación usa la variable especial __name__ que Python establece automáticamente. Cuando el archivo se ejecuta directamente, __name__ vale "__main__". Cuando el archivo se importa, __name__ es el nombre del módulo (el nombre del archivo). El código dentro de if __name__ == "__main__": solo se ejecuta en el primer caso.

# math_utility.py
def add(a, b):
    return a + b


# Prueba rápida solo cuando se ejecuta directamente
if __name__ == "__main__":
    print("check:", add(10, 20))   # 30

# Cuando otro archivo hace `import math_utility`,
# el bloque if de arriba no se ejecuta — solo se expone la función add.

El math_utility_2.py adjunto define una función show_name() que imprime su propio __name__, más un bloque if __name__ == "__main__": al final (ábrelo desde 📂 Files para mirar).

① Desde el lado de main, importa math_utility_2 e imprime el __name__ de main.

② Llama a math_utility_2.show_name() y comprueba cómo se ve __name__ desde el lado importado.

Combinar varios de tus propios módulos

En aplicaciones reales sueles partir las funciones en archivos separados por responsabilidad y traerlas todas desde main.py. Por ejemplo, las comprobaciones de entrada viven en validator.py, el formato de presentación en formatter.py. Con responsabilidades partidas así, los cambios en el formato solo tocan formatter.py — main.py y validator.py se quedan intactos.

Completa los validator.py y formatter.py adjuntos y luego importa ambos desde main.py.

① En validator.py, implementa is_valid_price(price) — devuelve True si price es un int positivo, False en otro caso.

② En formatter.py, implementa format_price(price) — toma un int, añade un recargo del 5% con int(price + price * 0.05), y devuelve una cadena como "con impuesto: $1575".

③ En main.py, importa ambos. Decide si price = 1500 es válido, formatéalo e imprime el resultado.

Este artículo cubrió la jerarquía módulo / paquete / librería, cómo import trae funciones desde otros archivos, qué se ejecuta en el momento del import, el patrón __name__ == "__main__" para distinguir ejecuciones directas de imports, y la separación multi-módulo donde cada archivo tiene una responsabilidad. El siguiente artículo profundiza en los paquetes y el archivo __init__.py.