Cómo comprobar si un módulo está importado en Python

Introducción

En este laboratorio (lab), aprenderás cómo verificar si un módulo está importado en Python. El laboratorio cubre los conceptos básicos de la importación de módulos, incluyendo la creación e importación de un módulo simple. Aprenderás cómo usar la declaración import para traer módulos a tu programa y acceder a sus funciones y variables.

Luego, el laboratorio explora el diccionario sys.modules, que almacena todos los módulos importados en la sesión actual de Python. También aprenderás cómo usar el módulo importlib para verificar si un módulo ha sido importado.

Skills Graph

Aprende sobre la Importación de Módulos

En este paso, aprenderás sobre la importación de módulos en Python. Los módulos son archivos que contienen definiciones y declaraciones de Python. La declaración import se utiliza para traer módulos a tu programa actual, lo que te permite usar las funciones y variables definidas dentro de ellos.

Primero, creemos un módulo simple. Abre el editor de VS Code en el entorno de LabEx y crea un nuevo archivo llamado my_module.py en el directorio ~/project.

## ~/project/my_module.py
def greet(name):
    return f"Hello, {name}!"

PI = 3.14159

Este módulo define una función greet y una variable PI. Ahora, creemos otro archivo de Python para importar y usar este módulo. Crea un nuevo archivo llamado main.py en el directorio ~/project.

## ~/project/main.py
import my_module

name = "LabEx User"
greeting = my_module.greet(name)
print(greeting)
print("PI =", my_module.PI)

En este archivo main.py, usamos la declaración import my_module para traer el my_module que creamos anteriormente. Luego accedemos a la función greet y a la variable PI utilizando la notación de punto (my_module.greet, my_module.PI).

Para ejecutar este código, abre una terminal en el entorno de LabEx (ya debería estar abierta en el panel inferior de VS Code). Asegúrate de que tu directorio actual sea ~/project. Si no lo es, navega a él utilizando el comando cd:

cd ~/project

Ahora, ejecuta el script main.py utilizando el comando python:

python main.py

Deberías ver la siguiente salida:

Hello, LabEx User!
PI = 3.14159

Esto demuestra cómo importar un módulo y usar su contenido en otro archivo de Python.

Verificar el Diccionario sys.modules

En este paso, explorarás el diccionario sys.modules, que es una parte crucial del sistema de importación de módulos de Python. sys.modules es un diccionario que contiene todos los módulos que se han importado en la sesión actual de Python. Comprender este diccionario puede ayudarte a entender cómo Python gestiona los módulos.

Para comenzar, creemos un script de Python llamado check_modules.py en el directorio ~/project. Este script importará el módulo sys e imprimirá las claves del diccionario sys.modules.

## ~/project/check_modules.py
import sys

print("Modules currently in sys.modules:")
for module_name in sys.modules.keys():
    print(module_name)

import my_module

print("\nModules after importing my_module:")
for module_name in sys.modules.keys():
    print(module_name)

Este script primero importa el módulo sys. Luego, itera a través de las claves del diccionario sys.modules e imprime el nombre de cada módulo. Después, importa el my_module creado en el paso anterior e imprime el diccionario sys.modules nuevamente para mostrar el módulo recién importado.

Ahora, ejecuta el script utilizando el comando python en la terminal:

cd ~/project
python check_modules.py

Verás una lista de módulos que ya están cargados cuando el intérprete de Python se inicia, seguida de la misma lista con my_module agregado después de la declaración import my_module. La salida se verá algo así (la lista exacta de módulos puede variar):

Modules currently in sys.modules:
builtins
sys
_frozen_importlib
_imp
_warnings
_io
... (many more modules)

Modules after importing my_module:
builtins
sys
_frozen_importlib
_imp
_warnings
_io
... (many more modules)
my_module

Observa que my_module se agrega al diccionario sys.modules después de la declaración import. Este diccionario actúa como una caché, por lo que si intentas importar el mismo módulo nuevamente, Python simplemente lo recuperará de sys.modules en lugar de recargarlo desde el disco. Esta optimización mejora el rendimiento.

Utilizar importlib para Verificar

En este paso, aprenderás cómo utilizar el módulo importlib para importar módulos de forma programática y verificar su existencia. importlib es parte de la biblioteca estándar de Python y proporciona una forma de interactuar con el sistema de importación.

Creemos un script de Python llamado verify_import.py en el directorio ~/project. Este script utilizará importlib para importar my_module y comprobar si se importó correctamente.

## ~/project/verify_import.py
import importlib

module_name = "my_module"

try:
    module = importlib.import_module(module_name)
    print(f"Module '{module_name}' imported successfully.")
    print(f"Greeting: {module.greet('LabEx')}")
except ImportError:
    print(f"Failed to import module '{module_name}'.")

En este script, utilizamos importlib.import_module() para importar my_module. Si el módulo se encuentra e importa correctamente, el script imprime un mensaje de éxito y llama a la función greet del módulo. Si el módulo no se encuentra, se levanta una excepción ImportError y el script imprime un mensaje de error.

Ahora, ejecuta el script utilizando el comando python en la terminal:

cd ~/project
python verify_import.py

Deberías ver la siguiente salida:

Module 'my_module' imported successfully.
Greeting: Hello, LabEx!

Si cambiases module_name a un módulo que no existe, como "nonexistent_module", y ejecutases el script de nuevo, verías:

Failed to import module 'nonexistent_module'.

Esto demuestra cómo utilizar importlib para importar módulos de forma dinámica y manejar posibles errores de importación. Esto es especialmente útil en situaciones en las que necesitas cargar módulos basados en la entrada del usuario o en archivos de configuración.

Resumen

En este laboratorio (lab), aprendiste sobre la importación de módulos en Python. Creaste un módulo llamado my_module.py que contiene una función greet y una variable PI. Luego, creaste main.py para importar my_module y utilizar su contenido, demostrando cómo la declaración import incorpora módulos a tu programa y cómo acceder a funciones y variables dentro de ellos utilizando la notación de punto.

También comenzaste a explorar el diccionario sys.modules, que contiene todos los módulos que se han importado en la sesión actual de Python, una parte crucial del sistema de importación de módulos de Python.