Módulos y Librerías en Python : Importar, acceder, crear

A la hora de programar a veces es necesario recurrir a módulos, librerías, paquetes, etc para facilitarnos el desarrollo de un programa sin tener que repetir código o inventar la rueda nuevamente. También para organizar nuestro programa si es demasiado extenso y cuenta con muchas líneas de código, su estructura puede ser separada en módulos.

 

¿Qué son los módulos y librerías?

 

Módulo en programación

En programación un módulo se define como la porción de un programa.

Según la wikipedia: En programación, un módulo es una porción de un programa de ordenador. De las varias tareas que debe realizar un programa para cumplir con su función u objetivos, un módulo realizará, comúnmente, una de dichas tareas (o varias, en algún caso).

Librería en programación (biblioteca)

En programación una librería se define como un conjunto de implementaciones funcionales.

Según la wikipedia: En informática, una biblioteca o, llamada por vicio del lenguaje librería (del inglés library) es un conjunto de implementaciones funcionales, codificadas en un lenguaje de programación, que ofrece una interfaz bien definida para la funcionalidad que se invoca.

Así podemos reconocer una librería como un conjunto de módulos cuya agrupación tiene una finalidad específica y que también puede ser invocada, tal como un módulo. Pero no es un módulo, sino un conjunto de ellos con una estructura determinada para lograr una finalidad.

Entonces se trata de organización y capacidad a la hora de desarrollar una aplicación. Esta puede hacer con miles de líneas en un solo archivo, o con 5 archivos de cientos de líneas; así surgen dos opciones. Hacerlo como un módulo aparte, o dentro del código del mismo programa; pero aquí surge un problema. Al incluir todo el código de lo que podrían ser diferentes módulos en el mismo archivo obtendremos como resultado un enredo de millones de líneas de código o quizás más en un solo file. Y donde obtengas una serie de errores te encontrarás más perdido en el espacio que esta nave.

Y también si no dispones de las librerías, es como si no tuvieses la capacidad de lograr lo que quieres sin un esfuerzo mayor. Por ejemplo suponiendo que tu quieras hacer una calculadora en python, y la misma ya está programada lógicamente. Pero tu quieres brindarle al usuario un entorno gráfico. Sin librería, estarías perdido.

Salvo que tu programes desde 0 todo el entorno gráfico de tu programa!. Pero para eso existen las librerías (conjuntos de módulos) y módulos “prefabricados del lenguaje o incorporados por tí” por decir así que facilitaran el trabajo.

 

Importando módulos

Bien si un módulo es como una caja de herramientas y nosotros vamos a hacer cálculos, necesitamos un módulo que posea estos accesorios y debemos incorporarlo a nuestro programa.

Vamos a crear un archivo .py como clásicamente lo hacemos en nuestro IDE. Y dentro de él vamos a importar el módulo Math usando la orden import. De esta manera:

Como ves en la barra lateral izquierda en este caso en Geany nos aparece que ha sido importado el módulo Math. Este es un módulo estándar de Python. Usemoslo un poco para ver cómo se utiliza un módulo. Una vez importado vamos a utilizar en este caso una función del módulo para calcular la raíz cuadrada de un número. Para eso colocaremos un input donde el usuario ingrese el número y nos devuelva la raíz.

Importando Módulo math

Quedando nuestro código así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# pythones.net

import math #Importamos el módulo math
x = int(input("Ingresa un numero \n"))
raiz = math.sqrt(x) #Utilizamos la función sqrt del módulo math
print (raiz)

Por supuesto que solo para sacar una raíz cuadrada no es necesario importar semejante módulo. Si con un print(x**.5) bastaba no??

Solo estoy ejemplificando con uno de los módulos más utilizados en python! Y aquí nace un problema, estamos importando todo un módulo para usar solamente una función del mismo. Y resulta inconveniente en grandes programas, para eso existe FROM.

From module import

La orden from (module) import nos permitirá importar determinadas funciones de un módulo y no el modulo completo. Aunque hay que tener cuidado con lo que importamos de cada módulo, y pronto sabrás porque. Primero veamos cómo haríamos para solo importar y utilizar esta función SQRT de Math. Dejando todo el equipaje pesado de lado:

from math import *

Importando Módulos

Este código lo que hará será importar todo lo que en el módulo math esté declarado como explícito. No exportará todo el código del módulo como se cree a menudo. Y resulta riesgoso exportar varios módulos de esta manera porque no sabemos si estos módulos tienen nombres de variables, clases, métodos exactamente iguales. Y que si así fuera podríamos obtener errores en la ejecución de una función de alguno de los módulos.

Cómo ves el código de nuestro programa también ha sido cambiado, específicamente en la línea 7. Porque de esta forma ya no precisamos indicar que sqrt es una función del módulo math. Porque directamente importamos todas las funciones explicitas así que solo basta dar el nombre de la función a utilizar.

Recuerda de esta manera se exporta lo que el programador del módulo declaró como explícito.

Si nosotros sabemos que usaremos sólo determinada función de ese módulo y no todas las demás podemos solo importar la que nos interesa, en este caso así:

from math import (sqrt)

Para saber todas las funciones de un módulo podemos hacerlo mediante el siguiente código, en este caso pongo math de ejemplo:

import math
print (dir(math))

Módulos

 

De módulos como este python cuenta con muchísimos, puedes investigar un poco al respecto y veras que en algunos casos solo con importar una función de determinado módulo, te ahorras varias líneas de código y dolores de cabeza!

 

¿Cómo creamos un módulo propio?

Pues esto es fácil, primeramente debemos pensar cómo vamos a dividir nuestro proyecto. Si se tratase de una calculadora por ejemplo podríamos separar en un módulo las funciones de las operaciones matemáticas, por el otro la librería gráfica y el ejecutable principal por ejemplo calc.py que integra ambos.

Vamos a tomar de ejemplo la calculadora en python que realizamos en una entrada de manejo de errores hace unos meses. Aquí está el código incluyendo Try/Except

Abrir Spoiler
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  calc.py
#  
#  Copyright https://pythones.net
#
############################################-1-##################################################
 
def sumar(): #Definimos la función sumar
    x = a + b
    print (("Resultado"), (x))
def restar():#Definimos la función restar
    x = a - b
    print (("Resultado"), (x))
def multiplicar():#Definimos la función multiplicar
    x = a * b
    print (("Resultado"), (x))
def dividir():#Definimos la función dividir
    x = a / b
    print (("Resultado"), (x))
 
##########################################-2-###################################################
while True: #Creamos un bucle
    try: #Intentamos obtener los datos de entrada
        a = int(input("Ingresa el primer numero: \n")) #Solicitamos el 1er numero al usuario
        b = int(input("Ingresa el segundo numero: \n"))#Solicitamos el 2do numero al usuario
        print (("Que calculo quieres realizar entre"), (a), ("y"), (b), ("?\n")) #Preguntamos el calc
        op = str(input(""" #Ofrecemos las opciones de cálculo las cuales van a llamar a las funciones
        1- Sumar
        2- Restar
        3- Multiplicar
        4- Dividir \n"""))
 
##########################################-3-##################################################
        if op == '1':#Si el usuario elige opción 1 llamamos a sumar
            sumar()
            break
        elif op == '2':#Si el usuario elige opción 1 llamamos a restar
            restar()
            break
        elif op == '3':#Si el usuario elige opción 1 llamamos a multiplicar
            multiplicar()
            break
        elif op == '4':#Si el usuario elige opción 1 llamamos a dividir
            dividir()
            break
        else:
            print ("""Has ingresado un numero de opcion erroneo""") #En caso que el numero no
                                                                            #se encuentre
    except:
        print ("Error")
        op = '?'

La dejo en spoiler para que no se haga molesto tanto código, pero puedes ver como ya antes habíamos separado las funciones en el apartado señalado con un 1. El bucle en el apartado 2 y finalmente las sentencias en el apartado 3.

Pues bien vamos a exportar esas funciones a un modulo propio, el cual llamaremos calcfunc.py

Así que colocamos calc.py en una carpeta, pues el módulo debe alojarse preferentemente junto al archivo que lo importa o invoca digamos.

Entonces copiamos el apartado 1 a nuestro nuevo módulo calcfunc. Pero vamos a mejorar ese código asqueroso así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  calc.py
#  
#  Copyright https://pythones.net
#
def sumar(a, b): return (a + b)
def restar(a, b): return (a - b)
def multiplicar(a, b): return (a * b)
def dividir(a, b): return (a / b)

Este es nuestro módulo, solo mejoramos el código para que quede en una sola línea y quitamos el print. Porque yo quiero que el solo se encargue de procesar los datos que le enviamos.

Ahora es el momento de modificar el código de la calculadora para importarlo y trabajar con sus funciones. Lo importe de esta manera para evitar tener que colocar calcfunc, si tu simplemente colocas un import calcfunc, te obligará a colocar antes del punto el nombre del mismo.

Obviamente ese print que quitamos debemos agregarlo en la calc.py para que nos muestre “El resultado es” y también añadir los argumentos a, b que estamos dando como parámetros en las funciones del módulo, de lo contrario no funcionará. Y (tambores) así queda nuestro código:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  calc.py
#  
#  Copyright https://pythones.net
#
############################################-1-##################################################
 
from calcfunc import * #Importamos todas las funciones explicitas de nuestro módulo
						#para no tener que especificar el modulo.funcion y que nuestro codigo
						#del apartado 3 quede casi igual.

##########################################-2-###################################################
while True: #Creamos un bucle
    try: #Intentamos obtener los datos de entrada
        a = int(input("Ingresa el primer numero: \n")) #Solicitamos el 1er numero al usuario
        b = int(input("Ingresa el segundo numero: \n"))#Solicitamos el 2do numero al usuario
        print (("Que calculo quieres realizar entre"), (a), ("y"), (b), ("?\n")) #Preguntamos el calc
        op = str(input(""" #Ofrecemos las opciones de cálculo las cuales van a llamar a las funciones
        1- Sumar
        2- Restar
        3- Multiplicar
        4- Dividir \n"""))
 
##########################################-3-##################################################
        if op == '1':
            print("El resultado es {}". format(sumar(a, b))) 
            #Aqui tenemos que cambiar las funciones, enviarle los argumentos para sus parametros
			#Y las metemos en un print, directamente para imprimir el resultado
            break
        elif op == '2':
            print("El resultado es {}". format(restar(a, b)))
            break
        elif op == '3':
            print("El resultado es {}". format(multiplicar(a, b)))
            break
        elif op == '4':
            print("El resultado es {}". format(dividir(a, b)))
            break
        else:
            print ("""Has ingresado un numero de opcion erroneo""") #En caso que el numero no
                                                                            #se encuentre
    except:
        print ("Error")
        op = '?'

Y este es el resultado final de calc.py:

calc.py Pythones

 

yoyo

Esta entrada está ligada al concepto de modularidad en Python, también con ejemplos utilizando clases, si quieres revisarlo y aprender más sobre módulos puedes leer aquí:

 

 

Bien y eso es todo por ahora, nos vemos por ahí!

 

 

 

 

 

Compartir es agradecer! :)