UNIVERSIDAD DE GUAYAQUIL

FACULTAD DE CIENCIAS ADMINISTRATIVAS

MATERIA
PROGRAMACIÓN EXTRUCTURADA

ESTUDIANTE

CHELE TIGUA KERLY JOHANA

TUTORA
LCDA. MARCILLO SANCHEZ PATRICIA

CURSO
VE 2-2
 2021
GUAYAQUIL – ECUADOR

¿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.

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.

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.

#!/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)
puesto 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 *

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))

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
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:

Cuáles son las librerías que trabajan con archivos.

Diferentes librerías para generar archivos .PDF
Fpdf: es uno de los más populares entre desarrolladores, genera archivos PDF con PHP y tiene
licencia libre sin restricciones. Un ejemplo que puedes ver es Pdf-generator.
iText: con iText puedes generar archivos PDF de forma rápida, soportado por la tecnología Java y
con una licencia MPL/LGPL.
Alivepdf: funciona con ActionScript 3, librería Open Source y con licencia MIT.
Tcpdf:es una clase PHP Open Source que genera documentos PDF, un proyecto que dio inicio en
el 2002 que funciona con una licencia LGPL.
Haru: es crossplataform y funciona en C++ utiliza una licencia ZLIB/LIBPNG.
Apache FOP: es una aplicación Java que funciona con una licencia Apache, versión 2.0 y lee
XSL-FO.
Archivos DLL

Seguramente hemos oído hablar de los archivos DLL

Que vas a encontar aquí? Definición de los archivos DLL y para que sirven. Como instalar, abrir y
manejarlos.
Estos archivos DLL son fundamentales para el buen funcionamiento de las aplicaciones, ya que
son parte de ellas, ya que contienen diversos elementos como gráficos, fuentes, comandos y
demás.

Como mencionamos, los archivos DLL están lamentablemente relacionados con errores en la PC,
esto sucede debido a una mala ejecución de los mismos por descuido del programador o por mal
diseño del programa que usa estas DLL. Esto provoca que una vez cerrada la aplicación que las
utiliza, las DLL continúan residiendo en la memoria, lo que además de perjudicarnos en lo relativo
al rendimiento de nuestra computadora, suscita problemas de compatibilidad.