ALGORITMO CON

MANEJO DE EXCEPCIONES
 DEPURACIÓN DE PROGRAMAS

La eliminación de los errores en un programa recibe el nombre de depuración.

La depuración de programas cuenta con 3 fases: Alfa (donde se evidencia que al correr el
programa se notan los errores y se corrigen) , Beta (donde se entrega un trabajo a los
usuarios para que informen donde puede tener un error) y Gamma (es el producto
definitivo que se puede considerar casi perfecto).

La depuración de un programa suele realizarse en dos pasos:

- En primer lugar hay que localizar donde el sistema (R en este caso) ha detectado el
error.
- Desde este punto suele ser preciso retroceder hasta encontrar lo que ha producido el
problema.

Depuración en R se basa principalmente en la función browser (navegador). Esta inicia en

la ejecución del paso a paso y puede invocarse desde dentro de cualquier función. Es decir
si sabemos en que punto puede producirse el error podemos insertar la llamada antes de
este punto.
La función debug sirve para indicar a R que cierta función debe ser
depurada.

Lo que R muestra es:

1) Nombre de la función que se esta depurando
2) Numero de la línea en la que se encuentra
3) Un comando especial que es “Browser”.
• Visualizar cualquier variable global (o si está disponible) local en la función.
• Ejecutar instrucciones de R
• Ejecutar instrucciones específicas del depurador (haga help(debug) para más
explicaciones.
• Las instrucciones de depuración que muestra la ayuda de R son:

Dos puntos importantes: Para salir del depurador debe escribirse ’Q’
y para que ya no se invoque al depurador debe invertirse la llamada
con undebug().
 MANEJO DE EXCEPCIONES

No siempre los programas que se escriben están correctos. Existen muchos

tipos de errores que pueden estar presentes en un programa.

Existen errores que sí pueden ser detectados. Cuando un error es

detectado durante la ejecución del programa ocurre una excepción.

Los errores más comunes son:

* Error de sintaxis
* Error de ejecución
* Error de lógica
 ERROR DE SINTAXIS

Los errores en lenguaje de programación son llamados errores de sintaxis

Así como los idiomas tienen reglas de puntuación, gramática y ortografía, los lenguajes
de programación tienen reglas de cómo deben ser expresadas las instrucciones a la
computadora. Si el programador rompe esas reglas al crear el código para ejecutar un
algoritmo, esta responderá con un error de sintaxis.

Por ejemplo, a menudo los

programadores deben poner
declaraciones entre paréntesis. Si el
número de paréntesis abiertos no
coincide con el número de paréntesis
cerrados, ocurrirá un error de
sintaxis.
 ERROR DE SINTAXIS

! Si en vez de ingresar la instrucción:

System.out.printhl (“ingrese un numero:”);

Un programador escribe:

System.out.printhl (“ingrese un numero:”)

ó
Sistem.out.printhl (“ingrese un numero:”);
 ERROR DE EJECUCION

Son errores que aparecen mientras se ejecuta su programa. Estos errores aparecen
normalmente cuando el programa intenta una operación que es imposible llevar a cabo

!
sumaNotasExamenes=60;
numeroExamenes=0;
Promedio=sumaNotasExamenes/numeroExamenes;
 ERROR DE LOGICA

Son los mas difíciles de detectar, cuando un programa no tiene errores de

sintaxis ni errores de ejecución, pero aun así no funciona bien se debe a la
existencia de algún error lógico. Por tanto se produce cuando los resultados
obtenidos no son los esperados. En este caso, el error lógico conduce a un
error en tiempo de ejecución que hace que el programa se interrumpa. Estos
tipos de errores en tiempo de ejecución típicamente se llaman excepciones.
 ERROR DE LOGICA

import java.util.Scanner; 
!
public class SuperficieCuadrado { 
    public static void main(String[] ar) { 
        Scanner teclado=new Scanner(System.in); 
        int lado; 
        int superficie; 
        System.out.print("Ingrese el valor del lado del cuadrado:"); 
        lado=teclado.nextInt(); 
        superficie=lado * lado * lado; 
        System.out.print("La superficie del cuadrado es:");
        System.out.print(superficie);
Para el manejo de excepciones dentro de los lenguajes proveen ciertas palabras
reservadas, que nos permiten manejar las excepciones que puedan surgir y tomar
acciones de recuperación para evitar la interrupción del programa o, al menos, para
realizar algunas acciones adicionales antes de interrumpir el programa.

En el caso de Python, el manejo de excepciones se hace mediante los bloques que

utilizan las sentencias try, except y finally.

Dentro del bloque try se ubica todo el código que pueda llegar a levantar una
excepción, se utiliza el término levantar para referirse a la acción de generar una
excepción.

A continuación se ubica el bloque except, que se encarga de capturar la excepción y

nos da la oportunidad de procesarla mostrando por ejemplo un mensaje adecuado al
usuario. Veamos qué sucede si se quiere realizar una división por cero:
En este caso, se levantó la excepción ZeroDivisionError cuando se quiso
hacer la división. Para evitar que se levante la excepción y se detenga la
ejecución del programa, se utiliza el bloque try-except.
No se permite la división por cero.

Dado que dentro de un mismo bloque try pueden producirse excepciones

de distinto tipo, es posible utilizar varios bloques except, cada uno para
capturar un tipo distinto de excepción.

Esto se hace especificando a continuación de la sentencia except el

nombre de la excepción que se pretende capturar. Un mismo
bloque except puede atrapar varios tipos de excepciones, lo cual se hace
especificando los nombres de la excepciones separados por comas a
continuación de la palabra except. Es importante destacar que si bien
luego de un bloque try puede haber varios bloques except, se ejecutará, a
lo sumo, uno de ellos
Como se muestra en el ejemplo precedente también es posible utilizar una
sentencia except sin especificar el tipo de excepción a capturar, en cuyo
caso se captura cualquier excepción, sin importar su tipo. Cabe destacar,
también, que en caso de utilizar una sentencia except sin especificar el tipo,
la misma debe ser siempre la última de las sentencias except, es decir que
el siguiente fragmento de código es incorrecto.
Finalmente, puede ubicarse un bloque finally donde se escriben las
sentencias de finalización, que son típicamente acciones de limpieza. La
particularidad del bloque finally es que se ejecuta siempre, haya surgido una
excepción o no. Si hay un bloque except, no es necesario que esté presente
el finally, y es posible tener un bloque try sólo con finally, sin except.

Si, por otra parte, no hay problemas durante la ejecución del bloque try, se
completa la ejecución del bloque, y luego se pasa directamente a la
ejecución del bloque finally (si es que está definido).

Ejemplo: supongamos que nuestro programa tiene que procesar cierta

información ingresada por el usuario y guardarla en un archivo. Dado que el
acceso a archivos puede levantar excepciones, siempre deberíamos colocar
el código de manipulación de archivos dentro de un bloque try. Luego
deberíamos colocar un bloque except que atrape una excepción del
tipo IOError, que es el tipo de excepciones que lanzan la funciones de
manipulación de archivos. Adicionalmente podríamos agregar un
bloque except sin tipo por si surge alguna otra excepción. Finalmente
deberíamos agregar un bloque finally para cerrar el archivo, haya surgido o
no una excepción.