Crear tus propios módulos en Python es fundamental para organizar tu código y hacerlo reutilizable. Es un proceso sencillo y te permite estructurar tus proyectos de manera lógica.

Pasos para Crear un Módulo Propio:

1. Escribe tu código Python: Simplemente crea un archivo nuevo con la extensión .py y escribe en él las definiciones de funciones, clases, variables o cualquier otro código Python que quieras incluir en tu módulo.

   Ejemplo: Vamos a crear un módulo llamado mis_herramientas.py con algunas funciones útiles.

   Python

    

   # mis_herramientas.py
   
   def saludar(nombre):
       """Saluda a la persona con el nombre proporcionado."""
       return f"¡Hola, {nombre}!"
   
   def calcular_area_rectangulo(base, altura):
       """Calcula el área de un rectángulo."""
       return base * altura
   
   PI = 3.14159
   
   class Contador:
       """Una clase simple para contar."""
       def __init__(self, inicio=0):
           self.conteo = inicio
   
       def incrementar(self):
           self.conteo += 1
   
       def obtener_conteo(self):
           return self.conteo
   

2. Guarda el archivo: Guarda el archivo con un nombre descriptivo y la extensión .py. En nuestro ejemplo, lo guardamos como mis_herramientas.py.

3. Utiliza tu módulo en otro script: Ahora, desde otro archivo Python en la misma ubicación (o en una ubicación donde Python pueda encontrarlo, como veremos más adelante), puedes importar y utilizar tu módulo.

   Ejemplo: Vamos a crear un script llamado mi_programa.py que utiliza el módulo mis_herramientas.py.

   Python

    

   # mi_programa.py
   
   import mis_herramientas
   
   mensaje = mis_herramientas.saludar("Alicia")
   area = mis_herramientas.calcular_area_rectangulo(5, 10)
   valor_pi = mis_herramientas.PI
   
   mi_contador = mis_herramientas.Contador(5)
   mi_contador.incrementar()
   conteo_actual = mi_contador.obtener_conteo()
   
   print(mensaje)
   print(f"El área del rectángulo es: {area}")
   print(f"El valor de PI es: {valor_pi}")
   print(f"El conteo actual es: {conteo_actual}")
   
   # También puedes usar "from ... import ..."
   from mis_herramientas import saludar as saludo_especial, Contador as MiContador
   
   mensaje_especial = saludo_especial("Bob")
   otro_contador = MiContador(0)
   otro_contador.incrementar()
   conteo_otro = otro_contador.obtener_conteo()
   
   print(mensaje_especial)
   print(f"El otro conteo es: {conteo_otro}")
   

   Salida (si mis_herramientas.py y mi_programa.py están en la misma carpeta):

   ¡Hola, Alicia!
   El área del rectángulo es: 50
   El valor de PI es: 3.14159
   El conteo actual es: 6
   ¡Hola, Bob!
   El otro conteo es: 1
   

Dónde Python Busca los Módulos:

Cuando importas un módulo, Python busca en una lista de directorios específicos en un orden determinado. Puedes ver esta lista accediendo a sys.path.

import sys
for ruta in sys.path:
    print(ruta)

La lista sys.path incluye:

1. El directorio que contiene el script de entrada (o el directorio actual si estás en el intérprete interactivo).
2. Los directorios listados en la variable de entorno PYTHONPATH (si está configurada).
3. Directorios de instalación por defecto de Python, que contienen las bibliotecas estándar.

Si tu módulo propio está en la misma carpeta que el script que lo importa, Python lo encontrará automáticamente. Si quieres organizar tus módulos en otras carpetas, necesitarás crear paquetes (como vimos anteriormente) o asegurarte de que la ruta a tus módulos esté incluida en sys.path o en la variable de entorno PYTHONPATH.

Creación de Paquetes Propios:

Para organizar tus módulos en paquetes (jerarquías de directorios):

1. Crea un directorio para tu paquete.

2. Dentro de ese directorio, crea un archivo llamado __init__.py. Este archivo puede estar vacío o contener código de inicialización para el paquete.

3. Coloca tus módulos Python (archivos .py) dentro del directorio del paquete o en subdirectorios del paquete (creando subpaquetes).

   Ejemplo de estructura de paquete:

   mi_proyecto/
       mi_paquete/
           __init__.py
           modulo_uno.py
           modulo_dos.py
           sub_paquete/
               __init__.py
               modulo_tres.py
   

4. Importa desde tu paquete:

   Python

    

   # Desde otro script en 'mi_proyecto' o en un lugar donde 'mi_proyecto' esté en el path
   
   import mi_paquete.modulo_uno
   mi_paquete.modulo_uno.funcion_uno()
   
   from mi_paquete import modulo_dos
   modulo_dos.funcion_dos()
   
   from mi_paquete.sub_paquete import modulo_tres
   modulo_tres.funcion_tres()
   
   from mi_paquete.sub_paquete.modulo_tres import otra_funcion_tres
   otra_funcion_tres()
   

Crear tus propios módulos y paquetes es una práctica esencial para escribir código Python bien organizado, reutilizable y mantenible. Te permite dividir proyectos complejos en partes más pequeñas y manejables.