• Manuales

 #447807  por KHC
 06 Jul 2014, 03:17
Séptima entrega del curso de programación en Python3 que debe inconcluso hace un tiempo.

Excepciones:
-------------


A grandes rasgo, las excepciones son un artilugio del lenguaje como tal que nos permite
evaluar ciertos eventos y modificar como tal el comportamiento del programa.

Eventualmente al generarse un error el lenguaje activa un trigger o disparador que interrumpe
el flujo del programa abortando y saliendo.
Las excepciones como tal es una herramienta que ofrece el lenguaje para evaluar lo que ha ocurrido
controlarlo el error, permitiéndonos aplicar ciertas acciones en caso de haber sido activa cualquier
tipo de excepción.


Catching Exceptions:
-------------------


En este caso definimos un conjunto, que supuestamente deben saber de que tipo es...
al momento de consultar, en este caso mostrar el elemento 3 --name[2]-- y sabiendo que
se cuenta empezando por el '0' no tendria mayor problema darnos cuenta que estamos tratando de
acceder a un elemento que no existe
>>> name = ['juan','perez']
>>> print(name[2])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
De tal forma que nos indicar un 'IndexError' del tipo 'list index out of range', dejando claro
que el el index que utilizamos para la consulta es fuera del rango de elemento que contiene
el conjunto.
Hasta aquí sin mayor problema, en caso de estar en un script o programa en ejecución el
interprete de Python abortara la ejecución del programa.

Ahora intentaremos lo siguiente:
>>> try:
...     print(name[2])
... except IndexError:
...     print('Elemento no existente dentro del conjunto, revise el index.')
...
Elemento no existente dentro del conjunto, revise el index.
Con lo anterior try/execpt estamos evitan que el interprete de Python termine la ejecucio
del program/script.
Como podemos observar, dentro de 'try:' van las sentencias a evaluar en busca de excepciones
y dentro de 'except IndexError:' va nuestras medidas aposteriori a la detección del mismo.

Muestro la estructura de las excepciones en general:
try:
	aquí van sentencias a evaluar
except YOSOYELTIPODEEXCEPCION:
	aqui van las sentencias a ejecutar de detectar una excpecion en try
else:
	si no se detecta ningún a de las anteriores entonces me toca a mi
finally:

	después de haber salido de try
De no entrar la sentencia except, se ejecutaran las dos siguientes 'else' y 'finally'.
También hacer énfasis en la sentencia 'except' ya que después de palabra reservada 'except'
seguido de un espacio va el tipo de error que se busca, también se pueden agregar tantos
excepts como uno quiera en busca de distintas excepciones.


Raise:
-------


Python tambien ofrece un artilugio que nos permite lanza un tipo de excepción personalizada y
se trata de 'raise'
>>> raise Exception('excepcion personalizada :3')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Exception: excepcion personalizada :3
Un clásico ejemplo donde podrías personalizar un excepción sera al calcular las raíces de un
polinomio de segundo grado, en caso de ser negativas, podríamos lanzar una excepción
que nos indique que son raíces complejas, que no dudo que Python tenga un la excepción
ya definida, como era el caso en python 2.7, de ser sincero he estado buscando sin encontrar
nada relacionado...


Definiendo Excepciones:
--------------------------


Podemos personalizar la excepciones a nuestras necesidades como antes comente, para esto
seria necesario comprender el paradigma de la POO y eso lo trataremos mas adelante.
De momento dejaremos este apartado de lado para tratarlo mas adelante para bien del lector.


Información Sobre Las Excepciones:
----------------------------------------


Esto principalmente nos ayudara para informar tanto al desarrollador, como al usuario lo sucedido
y poder corregir el tipo tratado a futuro, ofreciéndonos muchas posibilidades como por ejemplo
poder volcar el dump a un log o mandarlo a un server que reciba los logs y sea corregido en programa.

Para realizar esto necesitaremos una utilidad dentro del modulo 'sys' y basta con importarlo
>>>import sys
o bien:
>>>from sys import exc_info
También podemos instanciar exc_info:
>>> from sys import exc_info as informatiion
>>> informatiion
<built-in function exc_info>
>>> informatiion()
(None, None, None)
Como vemos lo que nos sera de utilidad es 'exc_info()' una función definida dentro del modulo 'sys'
que al ser invocada notamos que nos regresa una tupla con tres elementos.
>>>help(informatiion)
en nuestro caso ya que importamos e instaciamos la función, pero también podría ser así:
>>>help(exc_info)
ya que solo importamos del modulo 'sys' o también:
>>>help(sys.exc_info)
en dado caso que solo importamos el modulo sys, en cualquiera de los tres caso nos regresa esto:
Help on built-in function exc_info in module sys:

exc_info(...)
    exc_info() -> (type, value, traceback)
    
    Return information about the most recent exception caught by an except
    clause in the current stack frame or in an older stack frame.
Como vemos el primer valor de la tupla es el tipo de excepción;
el segundo es el valor que arroja el tipo de excepción y por ultimo
el traceback del objeto.

Bueno ya con conocimiento de como tratar un tupla, se les queda de tarea el pensar
como volcar la información a un log para poder analizarla después.

Este paper en especial tratamos puras y meras excepciones, ya que era pertinente y
ya en el siguiente, trataremos lo que es el paradigma de la POO lo mas simple posible
y que mejor que apoyarnos de Python para entender ese paradigma.
Un saludo a todos!

@greydotsec
@julianstafari
[ Debe registrarse para ver este enlace ]