Manejo de errores

Cuando de Sistemas y Programas hablamos:

• El ingreso de datos es uno de los puntos de mayor frecuencia de errores. • El ingreso de datos es el lugar más económico
donde se pueden detectar y

salvar errores.

Para intentar disminuir la tasa de errores en el ingreso podemos:

• Simplificar el formato de los datoso adaptarlos a sistemas de lectura automática (códigos de barra, QR, etc.).

• Validar los ingresos.

A la hora de testear algo, como cuando se usa un while loop, hay que utilizar como condición un ingreso inválido para que
ofrecerle al usuario cuantas oportunidades sean necesarias para que ingrese un dato válido. Un ejemplo sería:

par = int (input(' Ingresá un número par: '))

while par < 0 or par % 2 != 0: # También te serviría la condición

# par < 0 or par % 2.

par = int (input (' Ingresá un número par: '))

print('Tu número es', par)

Una ejecución ejemplo podría ser:

Ingresá un número par: 11 Ingresá un número par: 8 Tu número es 8

>>>

Hay otros casos donde el usuario puede ingresar un tipo inválido de dato, como un string en vez de un int. Estas
situaciones podrían causar errores fatales en el programa, por lo que también se recomienda validar ante estas situaciones.
Una forma de manejar elegantemente esta situación sería aceptar el ingreso como string, validar que el ingreso sea
compatible con un número y recién castear:

# Solicita el ingreso de un string (aunque se espera un número). num = input(' Ingresá un número: )

# ¿Es compatible con un número?

# Si no es así, vuelve a pedirle un número al usuario. while not num.isnumeric():

num = input('Ingresá un número: '))

# Si es compatible con un número, imprímelo junto a un mensaje. print('Tu número es',int (num) )

Miremos una probable ejecución:

Ingresá un número: Cxc Ingresá un número: 3.66 Ingresá un número: 22 Tu número es 22

>>>

Disponemos de la sentencia estructurada trylexcept que funciona básicamente intentando realizar una acción (con try,
intento con recaudos) y si tiene éxito, el programa prosigue relajadamente, sin embargo, si en el intento emerge un error, la
sentencia lo captura y lo trata de una manera conveniente en la cláusula except. La sintaxis es:

try:
<código a probar> except:

<código a ejecutar si hay un error>

Un ejemplo de uso sería:

sigue = True

while sigue: try:

num = int (input('Ingresá un número entero: sique = False

except:

print (' Debe ser un número entero')

))

print('Tu número es', num)

Una ejecución posible sería:

Ingresá un número entero: hola Debe ser un número entero Ingresá un número entero: 1.33 Debe ser un número entero
Ingresá un número entero: -77 Tu número es -77

>>>

Nota: Los errores deben escribirse exactamente como los identifica Python. En el ejemplo, el Código de error que
pretendemos capturar es: ValueError. Debe anotarse tal cual.

sigue = True

while sigue: try:

num = int (input(' Ingresá un número entero: ')) sigue = False

except ValueError:

print(' Debe ser un número entero' )

print('Tu número es', num)

En este caso la excepción se activará únicamente si el error que se produce es de ese tipo.
Matplotlib

La última biblioteca que vamos a ver en la materia, pero, para qué sirve? Básicamente para crear gráficos y visualizaciones
de datos de forma sencilla, podemos representar datos en forma de gráficos de líneas, barras, dispersión y muchos otros
tipos. Antes de hablar de lo que sigue, veamos primero qué es un módulo.

¿Qué es un módulo?

En la clase anterior mencionamos que podemos decir analogamente que una biblioteca en Python es como una caja de
herramientas. Siguiendo la analogía previamente descrita podemos decir que los módulos son como los compartimientos en
aquella caja de herramientas, en la cual hay una sección especial para los destornilladores, otra para las pinzas y alicates,
etc. Y en qué nos benefinicia tener estos compartimientos? Bueno, nos permite tener una organización de todas las
herramientas. De la misma manera, los módulos son archivos/paquetes que se agrupan para proporcionar una
funcionalidad específica. Cada modulo contiene código con definiciones y declaraciones de funciones, variables, clases.
Cada módulo dentro de una biblioteca se centra en una tarea o conjunto de tareas específicas (modularizar). Esto permite
que podamos trabajar en diferentes aspectos de la biblioteca de forma independiente y facilita la reutilización del código en
diferentes proyectos. Bien, pero cómo importo una biblioteca y el módulo que yo quiero? De la siguiente manera: import
nombre_biblioteca.nombre_modulo Nosotros vamos a trabajar con pyplot, un módulo de matplotlib.

¿Qué es Pyplot?

Un módulo que proporciona una interfaz a la biblioteca de matplotlib. Simplifica la creación de gráficos al proporcionar una
serie de comandos y funciones predefinidas que permiten realizar tareas comunes de visualización de datos de manera
rápida y sencilla. Lo importamos asÍ: import matplotlib.pyplot as plt.

from matplotlib import pyplot as plt

Parte práctica
show con esta función vamos a mostrar cualquier gráfico que hagamos
Tipos de gráficos
plot

La función plot une una serie de puntos en el plano cartesiano, dados por dos arreglos de coordenadas X e Y. La función
show muestra la imagen con los gráficos definidos. Es fácil darse cuenta entonces que… mientras más puntos
definamos, más suave va a ser la linea. Sería conveniente también añadir labels a cada eje para indicar su significado y
ún título (title) general. Por ejemplo, el eje Y podría representar "Distancia" y el eje X podría representar "Tiempo". Así, sería
posible, por ejemplo, visualizar la relación entre la distancia y el tiempo
from matplotlib import pyplot as plt

x = [0,2,10,11,18,25] #eje de abscisas

y = [0,1,2,3,4,5] #eje de ordenadas

plt.plot(x, y) # usamos la función plot para unir los puntos x e y

plt.xlabel('Tiempo') # Etiqueta del eje X

plt.ylabel('Distancia') # Etiqueta del eje Y
plt.title('Gráfica de distancia en función del tiempo') #título de la gráfica

plt.show() # mostramos la gráfica

bar

la función .bar crea un gráfico de barras utilizando dos arreglos.

from matplotlib import pyplot as plt

peso = [340, 115, 200, 200, 270]

ingredientes = ['chocolate', 'manteca', 'azúcar', 'huevo', 'harina']

plt.bar(ingredientes, peso) # acá usamos la función para que se muestre el gráfico de

barras

plt.xlabel('Ingredientes').

plt.ylabel('Cantidad (gramos)')

plt.title("Receta")

Plt. Show

pie

la función .pie crea un gráfico tipo torta tomando arreglos como argumentos

from matplotlib import pyplot as plt

peso = [340, 115, 200, 200, 270]

ingredientes = ['chocolate', 'manteca', 'azúcar', 'huevo', 'harina']

plt.pie(peso, labels= ingredientes)

plt.title("Receta")

plt.show().

Scatter
muy parecido a la función plot en cuanto a los parámetros que recibe pero solo dibuja
los puntos en vez de unirlos con líneas.
from matplotlib import pyplot as plt

x = [5,7,8,7,2,17,2,9,4,11,12,9,6]

y = [99,86,87,88,111,86,103,87,94,78,77,85,86]

plt.scatter(x, y)

plt.show()
Antes de todo lo demás… Hablemos un poco de lo que es Numpy, la cuál es una bibliteca que nos permite trabajar con
conjuntos de datos numéricos, como matrices o vectores, de manera rápida y eficiente. Además proporciona funciones
y operaciones optimizadas para realizar cálculos matemáticos, estadísticos y algebraicos en estos arreglos, lo que facilita
el trabajo con datos numéricos y científicos en Python. Por otro lado, vamos a usar una función de numpy llamada linspace
la cual devuelve un arreglo NumPy con la secuencia de valores generados en el rango especificado. la sintáxis es:
**np.linspace(inicio, fin)**

la misma función puede tener los siguientes argumentos opcionales: num=50 especifica la cantidad de valores que se
generarán en la secuencia. ****Por defecto es 50.

**endpoint=True** Indica si se incluye o no el valor final (fin) en la secuencia. Si es True se incluye.

retstep=True permite obtener el espaciado entre los valores generados si es True

**dtype=None** especifica el tipo de datos de los valores generados (int, float, etc)

por lo qué podríamos decir que los argumentos que toma son los siguientes:

np.linspace(inicio, fin, cantidad_de_valores, incluir_valor_fin=True, retornar_paso=False, tipo_dato=None)

Como mencionamos antes, NumPy tiene muchísimas funciones relacionadas a números. Por ejemplo, el seno sin(x),
coseno cos(x) pero además también tiene constantes, valores constantes como por ejemplo el número π np.pi o el número
np.e , etc.

En Matplotlib, podés personalizar muchos aspectos de los gráficos cambiando la configuración predeterminada. Es decir, el
tamaño de la figura, la resolución (DPI), el color, el estilo de línea, las etiquetas de los ejes, la cuadrícula, etc. Por ejemplo,
vamos a graficar las funciones seno y coseno en el mismo gráfico.

Para empezar, necesitaremos obtener los datos para graficar:

import pandas as pd

import numpy as np

from matplotlib import pyplot as plt

X = np.linspace(-np.pi, np.pi, 256) # Generamos un arreglo de 256 puntos en el rango de -π a π

C, S = np.cos(X), np.sin(X) # Calculamos los valores de las funciones coseno y seno para cada punto en el arreglo X

df = pd.DataFrame({'x': X, 'cos(x)': C, 'sin(x)': S}) # Creamos un DataFrame utilizando Pandas con las columnas 'x', 'cos(x)' y
'sin(x)' y les asignamos los arreglos correspondientes

df # Mostramos el contenido del DataFrame en la consola

plt.figure(figsize=(10, 6), dpi=80) # Creamos una nueva figura con un tamaño de 10 pulgadas de ancho y 6 pulgadas de alto,
y una resolución (DPI) de 80

plt.plot(X, C) # usamos la función plot para unir los puntos x e y

plt.plot(X, S) # usamos la función plot para unir los puntos x e y

plt.show() # Mostramos el gráfico

si queremos cambiar los colores podemos agregar el argumento “color” dentro de la función plot, también podemos
cambiar el ancho del trazo de la línea usando “linewidth" y además con “linestyle" podemos cambiar el estilo de la linea.
Ejemplo

plt.figure(figsize=(10, 6), dpi=80)

plt.plot(X, C, color="blue", linewidth=2.5, linestyle=":")

plt.plot(X, S, color="red", linewidth=2.5, linestyle="-.")

plt.show()

Limite de los Ejes

Cuando ajustamos los límites de los ejes en un gráfico,

ampliamos el rango visible de los valores de los datos. Esto separa los puntos que estaban cerca de los bordes,
brindándoles más espacio y permitiéndonos verlos con mayor claridad. Para mostrar con más claridad, he decidido usar
otra función para este ejemplo:

Sin cambios en el lim de los ejes

x = [1,0,2,3,4]

y = [1,2,3,1,2]

plt.plot(x,y,color="black",marker="o",mfc="blue",ms=20)

plt.show

Con cambios en el lim de los ejesx = [1,0,2,3,4]

y = [1,2,3,1,2]

plt.plot(x,y,color="black",marker="o",mfc="blue",ms=20)

plt.xlim([-0.5,4.5])

plt.ylim([0.5,3.5])

plt.show