Módulos

¿Cómo se divide una pieza de software en partes separadas pero cooperantes? Esta es la
pregunta. Módulos son la respuesta

¿Cómo hacer uso de un módulo?

El manejo de los módulos consta de dos cuestiones diferentes:

• El primero (probablemente el más común) ocurre cuando se desea utilizar un módulo ya

existente, escrito por otra persona o creado por el programador mismo en algún proyecto
complejo: en este caso, se considera al programador como el usuario del módulo.

• El segundo ocurre cuando se desea crear un nuevo módulo, ya sea para uso propio o para
facilitar la vida de otros programadores: aquí eres el proveedor del módulo

En primer lugar, un módulo se identifica por su nombre. Si se desea utilizar cualquier módulo, se
necesita saber su nombre. Se entrega una cantidad (bastante grande) de módulos junto con
Python. Se puede pensar en ellos como una especie de "equipo extra de Python".
Todos estos módulos, junto con las funciones integradas, forman la Biblioteca estándar de
Python - un tipo especial de biblioteca donde los módulos desempeñan el papel de libros
(incluso podemos decir que las carpetas desempeñan el papel de estanterías). Si deseas ver
la lista completa de todos los "volúmenes" recopilados en esa biblioteca, se puede encontrar
aquí: https://docs.python.org/3/library/index.html

Cada módulo consta de entidades (como un libro consta de capítulos). Estas entidades pueden
ser funciones, variables, constantes, clases y objetos. Si se sabe cómo acceder a un módulo en
particular, se puede utilizar cualquiera de las entidades que almacena.

Comencemos la discusión con uno de los módulos más utilizados, el que lleva por nombre math.
Su nombre habla por sí mismo: el módulo contiene una rica colección de entidades (no solo
funciones) que permiten a un programador implementar efectivamente cálculos que exigen el uso
de funciones matemáticas, como sen() o log().

Importando un módulo

Para que un módulo sea utilizable, hay que importarlo (piensa en ello como sacar un libro del
estante). La importación de un módulo se realiza mediante una instrucción llamada import. Nota:
import es también una palabra reservada (con todas sus implicaciones).
Supongamos que deseas utilizar dos entidades proporcionadas por el módulo math:

Un símbolo (constante) que representa un valor preciso (tan preciso como sea posible usando
aritmética de punto flotante doble) de π (aunque usar una letra griega para nombrar una variable
es totalmente posible en Python, el símbolo se llama pi: es una solución más conveniente,
especialmente para esa parte del mundo que ni tiene ni va a usar un teclado griego).

Una función llamada sin() (el equivalente informático de la función matemática sine).
Primera forma de importar un Modulo
La forma más sencilla de importar un módulo en particular es usar la instrucción de
importación de la siguiente manera:
import math

La cláusula contiene:
La palabra reservada import.
El nombre del módulo que se va a importar.
La instrucción puede colocarse en cualquier parte del código, pero debe colocarse antes del
primer uso de cualquiera de las entidades del módulo.
Si se desea (o se tiene que) importar más de un módulo, se puede hacer repitiendo la cláusula
import, o listando los módulos despues de la palabra reservada import, por ejemplo:

import math, sys

La instrucción importa dos módulos, primero uno llamado math y luego un segundo llamado
sys.
La lista de módulos puede ser arbitrariamente larga.

Para llamar a las entidades se coloca: nombre_Modulo.nombre Entidad.

Por ejemplo:

Ingresar el radio de un circulo y calcular su área:

import math

radio=float(input('Ingrese radio:'))

area=math.pi*math.pow(radio,2)

print('El area es: ',area)

En este programa estamos importando el modulo math. Y para usar la constante pi, se coloca
math.pi y para usar la función potencia se coloca math.pow(radio,2)
Segunda forma de importar un Modulo

En el segundo método, la sintaxis del import señala con precisión qué entidad (o entidades) del
módulo son aceptables en el código:

from math import pi, pow,sin

La instrucción consta de los siguientes elementos:

• La palabra reservada from.

• El nombre del módulo a ser (selectivamente) importado.

• La palabra reservada import.

• El nombre o lista de nombres de la entidad o entidades las cuales estan siendo importadas al
namespace.

La instrucción tiene este efecto:

• Las entidades listadas son las unicas que son importadas del módulo indicado.

• Los nombres de las entidades importadas pueden ser accedidas dentro del programa.

Ejemplo:

from math import pi,pow

radio=float(input('Ingrese radio:'))

area=pi*pow(radio,2)

print('El area es: ',area)

Tercera forma de importar un Modulo

En el tercer método, la sintaxis del import es una forma más agresiva que la presentada
anteriormente:

from module import *

Como puedes ver, el nombre de una entidad (o la lista de nombres de entidades) se reemplaza con
un solo asterisco (*).

Tal instrucción importa todas las entidades del módulo indicado.

¿Es conveniente? Sí, lo es, ya que libera del deber de enumerar todos los nombres que se
necesiten.

¿Es inseguro? Sí, a menos que conozca todos los nombres proporcionados por el módulo, es
posible que no puedas evitar conflictos de nombres. Trata esto como una solución temporal e
intenta no usarlo en un código regular
Importando un módulo: la palabra reservada as

Si se importa un módulo y no se esta conforme con el nombre del módulo en particular (por
ejemplo, sí es el mismo que el de una de sus entidades ya definidas) puede darsele otro nombre:
esto se llama aliasing o renombrado.

Aliasing (renombrado) hace que el módulo se identifique con un nombre diferente al original.

La creación de un alias se realiza junto con la importación del módulo, y exige la siguiente forma
de la instrucción import:

import module as alias

Nota: después de la ejecución exitosa de una importación con alias, el nombre original del módulo
se vuelve inaccesible y no debe ser utilizado.

A su vez, cuando usa la variante from module import name y se necesita cambiar el nombre de la
entidad, se crea un alias para la entidad. Esto hará que el nombre sea reemplazado por el alias que
se elija.

Así es como se puede hacer:

from module import nombre as alias

Como anteriormente, el nombre original (sin alias) se vuelve inaccesible.

La frase nombre as alias puede repetirse: emplea comas para separar las frases, como a
continuación:

from module import n as a, m as b, o as c

El ejemplo puede parecer un poco extraño, pero funciona:

from math import pi as PI, sin as sine

print(sine(PI/2))

Instrucción dir

Permite revelar todos los nombres proporcionados a través de un módulo en particular.

Hay una condición: el módulo debe haberse importado previamente como un todo (es decir,
utilizar la instrucción import module
La función devuelve una lista ordenada alfabéticamente la cual contiene todos los nombres de las
entidades disponibles en el módulo:
dir(module)

Nota: Si el nombre del módulo tiene un alias, debe usar el alias, no el nombre original.
import math

for name in dir(math):

print(name, end="\t")

__doc__ __loader__ __name__ __package__ __spec__ acos acosh asin asinh

atan atan2 atanh ceil copysign cos cosh degrees e erf erfc exp expm1 fabs
factorial floor fmod frexp fsum gamma gcd hypot inf isclose isfinite isinf isnan
ldexp lgamma log log10 log1p log2 modf nan pi pow radians remainder sin
sinh sqrt tan tanh tau trunc

Funciones seleccionadas del módulo math

• sin(x) → el seno de x.
• cos(x) → el coseno de x.
• tan(x) → la tangente de x.
• asin(x) → el arcoseno de x.
• acos(x) → el arcocoseno de x.
• atan(x) → el arcotangente de x.
• pi → una constante con un valor que es una aproximación de π.
• radians(x) → una función que convierte x de grados a radianes.
• degrees(x) → actuando en el otro sentido (de radianes a grados).
• sinh(x) → el seno hiperbólico.
• cosh(x) → el coseno hiperbólico.
• tanh(x) → la tangente hiperbólico.
• asinh(x) → el arcoseno hiperbólico.
• acosh(x) → el arcocoseno hiperbólico.
• atanh(x) → el arcotangente hiperbólico.
• e → una constante con un valor que es una aproximación del número de Euler (e).
• exp(x) → encontrar el valor de ex.
• log(x) → el logaritmo natural de x.
• log(x, b) → el logaritmo de x con base b.
• log10(x) → el logaritmo decimal de x (más preciso que log(x, 10)).
• log2(x) → el logaritmo binario de x (más preciso que log(x, 2)).
• pow(x, y) → encontrar el valor de xy (toma en cuenta los dominios).
• ceil(x) → devuelve el entero más pequeño mayor o igual que x.
• floor(x) → el entero más grande menor o igual que x.
• trunc(x) → el valor de x truncado a un entero (ten cuidado, no es equivalente a ceil o floor).
• factorial(x) → devuelve x! (x tiene que ser un valor entero y no negativo).
• hypot(x, y) → devuelve la longitud de la hipotenusa de un triángulo rectángulo con las longitudes
de los catetos iguales a x e y (lo mismo que sqrt(pow(x, 2) + pow(y, 2)) pero más preciso).
Ejemplo 01
from math import pi, radians, degrees, sin, cos, tan, asin
ad = 90
ar = radians(ad)
ad = degrees(ar)
print(ad == 90.)
print(ar == pi / 2.)
print(sin(ar) / cos(ar) == tan(ar))
print(asin(sin(ar)) == ar)

Ejemplo 02

from math import e, exp, log

print(pow(e, 1) == exp(log(e)))

print(pow(2, 2) == exp(2 * log(2)))

print(log(e, e) == exp(0))

Ejemplo 03

from math import ceil, floor, trunc

x = 1.4

y = 2.6

print(floor(x), floor(y))

print(floor(-x), floor(-y))

print(ceil(x), ceil(y))

print(ceil(-x), ceil(-y))

print(trunc(x), trunc(y))

print(trunc(-x), trunc(-y))
¿Qué es un paquete?

• Un módulo es un contenedor lleno de funciones - puedes empaquetar tantas funciones como

desees en un módulo y distribuirlo por todo el mundo.

• Por supuesto, no es una buena idea mezclar funciones con diferentes áreas de aplicación dentro
de un módulo (al igual que en una biblioteca: nadie espera que los trabajos científicos se incluyan
entre los cómics), así que se deben agrupar las funciones cuidadosamente y asignar un nombre
claro e intuitivo al módulo que las contiene (por ejemplo, no le des el nombre videojuegos a un
módulo que contiene funciones destinadas a particionar y formatear discos duros).

• Crear muchos módulos puede causar desorden: tarde que temprano querrás agrupar tus
módulos de la misma manera que previamente has agrupado funciones: ¿Existe un contenedor
más general que un módulo?.

• Sí lo hay, es un paquete: en el mundo de los módulos, un paquete juega un papel similar al de

una carpeta o directorio en el mundo de los archivos

Tu primer módulo

Crear el modulo llamado aritmética.py que tenga una función que reporte los divisores de un
numero y una función para poder verificar si un número es primo

aritmetica.py

def mostrar_divisores(x):
for i in range(1,x+1):
if x % i ==0:
print(i,end=" ")

def esPrimo(x):
cd=0
for i in range(1,x+1):
if x % i ==0:
cd=cd+1
if cd==2:
return True
else:
return False

Hacer un programa que usando el modulo aritmética.py, ingrese un número y reporte todos sus
divisores y que se verifique si el número es primo.

from aritmetica import mostrar_divisores,esPrimo

num = int(input('Ingrese numero entero: '))

print('Los divisores son')
mostrar_divisores(num)
print()
if esPrimo(num):
print('El numero ',num, 'es primo')
else:
print('El numero ',num, 'no es primo')

Excepciones
Cada vez que tu código intenta hacer algo erróneo, irresponsable o inaplicable, Python hace dos
cosas:

• Detiene tu programa.

• Crea un tipo especial de dato, llamado excepción.

Ambas actividades llevan por nombre lanzar una excepción. Podemos decir que Python siempre
lanza una excepción (o que una excepción ha sido lanzada) cuando no tiene idea de qué hacer con
el código.

¿Qué ocurre después?

• La excepción lanzada espera que alguien o algo lo note y haga algo al respecto.

• Si la excepción no es resuelta, el programa será terminado abruptamente, y verás un mensaje de

error enviado a la consola por Python.

• De otra manera, si se atiende la excepción y es manejada apropiadamente, el programa puede

reanudarse y su ejecución puede continuar.

Python proporciona herramientas efectivas que permiten observar, identificar y manejar las
excepciones eficientemente. Esto es posible debido a que todas las excepciones potenciales tienen
un nombre específico, por lo que se pueden clasificar y reaccionar a ellas adecuadamente

Observa el código en el editor. Ejecuta el (obviamente incorrecto) programa.

valor = 1
valor /= 0
Verás el siguiente mensaje en respuesta:
Traceback (most recent call last):
File "div.py", line 2, in
valor /= 0
ZeroDivisionError: division by zero
Este error de excepción se llama ZeroDivisionError
Manejando una Excepción
try:
Trata de ejecutar algo
# procesar el archivo
except exc1:
# Manejar bloque excepción 1
except exc2:
# Manejar bloque excepción 2
except:
# procesar otro tipo de excepcion
finally: # Esta cláusula es Opcional
Ejecuta algo siempre, así exista o no exista excepcion

✓ Si el try lanza la excepción exc1, esta será manejada por el bloque except exc1:.
✓ De la misma manera, si el try lanza la excepción exc2, esta será manejada por el bloque
except exc2:.
✓ Si el try lanza cualquier otra excepción, será manejado por el bloque sin nombre except
✓ Exista o no exista Excepción el bloque finally se ejecutará.

Ejemplo 01:

try:

x = int(input("Ingresa un numero: "))

y=1/x

except:

print("Oh cielos, algo salio mal...")

print("FIN.")

Al igual que en el código en el editor. Ejecútalo y ve lo qué pasa.

El mensaje: Oh cielos, algo salió mal... que aparece en la consola no dice nada acerca de la razón,
mientras que hay dos posibles causas de la excepción:

✓ Datos no enteros fueron ingresados por el usuario.

✓ Un valor entero igual a 0 fue asignado a la variable x.

Técnicamente, hay dos formas de resolver el problema:

✓ Construir dos bloques consecutivos try-except, uno por cada posible motivo de excepción
(fácil, pero provocará un crecimiento desfavorable del código).
✓ Emplear una variante más avanzada de la instrucción.
Ejemplo 02

try:
x = int(input("Ingresa un numero: "))
y=1/x
print(y)
except ZeroDivisionError:
print("No puedes dividir entre cero, lo siento.")
except ValueError:
print("Debes ingresar un valor entero.")
except:
print("Oh cielos, algo salio mal...")
print("THE END.")

El código, cuando se ejecute, producirá una de las siguientes cuatro variantes de salida:

✓ Si se ingresa un valor entero válido distinto de cero (por ejemplo, 5) dirá:

0.2
FIN.
✓ Si se ingresa 0, dirá:
No puedes dividir entre cero, lo siento.
FIN.
✓ Si se ingresa cualquier cadena no entera, verás:
Debes ingresar un valor entero.
FIN.
✓ (Localmente en tu máquina) si presionas Ctrl-C mientras el programa está esperando la
entrada del usuario (provocará una excepción denominada KeyboardInterrupt), el programa
dirá:
Oh cielos, algo salio mal...
FIN.

Ejemplo 03

try:
x = int(input("Ingresa un numero: "))
y=1/x
print(y)
except ValueError:
print("Debes ingresar un valor entero.")
finally:
print("FIN.")
El usuario ingresa nuevamente un 0 , y:

✓ La excepción no será manejada por ValueError - no tiene nada que ver con ello.
Como no hay otro bloque, deberías ver este mensaje:
FIN.

Traceback (most recent call last):

File "exc.py", line 3, in
y = 1 / x
ZeroDivisionError: division by zero
✓ Imprimira FIN pues cuando hay finally las instrucciones que
siguen al finally se ejecutan, se trate o no se trate la
excepción.

Python 3 define 63 excepciones integradas, y todos ellos forman una jerarquía en forma de
árbol, aunque el árbol es un poco extraño ya que su raíz se encuentra en la parte superior.

Algunas de las excepciones integradas son más generales (incluyen otras excepciones) mientras
que otras son completamente concretas (solo se representan a sí mismas). Podemos decir
que cuanto más cerca de la raíz se encuentra una excepción, más general (abstracta) es. A su
vez, las excepciones ubicadas en los extremos del árbol (podemos llamarlas hojas) son concretas
Recuerda:

✓ ¡El orden de las excepciones importa!

✓ No pongas excepciones más generales antes que otras más concretas.
✓ Esto hará que el último sea inalcanzable e inútil.
✓ Además, hará que el código sea desordenado e inconsistente.
✓ Python no generará ningún mensaje de error con respecto a este problema

La instrucción raise

La instrucción raise genera la excepción especificada denominada exc como si fuese generada de
manera natural:

raise exc

Nota: raise es una palabra reservada.

La instrucción permite:

✓ Simular excepciones reales (por ejemplo, para probar tu estrategia de manejo de

excepciones).
✓ Parcialmente manejar una excepción y hacer que otra parte del código sea responsable de
completar el manejo.

La instrucción assert

La instrucción de Python, llamada assert (afirmar), es una palabra reservada.

assert expresión

¿Como funciona?

✓ Evalúa la expresión.
✓ Si la expresión se evalúa como True (verdadero), o un valor numérico distinto de cero, o
una cadena no vacía, o cualquier otro valor diferente de None, no hará nada más.
✓ De lo contrario, automáticamente e inmediatamente genera una excepción llamada
AssertionError (en este caso, decimos que la afirmación ha fallado).

¿Cómo puede ser utilizada?

✓ Puedes ponerlo en la parte del código donde quieras estar absolutamente a salvo de datos
incorrectos, y donde no estés absolutamente seguro de que los datos hayan sido
examinados cuidadosamente antes (por ejemplo, dentro de una función utilizada por otra
persona).
✓ El generar una excepción AssertionError asegura que tu código no produzca resultados no
válidos y muestra claramente la naturaleza de la falla.
✓ Las aserciones no reemplazan las excepciones ni validan los datos, son suplementos.
Si las excepciones y la validación de datos son como conducir con cuidado, la aserción puede
desempeñar el papel de una bolsa de aire.

Ejemplo:

import math

x = float(input("Ingresa un numero: "))

assert x >= 0.0

x = math.sqrt(x)

print(x)

El programa se ejecuta sin problemas si se ingresa un valor numérico válido mayor o igual a cero;
de lo contrario, se detiene y emite el siguiente mensaje:

Traceback (most recent call last):

File ".main.py", line 4, in

assert x >= 0.0

AssertionError

Ejercicio

Tu tarea es escribir una función capaz de ingresar valores enteros y verificar si están dentro de un
rango especificado.
La función debe:
✓ Aceptar dos argumentos: un límite inferior aceptable y un límite superior aceptable.
✓ Si el usuario ingresa una cadena que no es un valor entero, la función debe emitir el
mensaje Error: entrada incorrecta, y solicitará al usuario que ingrese el valor nuevamente.
✓ Si el usuario ingresa un número que está fuera del rango especificado, la función debe
emitir el mensaje Error: el valor no está dentro del rango permitido (min..max) y solicitará
al usuario que ingrese el valor nuevamente.
✓ Si el valor de entrada es válido, será regresado como resultado.
def validarEntrada(limite_inferior,limite_superior):
exito=False
while not exito:
paso=True
try:
valor=int(input("Ingrese numero entre -10 y 10: "))
except ValueError:
paso=False
print("Error entrada incorrecta")
if paso==True:
if valor>=limite_inferior and valor<=limite_superior:
print('el numero es : ',valor)
exito=True
else:
print('El valor no está dentro del rango permitido')
return valor

limite_inferior=-10
limite_superior=10
validarEntrada(limite_inferior,limite_superior)