Módulo 5: Módulos, paquetes y entorno virtual

Tema 18: Importación de módulos propios y de terceros

Objetivo del tema

Aprender a organizar el código en módulos y paquetes, reutilizar funciones creadas en otros archivos, y aprovechar bibliotecas externas instaladas con pip.

1. ¿Qué es un módulo en Python?

Un módulo es un archivo con extensión .py que contiene código reutilizable (funciones, clases, variables, etc.). Sirve para organizar y reutilizar el código de manera ordenada.

Ejemplo de módulo (saludos.py):

Uso del módulo:

2. Tipos de importación

Python ofrece varias formas de importar módulos:

a) Importación completa

Accedemos a los elementos con el nombre del módulo como prefijo.

b) Importación parcial (selectiva)

Solo importa una función, clase o variable específica.

c) Importación con alias

Se usa para abreviar nombres largos de módulos.

d) Importar todo (no recomendado)

Importa todo el contenido del módulo, pero puede generar conflictos de nombres. Usa esta forma solo en casos muy controlados.

3. Módulos propios (creados por el programador)

Puedes crear tus propios módulos en archivos .py y usarlos en otros scripts del mismo proyecto.

Estructura de ejemplo:

proyecto/
    │
    ├── main.py
    └── utilidades.py

utilidades.py

main.py

4. La carpeta __pycache__ (caché de bytecode)

La primera vez que importas un módulo, Python lo compila a bytecode (un formato intermedio que la máquina virtual de Python ejecuta más rápido) y guarda el resultado en una carpeta llamada __pycache__, junto al módulo:

proyecto/
    │
    ├── main.py
    ├── utilidades.py
    └── __pycache__/
        └── utilidades.cpython-311.pyc

Cosas importantes que debes saber:

  • Solo se crea al importar módulos, no al ejecutar directamente el script principal.
  • El nombre del .pyc incluye la versión del intérprete (cpython-311), para que distintas versiones de Python no se pisen entre sí.
  • Es únicamente una caché. Si borras __pycache__, Python la regenera en el siguiente import. Además comprueba la fecha del .py: si lo modificas, recompila automáticamente, así que nunca ejecutas código desincronizado.
  • No la edites ni la subas al control de versiones: es un artefacto generado. Añádela a tu .gitignore:
__pycache__/
*.pyc

En resumen: ver aparecer __pycache__ es normal y buena señal (Python está acelerando tus importaciones). Puedes ignorarla por completo en tu día a día.

5. Importar módulos desde otras carpetas

Cuando el módulo no está en la misma carpeta, debes ajustar la ruta o convertirlo en paquete.

Opción 1: usando un paquete

Estructura:

mi_proyecto/
    │
    ├── main.py
    └── utilidades/
        ├── __init__.py
        └── matematicas.py

matematicas.py

main.py

Nota: El archivo __init__.py (aunque puede estar vacío) indica que la carpeta es un paquete Python.

Opción 2: modificando la ruta manualmente

otro_proyecto/
    │
    ├── main.py
    └── utilidades/
        ├── __init__.py
        └── basedatos.py

mi_proyecto/
    │
    ├── main.py
    └── utilidades/
        ├── __init__.py
        └── matematicas.py

Si necesitas importar desde otra carpeta fuera del proyecto:

No se recomienda en proyectos grandes: es mejor usar paquetes estructurados.

6. Módulos estándar de Python

Python incluye módulos integrados listos para usar. Algunos ejemplos:

Módulo Descripción Ejemplo
math Funciones matemáticas math.sqrt(16)
random Generación de números aleatorios random.randint(1,10)
datetime Manejo de fechas y horas datetime.datetime.now()
os Interacción con el sistema operativo os.listdir()
sys Interacción con el intérprete de Python sys.version

Ejemplo:

7. Módulos de terceros (bibliotecas externas)

Python permite instalar librerías adicionales usando pip, el gestor de paquetes.

Instalar un módulo:

pip install requests

Usarlo en tu script:

8. Comprobar módulos instalados

Puedes listar los módulos instalados:

pip list

Y desinstalar uno:

pip uninstall requests

O verificar si uno está disponible:

pip show numpy

9. Recomendación: usar entornos virtuales

Para evitar conflictos entre versiones de librerías, es recomendable usar entornos virtuales (tema siguiente).

En un entorno virtual cada proyecto tiene sus propias dependencias.

10. Actividades prácticas

Ejercicio 1

Crea un módulo llamado operaciones.py con las funciones:

  • sumar(a, b)
  • restar(a, b)
  • multiplicar(a, b)
  • dividir(a, b)

Importa ese módulo desde un archivo main.py y prueba todas las funciones.

Ejercicio 2

Crea un paquete llamado geometria con:

  • __init__.py
  • circulo.py (función area_radio(radio))
  • rectangulo.py (función area_rectangulo(base, altura))

Importa ambos módulos en un archivo principal y calcula áreas.

Ejercicio 3

Instala la librería requests y haz una pequeña consulta a una API pública, por ejemplo:

Evaluación del tema

Criterios de evaluación:

  • Comprende la diferencia entre módulos, paquetes y librerías externas.
  • Importa correctamente módulos propios y de terceros.
  • Usa adecuadamente import, from, as.
  • Instala y utiliza bibliotecas mediante pip.

Tema 19: Instalación con pip y uso de entornos virtuales (venv)

Objetivo del tema

Aprender a instalar y gestionar paquetes en Python usando pip, y a crear entornos virtuales con venv para mantener las dependencias de cada proyecto aisladas y organizadas.

1. ¿Qué es pip?

pip es el gestor de paquetes oficial de Python. Permite instalar, actualizar y eliminar librerías externas (no incluidas por defecto en Python).

Un paquete puede ser:

  • Una librería que añade nuevas funcionalidades.
  • Un framework (como Flask o Django).
  • Un conjunto de herramientas específicas.

2. Verificar si pip está instalado

Para comprobar si pip está disponible en tu sistema:

pip --version

Salida esperada:

pip 24.0 from /usr/lib/python3.11/site-packages/pip (python 3.11)

Si no aparece, puedes instalarlo o actualizarlo con:

python -m ensurepip --upgrade

3. Instalar paquetes con pip

Instalar un paquete

pip install requests

Instala la librería requests para hacer peticiones HTTP.

Instalar una versión específica

pip install requests==2.31.0

Esto garantiza que el proyecto use siempre la misma versión, útil para evitar incompatibilidades.

Actualizar un paquete

pip install --upgrade requests

Desinstalar un paquete

pip uninstall requests

Ver paquetes instalados

pip list

// Salida:

Package      Version
------------ -------
pip          24.0
requests     2.31.0
setuptools   68.0.0

Ver información de un paquete

pip show requests

Muestra detalles como versión, ubicación e información del desarrollador.

4. Guardar y restaurar dependencias del proyecto

Cuando trabajas en un proyecto, puedes guardar las librerías instaladas en un archivo llamado requirements.txt.

Crear el archivo:

pip freeze > requirements.txt

Instalar todas las dependencias desde ese archivo:

pip install -r requirements.txt

Ideal para compartir proyectos o trabajar en equipo.

5. ¿Qué es un entorno virtual?

Un entorno virtual es un entorno aislado dentro de tu sistema donde se instalan las dependencias solo para un proyecto.

Así, puedes tener:

  • Proyecto A con Django 3.2
  • Proyecto B con Django 5.0 sin conflictos entre sí.

6. Crear un entorno virtual

Python incluye el módulo venv para crear entornos virtuales.

En la carpeta de tu proyecto, ejecuta:

python -m venv venv

Esto creará una carpeta llamada venv/ que contiene su propio intérprete y paquetes.

7. Activar el entorno virtual

En Windows (cmd o PowerShell):

venv\Scripts\activate

En macOS / Linux:

source venv/bin/activate

Salida esperada:

(venv) C:\proyecto>

El prefijo (venv) indica que el entorno está activo.

8. Desactivar el entorno virtual

Para volver al entorno global:

deactivate

// Salida esperada:

C:\proyecto>

9. Instalar paquetes dentro del entorno virtual

Una vez activo el entorno:

pip install requests

La librería se instalará solo dentro del entorno, no en todo el sistema.

10. Ejemplo práctico paso a paso

Supongamos que estás desarrollando un proyecto web con Flask:

mkdir mi_web
cd mi_web
python -m venv venv
source venv/bin/activate  # o venv\Scripts\activate en Windows
pip install flask
pip freeze > requirements.txt

Contenido de requirements.txt:

Más tarde, si compartes tu proyecto, otra persona podrá recrear tu entorno con:

python -m venv venv
source venv/bin/activate  # o venv\Scripts\activate en Windows
pip install -r requirements.txt

11. Buenas prácticas con entornos virtuales

  • Crea siempre un entorno virtual por proyecto.
  • No subas la carpeta venv/ a Git (añádela al .gitignore).
  • Usa requirements.txt para compartir dependencias.
  • Usa nombres descriptivos: venv, .env, o env_proyecto.

12. Actividades prácticas

Ejercicio 1

  1. Crea una carpeta llamada mi_proyecto.
  2. Dentro de ella, crea un entorno virtual venv.
  3. Activa el entorno y verifica con pip list.
  4. Instala la librería requests.
  5. Usa pip freeze para generar requirements.txt.

Ejercicio 2

  1. Desactiva el entorno (deactivate).
  2. Elimina el entorno virtual.
  3. Crea un nuevo entorno env_prueba.
  4. Instala la librería flask.
  5. Verifica que no está disponible fuera del entorno.

Ejercicio 3 (extra)

Crea un pequeño script ver_api.py que use la librería requests instalada en el entorno virtual para consultar una API pública:

Evaluación del tema

Criterios de evaluación:

  • Comprende el uso y gestión de paquetes con pip.
  • Crea y activa correctamente entornos virtuales con venv.
  • Gestiona dependencias mediante requirements.txt.
  • Aplica buenas prácticas de aislamiento de proyectos.

Tema 20: Estructuración de proyectos con paquetes

Objetivo del tema

Aprender a organizar proyectos en Python utilizando paquetes, comprendiendo la importancia de una buena estructura de carpetas y archivos, y cómo importar y reutilizar módulos de manera ordenada en proyectos reales.

1. ¿Qué es un paquete en Python?

Un paquete es una carpeta que contiene módulos (archivos .py) y un archivo especial llamado __init__.py. Permite organizar el código de forma jerárquica y modular.

Ejemplo básico:

mi_paquete/
    │
    ├── __init__.py
    ├── modulo1.py
    └── modulo2.py
  • __init__.py: indica a Python que esta carpeta es un paquete.
  • modulo1.py y modulo2.py: contienen funciones o clases que se pueden importar.

2. ¿Por qué usar paquetes?

Organizar un proyecto en paquetes tiene varias ventajas:

  • Facilita la reutilización del código.
  • Mejora la legibilidad y mantenimiento del proyecto.
  • Permite que varias personas trabajen en distintas partes sin interferencias.
  • Facilita la creación de proyectos escalables y profesionales.

3. Estructura básica de un proyecto Python

Supongamos que creamos un proyecto llamado calculadora:

calculadora/
    │
    ├── main.py
    ├── operaciones/
    │   ├── __init__.py
    │   ├── suma.py
    │   ├── resta.py
    │   └── multiplicacion.py
    └── utils/
        ├── __init__.py
        └── validaciones.py

operaciones/suma.py

operaciones/resta.py

utils/validaciones.py

main.py

4. El archivo __init__.py

El archivo __init__.py le dice a Python que esa carpeta se comporta como un paquete. Puede estar vacío o ejecutar código al importar el paquete.

Ejemplo de __init__.py

Entonces podrías importar así:

Esto simplifica las importaciones y mejora la legibilidad del proyecto.

5. Importaciones relativas y absolutas

Importaciones absolutas

Usan la ruta completa desde la raíz del proyecto.

Claras y recomendadas en proyectos grandes.

Importaciones relativas

Usan puntos (. o ..) para referirse a módulos del mismo paquete o de paquetes superiores.

Son más cortas, pero pueden generar confusión si se abusa de ellas.

6. Buenas prácticas en la organización de proyectos

Recomendación Descripción
Separar por funcionalidad Agrupa módulos por tema (ej. usuarios, productos, utils).
Añadir __init__.py Aunque no siempre obligatorio, facilita la compatibilidad.
Archivo main.py Define el punto de entrada del programa.
Carpeta tests Guarda tus pruebas unitarias.
Archivo requirements.txt Lista las dependencias del proyecto.
Usa nombres claros Usa nombres descriptivos para archivos y paquetes.

7. Estructura de proyecto profesional

Ejemplo de un proyecto más grande:

mi_proyecto/
    │
    ├── src/
    │   ├── __init__.py
    │   ├── main.py
    │   ├── config.py
    │   ├── controllers/
    │   │   ├── __init__.py
    │   │   ├── usuarios.py
    │   │   └── productos.py
    │   ├── models/
    │   │   ├── __init__.py
    │   │   ├── usuario.py
    │   │   └── producto.py
    │   └── utils/
    │       ├── __init__.py
    │       └── validaciones.py
    │
    ├── tests/
    │   ├── __init__.py
    │   └── test_usuarios.py
    │
    ├── requirements.txt
    └── README.md

Esta estructura es típica en aplicaciones medianas y grandes.

8. Actividades prácticas

Ejercicio 1 — Crear un paquete simple

  1. Crea una carpeta geometria con:
  • __init__.py
  • circulo.py
  • rectangulo.py
  1. En circulo.py define area_circulo(radio).
  2. En rectangulo.py define area_rectangulo(base, altura).
  3. En un archivo main.py, importa ambos módulos y calcula áreas.

Ejercicio 2 — Reorganizar código

  1. Crea una carpeta calculadora con módulos para cada operación.
  2. Añade un __init__.py que importe las funciones principales.
  3. Crea un script main.py que use estas funciones para realizar operaciones básicas.

Ejercicio 3 — Importaciones relativas

  1. Crea un paquete animales con subpaquetes mamiferos y aves.
  2. Dentro, define clases como Perro y Aguila.
  3. Usa importaciones relativas para que animales/__init__.py importe todo el contenido.
  4. Muestra el uso de ambas clases desde main.py.

Evaluación del tema

Criterios de evaluación:

  • Comprende la diferencia entre módulos y paquetes.
  • Crea correctamente la estructura de un proyecto con carpetas y __init__.py.
  • Usa importaciones absolutas y relativas según convenga.
  • Aplica buenas prácticas en la organización del código.