1. Introducción

Python organiza el código en módulos y paquetes para hacerlo más estructurado, modular y reutilizable. Este tutorial explora cómo trabajar con módulos, paquetes y namespaces en Python, comenzando desde conceptos básicos y avanzando hacia ejemplos complejos. La estructura está pensada para que puedas ir profundizando a medida que practicas.

2. Concepto de Módulo

Un módulo en Python es un archivo que contiene definiciones y declaraciones de Python, como funciones, clases y variables. La idea principal es dividir el código en archivos separados para una mejor organización y reutilización.

Por ejemplo, si tienes un archivo llamado matematicas.py, este puede considerarse un módulo y podría contener definiciones como:

# matematicas.py
def sumar(a, b):
    return a + b

def restar(a, b):
    return a - b

3. Creación y Uso de Módulos

3.1. Paso 1: Creación de un Módulo

Supongamos que creamos un archivo llamado saludos.py que contiene las siguientes definiciones:

# saludos.py
def saludo_ingles():
    return "Hello!"

def saludo_euskera():
    return "Kaixo!"

def saludo_frances():
    return "Bonjour!"

3.2. Paso 2: Uso de Módulos

Podemos importar el módulo saludos en otro archivo o en el intérprete de Python:

# main.py
import saludos

print(saludos.saludo_ingles())  # Output: Hello!
print(saludos.saludo_euskera())  # Output: Kaixo!
print(saludos.saludo_frances())  # Output: Bonjour!

3.3. Paso 3: Alias para Módulos

Puedes usar alias para facilitar la llamada a los módulos, especialmente si el nombre es muy largo:

import saludos as s

print(s.saludo_ingles())  # Output: Hello!

4. Importación de Módulos

4.1. Importación Completa

Al importar un módulo completo, se pueden acceder a todas sus definiciones:

import matematicas
resultado = matematicas.sumar(3, 5)
print(resultado)  # Output: 8

4.2. Importación Específica

Puedes importar definiciones específicas de un módulo usando from ... import ...:

from matematicas import sumar, restar

print(sumar(10, 5))  # Output: 15
print(restar(10, 5))  # Output: 5

4.3. Importación con * (Importar Todo)

Al hacer from ... import *, importas todas las definiciones del módulo. Sin embargo, esta práctica no se recomienda porque puede generar conflictos de nombres:

from saludos import *

print(saludo_ingles())  # Output: Hello!

5. Namespaces en Python

Un namespace es una colección de nombres (identificadores) en un entorno particular. Python organiza estos espacios para evitar colisiones entre nombres. Existen tres tipos de namespaces principales:

  1. Local: Se refiere a nombres definidos dentro de una función.
  2. Global: Se refiere a nombres definidos en el módulo en el que te encuentras.

  3. Built-in: Se refiere a nombres integrados en Python como len() o int.

    # Ejemplo de namespaces
def funcion():
local_variable = "Soy una variable local"  # Namespace local
print(local_variable)

global_variable = "Soy una variable global"  # Namespace global
print(global_variable)

5.1. Conflictos de Nombres

Si se definen variables con el mismo nombre en distintos namespaces, Python utiliza la regla de resolución de nombre LEGB (Local, Enclosing, Global, Built-in).

def funcion():
    var = "local"
    print("Valor de la variable dentro de la función:", var)

var = "global"
funcion()
print("Valor de la variable fuera de la función:", var)

Salida:

Valor de la variable dentro de la función: local
Valor de la variable fuera de la función: global

6. Paquetes en Python

Un paquete es una colección de módulos organizados en un directorio que contiene un archivo especial llamado init.py. Este archivo indica a Python que el directorio debe tratarse como un paquete y se utiliza para inicializar el paquete.

6.1. Creación de un Paquete

Supongamos que tienes la siguiente estructura de archivos:

mi_proyecto/
    ├── geometria/
    │   ├── __init__.py
    │   ├── circulo.py
    │   └── rectangulo.py
    └── main.py
  • geometria es un paquete, y circulo.py y rectangulo.py son módulos dentro de este paquete.
  • __init__.py es un archivo especial que puede estar vacío o contener código de inicialización para el paquete.

6.2. Uso de Paquetes y Submódulos

Dentro de main.py, puedes importar módulos del paquete geometria:

# main.py
from geometria import circulo, rectangulo

print(circulo.area(5))  # Supongamos que `area` es una función definida en `circulo.py`
print(rectangulo.perimetro(4, 7))  # Supongamos que `perimetro` es una función definida en `rectangulo.py`

6.3. Importaciones Relativas y Absolutas

6.3.1. Importación Absoluta

Se utilizan rutas completas del paquete para importar módulos:

from geometria.circulo import area

6.3.2. Importación Relativa

Se usan puntos (.) para indicar niveles de la jerarquía. Por ejemplo, desde rectangulo.py, puedes importar algo de circulo.py usando:

from .circulo import area  # Importa `area` desde `circulo.py`

Las importaciones relativas permiten mover paquetes sin cambiar las rutas de importación.

7. Gestión de Namespaces: init.py

El archivo __init__.py se utiliza para gestionar qué módulos y definiciones deben estar disponibles al importar el paquete:

# geometria/__init__.py
from .circulo import area
from .rectangulo import perimetro

Con este __init__.py, puedes importar el paquete geometria de la siguiente manera:

import geometria

print(geometria.area(5))
print(geometria.perimetro(4, 7))

8. Ejercicios de Práctica

  • Crear un módulo para operaciones con matrices: Define un módulo que contenga funciones para sumar, restar y multiplicar matrices.
  • Construir un paquete animales: Crea un paquete con submódulos como mamiferos.py, aves.py y peces.py, cada uno con funciones específicas que describan comportamientos.
  • Implementar una calculadora científica: Crea un paquete llamado calculadora con submódulos para operaciones básicas, trigonométricas y estadísticas.

9. Conclusión

Trabajar con módulos y paquetes te permite organizar y reutilizar el código de manera eficiente. El uso correcto de namespaces evita colisiones de nombres, y las importaciones relativas y absolutas te permiten organizar mejor tus proyectos.

10. Referencias