Saltar al contenido principal

Módulos

En Python, un módulo es un archivo que contiene definiciones y declaraciones de Python. Estos archivos pueden contener funciones y variables que pueden ser utilizadas en otros programas de Python. Básicamente, los módulos permiten organizar el código en archivos separados para mejorar la modularidad y reutilización.

Definir un módulo​

Para crear un módulo de nombre mi_modulo solo debemos definir un archivo de nombre mi_modulo.py. Dentro de este definimos funciones y declaramos variables:

mi_modulo.py
pi = 3.14
def saludar(nombre):
    print("Hola", nombre)

Importar​

Se puede importar todo un módulo utilizando la palabra clave import seguida del nombre del módulo. Por ejemplo:

import mi_modulo

Esto importará todo el contenido del módulo mi_modulo. A partir de ahí se podrá acceder a las funciones y variables definidas en ese módulo.

Utilizar funciones o variables de un módulo​

Para acceder, por ejemplo, a una función de un módulo debemos seguir la siguiente sintaxis: nombre_del_modulo.funcion().

Por ejemplo:

import mi_modulo

mi_modulo.saludar("Manuel")

Para acceder, por ejemplo, a una variable de un módulo debemos seguir la siguiente sintaxis: nombre_del_modulo.variable.

Por ejemplo:

import mi_modulo

print(mi_modulo.pi)

Importar un módulo de un subdirectorio​

Para importar un módulo que está en un subdirectorio en Python, podemos utilizar la notación de punto . para indicar la ubicación relativa del módulo en relación con el archivo desde el que se está importando. Supongamos la siguiente estructura:

mi_proyecto/
│
├── subdirectorio/
│   └── mi_modulo.py
│
└── main.py

Para importar mi_modulo.py desde main.py debemos:

from subdirectorio import mi_modulo

Importar funciones o variables concretas​

En Python no es necesario importar todo el contenido de un módulo; podemos importar solo los elementos que deseamos utilizar.

Para importar una función específica debemos utilizar la siguiente sintaxis:

from mi_modulo import funcion_concreta

Esto importará solo la función funcion_concreta del módulo mi_modulo. Para usarla ya no se debe anteponer el nombre del módulo antes de llamar a la función. Por ejemplo:

from mi_modulo import saludar

saludar("Manuel")

De la misma manera podemos hacerlo con una variable:

from mi_modulo import pi

print(pi)

Para importar varios elementos solo debemos indicarlos separándolos con comas:

from mi_modulo import saludar, pi

saludar("Manuel")
print(pi)

Alias​

Los alias al importar en Python se utilizan para proporcionar un nombre alternativo a un módulo, función o variable importada. Esto puede ser útil para:

  • Evitar conflictos de nombres. Por ejemplo, si los nombres del módulo importado entran en conflicto con nombres de tu código actual.
  • Facilitar la escritura de código. Si los nombres de módulos son largos, podemos utilizar alias más cortos para facilitar la escritura de código.

Ejemplos:

import numpy as np
import pandas as pd

np.array([1, 2, 3])

__main__​

__main__ es un nombre de una variable especial en Python que se utiliza para denotar el punto de entrada principal de un programa Python cuando se ejecuta como un script independiente.

Cuando se ejecuta un script directamente desde la línea de comandos, el intérprete asigna automáticamente el nombre __main__ al módulo en ejecución. Este nombre se almacena en la variable __name__.

# Archivo script.py

def funcion_principal():
    pass

if __name__ == "__main__":
    print("Este código se ejecuta cuando el script se ejecuta directamente.")
    funcion_principal()

PyDoc​

Pydoc es una herramienta integrada en Python que sirve para generar documentación de módulos de Python utilizando las cadenas de documentación (docstrings) definidas en el código.

PyDoc en la línea de comandos​

Puedes acceder a la documentación de cualquier módulo utilizando la línea de comandos:

pydoc3 nombre_del_módulo.py

Generar un archivo HTML​

Si quieres crear un archivo HTML, ejecuta:

pydoc3 -w nombre_del_módulo.py

Esto generará un archivo como nombre_del_módulo.html en el directorio actual.

Módulos estándar​

Los módulos estándar de Python los que vienen incluidos con la instalación de Python. Se pueden importar directamente sin necesidad de instalar nada extra.

Algunos ejemplos:

  • Sistema operativo
    • os → interacción con el sistema operativo (rutas, procesos, variables de entorno).
    • sys → información y funciones relacionadas con el intérprete de Python.
    • platform → información sobre la plataforma (Windows, Linux, etc.).
    • shutil → operaciones de alto nivel con archivos y directorios (copiar, mover, etc.).
    • subprocess → ejecución y control de procesos externos.
  • Entrada y salida de datos
    • io → manejo de streams.
    • csv → lectura/escritura de archivos CSV.
    • json → manejo de datos en formato JSON.
    • sqlite3 → base de datos SQLite integrada.
  • Matemáticas y estadísticas
    • math → funciones matemáticas básicas.
    • random → generación de números aleatorios.
    • statistics → media, mediana, varianza, etc.
    • decimal y fractions → precisión exacta con decimales y fracciones.
  • Fechas y tiempo
    • datetime → fechas y horas.
    • time → funciones relacionadas con el tiempo del sistema.
    • calendar → calendarios y operaciones con fechas.
  • Redes e internet
    • socket → programación de red a bajo nivel.
    • http → cliente y servidor HTTP.
    • urllib → acceso a URLs.
  • Utilidades
    • re → expresiones regulares.
    • argparse → procesamiento de argumentos en línea de comandos.
    • logging → sistema de logs.
    • functools → utilidades de programación funcional.
    • itertools → combinaciones, permutaciones, generadores infinitos, etc.

Consultar módulos disponibles​

Para ver qué módulos tenemos disponibles, podemos ejecutar:

help('modules')

Salida:

Please wait a moment while I gather a list of all available modules...

__future__          _string             errno               re
__hello__           _strptime           faulthandler        reprlib
__phello__          _struct             filecmp             rlcompleter
_abc                _suggestions        fileinput           runpy
_aix_support        _symtable           fnmatch             sched
_android_support    _sysconfig          fractions           secrets
_apple_support      _testbuffer         ftplib              select
_ast                _testcapi           functools           selectors
_asyncio            _testclinic         gc                  shelve
_bisect             _testclinic_limited genericpath         shlex
_blake2             _testconsole        getopt              shutil
_bz2                _testimportmultiple getpass             signal
_codecs             _testinternalcapi   gettext             site
_codecs_cn          _testlimitedcapi    glob                smtplib
_codecs_hk          _testmultiphase     graphlib            socket
_codecs_iso2022     _testsinglephase    gzip                socketserver
_codecs_jp          _thread             hashlib             sqlite3
_codecs_kr          _threading_local    heapq               sre_compile
_codecs_tw          _tkinter            hmac                sre_constants
_collections        _tokenize           html                sre_parse
_collections_abc    _tracemalloc        http                ssl
_colorize           _typing             idlelib             stat
_compat_pickle      _uuid               imaplib             statistics
_compression        _warnings           importlib           string
_contextvars        _weakref            inspect             stringprep
_csv                _weakrefset         io                  struct
_ctypes             _winapi             ipaddress           subprocess
_ctypes_test        _wmi                itertools           symtable
_datetime           _zoneinfo           json                sys
_decimal            abc                 keyword             sysconfig
_elementtree        antigravity         linecache           tabnanny
_functools          argparse            locale              tarfile
_hashlib            array               logging             tempfile
_heapq              ast                 lzma                test
_imp                asyncio             mailbox             textwrap
_interpchannels     atexit              marshal             this
_interpqueues       base64              math                threading
_interpreters       bdb                 mimetypes           time
_io                 binascii            mmap                timeit
_ios_support        bisect              modulefinder        tkinter
_json               builtins            msvcrt              token
_locale             bz2                 multiprocessing     tokenize
_lsprof             cProfile            netrc               tomllib
_lzma               calendar            nt                  trace
_markupbase         cmath               ntpath              traceback
_md5                cmd                 nturl2path          tracemalloc
_multibytecodec     code                numbers             tty
_multiprocessing    codecs              opcode              turtle
_opcode             codeop              operator            turtledemo
_opcode_metadata    collections         optparse            types
_operator           colorsys            os                  typing
_osx_support        compileall          pathlib             unicodedata
_overlapped         concurrent          pdb                 unittest
_pickle             configparser        pickle              urllib
_py_abc             contextlib          pickletools         uuid
_pydatetime         contextvars         pip                 venv
_pydecimal          copy                pkgutil             warnings
_pyio               copyreg             platform            wave
_pylong             count               plistlib            weakref
_pyrepl             csv                 poplib              webbrowser
_queue              ctypes              posixpath           winreg
_random             curses              pprint              winsound
_sha1               dataclasses         profile             wsgiref
_sha2               datetime            pstats              xml
_sha3               dbm                 pty                 xmlrpc
_signal             decimal             py_compile          xxsubtype
_sitebuiltins       difflib             pyclbr              zipapp
_socket             dis                 pydoc               zipfile
_sqlite3            doctest             pydoc_data          zipimport
_sre                email               pyexpat             zlib
_ssl                encodings           queue               zoneinfo
_stat               ensurepip           quopri
_statistics         enum                random

Enter any module name to get more help.  Or, type "modules spam" to search
for modules whose name or summary contain the string "spam".

Módulo sys​

El módulo sys proporciona funciones y variables para interactuar con el intérprete de Python. Por ejemplo, para recoger los datos pasados por parámetro al script se necesita utilizar el módulo sys.

Este módulo contiene una variable argv que es una lista en la que el primer elemento es el nombre del script, y los siguientes son los argumentos que se pasaron al script. Ejemplo:

import sys

# Ejemplo de ejecución: "python3 script.py argumento1 argumento2"
# Tomamos el primer argumento
argumento1 = sys.argv[1]
# Tomamos el segundo argumento
argumento2 = sys.argv[2]

# Imprimimos los argumentos
print("Argumento 1:", argumento1)
print("Argumento 2:", argumento2)

Módulo math​

El módulo math de Python proporciona la mayoría de las funciones matemáticas habituales. Antes de poder utilizar el módulo, debemos importarlo.

import math

relacion = int_senal / int_ruido
decibelios = 10 * math.log10(relacion) # Logaritmo en base 10
radians = 0.7 
altura = math.sin(radians) # Función seno

El primer ejemplo calcula el logaritmo en base 10 de la relación señal-ruido. El módulo math también proporciona una función llamada log que calcula logaritmos en base e.

El segundo ejemplo calcula el seno de la variable radians. El nombre de la variable indica que sin y otras funciones trigonométricas (cos, tan, etc.) toman argumentos en radianes. Para convertir de grados a radianes, hay que dividir por 360 y multiplicar por 2 por pi.

grados = 45
radians = grados / 360.0 * 2 * math.pi
print(math.sin(radians))
0.7071067811865476

La expresión math.pi toma la variable pi del módulo math. El valor de esta variable es una aproximación de pi, con una precisión de unos 15 dígitos.

Módulo random​

A partir de las mismas entradas, la mayoría de programas generarán las mismas salidas cada vez, es lo que llamamos comportamiento determinista. El determinismo generalmente es algo bueno, ya que esperamos que la misma operación proporcione siempre el mismo resultado. Para ciertas aplicaciones, sin embargo, queremos que el resultado sea impredecible. Los juegos son un ejemplo obvio, pero hay más.

Conseguir que un programa sea realmente no-determinista no resulta sencillo. Pero hay dos modos de hacer que lo parezca. Uno de ellos es usar algoritmos que generen números pseudoaleatorios. Los números pseudoaleatorios no son verdaderamente aleatorios, ya que son generados por una operación determinista, pero si solo nos fijamos en los números resulta casi imposible distinguirlos de los aleatorios de verdad.

El módulo random proporciona funciones que generan números pseudoaleatorios. A partir de ahora nos referiremos a ellos como aleatorios aunque no lo sean.

La función random() devuelve un número en coma flotante aleatorio entre 0.0 y 1.0 (incluye 0.0 pero no 1.0). Cada vez que se llama a random(), se obtiene el número siguiente de una larga serie.

A modo de ejemplo, creamos un bucle que hace múltiples llamadas a random():

import random

for i in range(10):
    x = random.random()
    print(x)

Salida:

0.11132867921152356
0.5950949227890241
0.04820265884996877
0.841003109276478
0.997914947094958
0.04842330803368111
0.7416295948208405
0.510535245390327
0.27447040171978143
0.028511805472785867

La función random() solamente es una de las muchas que trabajan con números aleatorios. La función randint() toma parámetros inferior y superior, y devuelve un número entero aleatorio entre inferior y superior (incluyendo ambos extremos).

import random

random.randint(5, 10) # 5
random.randint(5, 10) # 9

Módulo time​

El módulo time proporciona funciones relacionadas con el tiempo del sistema, útiles por ejemplo para pausar la ejecución de un programa o medir cuánto tarda en ejecutarse una parte del código.

La función time.sleep(segundos) detiene la ejecución del programa durante el número de segundos indicado:

import time

print("Empezamos...")
time.sleep(2)
print("Han pasado 2 segundos")

La función time.time() devuelve el número de segundos transcurridos desde una fecha de referencia fija (el 1 de enero de 1970), en forma de número con decimales. Comparando el valor que devuelve antes y después de una operación, podemos medir cuánto tarda en ejecutarse:

import time

inicio = time.time()
time.sleep(1)
fin = time.time()

print(f"La operación ha tardado {fin - inicio:.2f} segundos")

Salida:

La operación ha tardado 1.00 segundos