Cómo Listar Módulos Importados en Python: Guía Completa y Herramientas

Técnicas manuales, automatizadas y profesionales para mapear las dependencias reales de tu proyecto

Por Jose Luis Rueda · 10 min lectura · 2026-07-29

El código no miente. Pero a veces, ni siquiera los desarrolladores saben con exactitud qué módulos están usando. Scripts que crecen, imports heredados, pruebas que dejaron dependencias sombra. En proyectos profesionales, listar los módulos importados es más que un ejercicio de curiosidad: es control de dependencias, seguridad, y optimización de despliegues.

Un simple import en Python puede desencadenar una cadena de dependencias que impacta el rendimiento, los costos de infraestructura y hasta la superficie de ataque de una aplicación. Y aunque el lenguaje ofrece módulos como modulefinder o ast para analizar esto, muchos equipos siguen adivinando.

En esta guía exploramos cómo listar todos los módulos importados desde tu código, con ejemplos reales, herramientas de línea de comandos, análisis estático con AST, y cómo plataformas como HolaGPT pueden acelerar ese trabajo sin perder precisión.

La importancia de conocer tus imports

Un proyecto Python típico acumula decenas de imports. Algunos vienen de la biblioteca estándar, otros son paquetes de terceros y muchos ni siquiera se declaran explícitamente en un requirements.txt. Listarlos con exactitud permite:

• Rastrear dependencias reales: lo que realmente necesita la aplicación para ejecutarse, no lo que suponemos.
• Detectar código muerto: imports que ya no se usan pero siguen generando acoplamientos.
• Minimizar imágenes de contenedores: saber qué paquetes instalar reduce el tamaño de las imágenes Docker.
• Auditoría de seguridad: cada módulo externo es un riesgo potencial; conocer la lista exacta ayuda al escaneo de vulnerabilidades.
• Cumplimiento de licencias: en software empresarial, listar las dependencias es obligatorio para verificar compatibilidad de licencias.

En entornos regulados o con pipelines estrictos, el análisis automático de imports se vuelve indispensable. Y Python, por su naturaleza dinámica, ofrece varios caminos para hacerlo.

Inspección manual: ¿cuándo conviene?

Para proyectos pequeños o scripts únicos, una revisión visual puede bastar. Abrir cada archivo y buscar líneas que comiencen con import o from ... import da una primera impresión. Herramientas como grep en sistemas Unix ayudan:

grep -E '^import |^from ' *.py

Pero esto falla con imports condicionales (dentro de if, try/except, funciones) y no distingue entre módulos estándar y locales. La inspección manual es rápida como primera aproximación, pero no escala. En equipos, es fuente de errores y omisiones.

Además, los alias (import numpy as np) o imports relativos complican una simple expresión regular. Por eso, el siguiente paso es usar las herramientas que el propio lenguaje provee.

Python modulefinder: el rastreador de dependencias integrado

Python incluye en su biblioteca estándar el módulo modulefinder, diseñado exactamente para analizar qué módulos importa un script. Básicamente, ejecuta el código en modo simulación y registra todos los módulos alcanzados.

Un ejemplo simple desde línea de comandos:

python -m modulefinder script.py

Esto imprime jerarquías de imports y marca aquellos que no encontró. Si necesitas una salida programática, puedes usarlo como librería:

from modulefinder import ModuleFinder
finder = ModuleFinder()
finder.run_script('mi_app.py')
for name, mod in finder.modules.items():
    print(name, mod.__file__)

La ventaja de modulefinder es que sigue imports encadenados y detecta dependencias ocultas. La desventaja: ejecuta el código real (aunque con restricciones). Eso significa que si tu script tiene efectos secundarios o necesita variables de entorno, puede fallar. No es análisis estático puro.

Para scripts simples o proyectos donde puedes controlar el entorno de ejecución, es una opción rápida y precisa. Pero en pipelines de CI/CD o repositorios grandes, se prefieren métodos estáticos.

Análisis estático con AST: mirada quirúrgica al código fuente

El módulo ast (Abstract Syntax Tree) de Python permite recorrer el árbol sintáctico del código sin ejecutarlo. Así, extraes cada nodo de tipo Import o ImportFrom con total precisión y sin riesgos de efectos laterales.

Un script mínimo para listar todos los imports en un archivo:

import ast

with open('archivo.py') as f:
    tree = ast.parse(f.read())

for node in ast.walk(tree):
    if isinstance(node, ast.Import):
        for alias in node.names:
            print('import', alias.name)
    elif isinstance(node, ast.ImportFrom):
        print('from', node.module, 'import', [a.name for a in node.names])

Este enfoque no resuelve qué módulos están realmente disponibles, solo lo que el código intenta importar. Es ideal para auditorías estrictas donde quieres la lista exacta de lo declarado, sin depender del entorno.

Puedes extenderlo para recorrer todo un proyecto, excluir imports relativos, o detectar imports dentro de funciones y clases. El análisis AST es la base de herramientas profesionales como pylint o bandit.

Herramientas de terceros: de pipreqs a pigar

La comunidad ha creado múltiples herramientas para automatizar la generación de listas de dependencias a partir de los imports. Las más destacadas:

pipreqs

Genera un requirements.txt escaneando todos los imports en el directorio del proyecto. Solo incluye paquetes de terceros que detecta en PyPI, ignorando estándares y locales.

pipreqs /ruta/proyecto --force

El resultado es un archivo con versiones exactas inferidas del entorno actual. Ideal para mantener dependencias limpias, aunque a veces falla con nombres de módulo que no coinciden con el nombre del paquete (ej. PIL vs Pillow).

pigar

Similar a pipreqs pero con capacidades adicionales: puede rastrear imports en notebooks Jupyter, detectar imports dinámicos (con __import__) y ofrece un modo interactivo para resolver ambigüedades.

pigar -p /ruta/proyecto

La salida es un requirements.txt comentado con la ubicación de cada import. Muy útil para auditorías de limpieza.

pipdeptree (para dependencias ya instaladas)

Muestra el árbol de dependencias con las versiones instaladas. No lista imports, pero complementa el análisis al mostrar qué hay realmente instalado y sus conflictos.

importlab (Google)

Una herramienta más compleja, usada internamente en Google, que construye un grafo de import para millones de líneas de código. Está disponible como librería de Python y resuelve imports tipo TypeScript/Python con inferencia de tipos.

La elección depende de la madurez del proyecto. Para equipos pequeños, pipreqs o pigar son un excelente punto de partida.

Manejando imports dinámicos y condicionales

El verdadero desafío son los imports que no aparecen como línea simple al inicio del archivo. Python permite cargar módulos en tiempo de ejecución con __import__(), importlib.import_module(), o dentro de funciones. También están los patrones de fallback:

try:
    import ujson as json
except ImportError:
    import json

Un análisis AST detecta el intento de importar ujson, pero herramientas basadas en ejecución como modulefinder solo registrarán el que realmente se cargó. Para ser exhaustivo, combina métodos:

• Análisis AST para capturar todas las menciones.
• Pruebas en diferentes entornos o con cobertura de código.
• Registros de profiling que capturen los módulos cargados en producción.

Algunos equipos instrumentan la aplicación con sys.modules para volcar la lista completa después de una ejecución completa. Esto no reemplaza el análisis de código, pero asegura que ningún módulo condicional quede fuera.

Automatización en CI/CD: que no se escape nada

Integrar el escaneo de imports en el pipeline de integración continua eleva la disciplina del equipo. Por ejemplo, un paso en GitHub Actions que corre pipreqs y compara el requirements.txt generado con el versionado. Si hay diferencias, la build falla.

Otra opción es usar pylint con una regla que marque imports no utilizados, combinado con isort para ordenarlos. Aunque no liste módulos, fuerza a mantener un estado limpio.

Para equipos que buscan máxima seguridad, se puede cruzar la lista de módulos importados con bases de vulnerabilidades conocidas usando safety o bandit. Todo automatizable con scripts cortos.

Cómo HolaGPT acelera el proceso

Plataformas de IA como HolaGPT, pensadas para profesionales hispanos, permiten automatizar el análisis de código con lenguaje natural. Puedes subir un archivo o describir tu proyecto y preguntar: “encuentra y lista todos los módulos importados en este código”, tal como lo harías con un colega experto.

HolaGPT entiende Python, AST y herramientas del ecosistema. Puede generar el script de análisis AST personalizado que necesites, o interpretar la salida de modulefinder y traducirla a un informe accionable para el equipo. Esto ahorra horas de scripting y reduce la fricción en tareas de mantenimiento.

Además, al estar integrado en un entorno colaborativo, los equipos pueden iterar rápido: pide que filtre imports de desarrollo, que cruce con bases de CVE, o que genere gráficos de dependencias, todo desde la misma conversación. No sustituye a las herramientas especializadas, pero sí reduce la barrera de entrada y acelera las auditorías.

En un panorama donde la deuda de dependencias crece rápido, tener un asistente que entienda código y contexto es una ventaja competitiva directa. Y HolaGPT está construido justo para ese perfil: el del desarrollador práctico que valora resultados, no complicaciones.

Buenas prácticas finales

Para mantener bajo control los imports en proyectos Python profesionales, adopta estas prácticas:

• Versiona un requirements.in (entrada) y un requirements.txt congelado. Herramientas como pip-compile facilitan este flujo.
• Incluye escaneo de imports en pre-commit hooks. Un hook que revise que ningún nuevo import no declarado en dependencias se cuela.
• Documenta los imports dinámicos. Si usas importlib, deja comentarios claros para que el análisis manual sea sencillo.
• Separa dependencias de desarrollo. Los módulos importados en tests o scripts de build deben estar aislados (dev-requirements.txt).
• Revisa periódicamente con HolaGPT. Un análisis trimestral con IA puede detectar imports huérfanos que las herramientas automáticas no capturaron.

Con estas herramientas y disciplina, listar los módulos importados deja de ser una tarea artesanal y se convierte en un pilar de la higiene del código.