Módulos

Existen varios métodos para crear módulos pero la forma más sencilla es crear un archivo con extensión .py que contenga un conjunto de funciones y/o de clases. Un módulo puede ser importado por otro programa para hacer uso de su funcionalidad, de igual forma que se hace con aquellos módulos que pertenecen a la biblioteca estándar de Python.

La carga de un módulo compilado es más rápida. Los archivos compilados tienen la extensión .pyc y tienen la ventaja de que son independientes de la plataforma.

Ejemplo de uso del modulo sys que ofrece funciones específicas para interactuar con el sistema:

import sys 

print('Las rutas de PYTHONPATH:', sys.path, '\n')

Namespaces y Alias

Cuando se hace referencia a algún elemento que pertenece a un módulo importado se indica previamente su espacio de nombres (namespaces) seguido de un punto “.” como en el ejemplo anterior: sys.path.

En el momento de importar un módulo puede asignarse también un alias con as:

# Carga módulo megamodulo.py y asigna alias:
import megamodulo as mmod

# Se hace referencia a una función del módulo:
mmod.mfuncion 

De un módulo es posible importar sólo aquella función que vamos a utilizar y así cada vez que la usemos evitamos hacer referencia al nombre del módulo. No se suele recomendar este uso porque puede crear conflictos con variables o con funciones que tengan nombres iguales en otros módulos importados en una misma aplicación.

# Se carla la función pi del módulo math
from math import pi

# Este uso no se recomienda:
print('El valor de pi', pi)  # es mejor: math.pi

Mediante el atributo __name__ tenemos acceso al nombre de un módulo. Si accedemos a este atributo cuando se ejecuta un programa podemos conocer si el módulo es ejecutado de forma independiente (en ese caso __name__ = '__main__') o es importado:

if __name__ == '__main__':
    print("Este programa es independiente")
else:
    print("El modulo ha sido importado")

En Geany cuando se comienza a escribir un programa a partir de una plantilla Python (Menú Archivo, Nuevo desde plantilla), en el código inicial se incluye la función main() para situar dentro de ella nuestro código.

Creación y uso de un módulo

En el siguiente ejemplo se crea el módulo moduloseries.py y un programa programa.py lo importa y hace uso de la función sumadesde1aN (que para un número n, suma todo los números que van desde 1 a n).

moduloseries.py:

def sumadesde1aN(pnumero):
    ''' Suma todos los números consecutivos desde 1 hasta
    el número expresado. Si el valor es menor que 1 devuelve 0 '''
    ntotal= 0
    if pnumero >0:
        for nnum in range(1,pnumero+1):
            ntotal = ntotal + nnum
  
    return ntotal
  
__version__ = '1.0'

programa.py:

import moduloseries

valor = 10
print('Suma desde 1 a '+str(valor)+':',
      moduloseries.sumadesde1aN(valor))
print('Versión:', moduloseries.__version__)
print('Nombre:', moduloseries.__name__)
print('Doc:', moduloseries.sumadesde1aN.__doc__)

También sería posible importar la función y la versión del módulo, así:

from moduloseries import sumadesde1aN, __version__

# Importa las funciones pero no la __version__
from moduloseries import *  

La función dir()

La función dir() lista los identificadores que definen un objeto. Para un módulo, los identificadores incluyen las funciones, las clases y variables definidas en ese módulo.

import sys
dir(sys)

Resultado:

['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_getframe', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'hash_info', 'hexversion', 'int_info', 'intern', 'last_traceback', 'last_type', 'last_value', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoptions']

Paquetes (Packages)

Las variables suelen ir dentro de las funciones, las llamadas variables globales dentro de los módulos. Los módulos suelen organizarse en un tipo de carpetas especiales que se llaman paquetes. Dentro de estas carpetas deben existir necesariamente un archivo llamado __init__.py, aunque esté vacío. No es obligatorio que todos los módulos pertenezcan a un paquete.

La estructura básica de las carpetas de un paquete se parece a:

 - <carpeta definida en sys.path>/

- mismodulos/
- __init__.py
- modulo1/
- __init__.py
- modulo2/
- __init__.py
- codpyton21.py
- modulo3/
- __init__.py
- modulo31/
- __init__.py
- codpython311.py

Un paquete puede contener a otros subpaquetes y éstos, también, módulos. Cuando se importa un módulo es posible indicar su espacio de nombres:

# Importa módulo no empaquetado:
import modulo

# Importa módulo del paquete indicado:
import paquete.modulo

# importa módulo del subpaquete/paquete:
import paquete.subpaquete.modulo  

Ir al índice del tutorial de Python