Conozca sus errores: tres

tipos de errores de
programación
Otras versiones

Actualización: noviembre 2007

En esta lección, conocerá los diferentes tipos de errores que pueden aparecer al escribir un programa.
Incluso los programadores más experimentados cometen errores; y conocer cómo depurar una aplicación y
encontrar esos errores es una parte importante de la programación. No obstante, antes de obtener información
sobre el proceso de depuración, conviene conocer los tipos de errores que deberá buscar y corregir.
Los errores de programación pertenecen a tres categorías: errores de compilación, errores en tiempo de
ejecución y errores lógicos. Las técnicas para depurar cada uno de ellos se tratarán en las tres lecciones siguientes.

Errores de compilación
Los errores de compilación, también conocidos como errores del compilador, son errores que impiden que su
programa se ejecute. Cuando presiona F5 para ejecutar un programa, Visual Basic compila el código en un
lenguaje binario que el equipo entiende. Si el compilador de Visual Basic se encuentra con código que no
entiende, emite un error de compilador.
La mayoría de los errores del compilador se deben a errores cometidos al escribir el código. Por ejemplo, puede
escribir mal una palabra clave, omitir alguna puntuación necesaria o intentar utilizar una instrucción End If sin
antes utilizar una instrucción If.
Afortunadamente, el editor de código de Visual Basic se diseñó para identificar estos errores antes de que se
intente ejecutar el programa. Aprenderá a encontrar y corregir los errores de compilación en la lección
siguiente, Encontrar y eliminar errores del compilador.

Errores en tiempo de ejecución

Los errores en tiempo de ejecución son errores que aparecen mientras se ejecuta su programa. Estos errores
aparecen normalmente cuando su programa intenta una operación que es imposible que se lleve a cabo.
Un ejemplo de esto es la división por cero. Suponga que tiene la instrucción siguiente:
Speed = Miles / Hours
Si la variable Hours tiene un valor de 0, se produce un error en tiempo de ejecución en la operación de división.
El programa se debe ejecutar para que se pueda detectar este error y si Hours contiene un valor válido, no se
producirá el error.
Cuando aparece un error en tiempo de ejecución, puede usar las herramientas de depuración de Visual Basic
para determinar la causa. Aprenderá a encontrar y corregir los errores en tiempo de ejecución en la lección ¡No
funciona! Encontrar y eliminar errores en tiempo de ejecución.

Errores lógicos
Los errores lógicos son errores que impiden que su programa haga lo que estaba previsto. Su código puede
compilarse y ejecutarse sin errores, pero el resultado de una operación puede generar un resultado no esperado.
Por ejemplo, puede tener una variable llamada FirstName y establecida inicialmente en una cadena vacía.
Después en el programa, puede concatenar FirstName con otra variable denominada LastName para mostrar un
nombre completo. Si olvida asignar un valor a FirstName, sólo se mostrará el apellido, no el nombre completo
como pretendía.
Los errores lógicos son los más difíciles de detectar y corregir, pero Visual Basic también dispone de
herramientas de depuración que facilitan el trabajo. Aprenderá a encontrar y corregir los errores lógicos
en ¿Qué? Esto no debiera haber ocurrido. Encontrar errores lógicos.
Pasos siguientes
En esta lección, obtuvo información sobre las tres categorías de errores de programación. En la lección siguiente
obtendrá información sobre cómo depurar los errores del compilador.
Siguiente lección: Encontrar y eliminar errores del compilador

Tipos de errores en programación. De compilación o ejecución.

Gestionados y no gestionados. (CU00242A)
Escrito por Mario R. Rancel
Resumen: Entrega nº41 del curso Bases de la programación Nivel II.

Codificación aprenderaprogramar.com: CU00242A

CLASIFICACIÓN DE ERRORES.

Los errores en un programa o algoritmo se pueden clasificar en distintos tipos. Atendiendo a los efectos que ocasionan se

podría hablar de errores que impiden la ejecución de un programa y errores que no impiden la ejecución de un programa.

Atendiendo al momento en que se producen podríamos hablar de errores de compilación y errores de ejecución. Lo vemos en

forma de esquemas:

Atendiendo a los efectos que ocasionan:

Atendiendo al momento en que se producen:

Cuando una vez tenemos escrito el código del programa y ordenamos su ejecución, se produce una “lectura de interpretación”

previa llamada compilación. Recordemos que el ordenador no interpreta directamente las órdenes que le damos sino que

necesita una traducción. Si durante esa traducción se detecta un problema el programa no comienza a ejecutarse. Lo más

habitual es que se detecten fallos de sintaxis, ciertos procesos no válidos e incluso errores lógicos tipo bucle infinito en algunas

circunstancias. Si el programa no compila estamos obligados a realizar las correcciones oportunas antes de poder ejecutarlo.

Durante la ejecución del programa pueden producirse errores previsibles porque se derivan del código o imprevisibles por ser

su origen externo (entradas incorrectas de usuario, problemas con ficheros, etc.).

Un error de ejecución puede ser gestionado (vía detección o vía lógica) pero uno de compilación no.

Atendiendo a la naturaleza del error los clasificaremos en:

Y según el tratamiento que reciben:

Por su facilidad de detección tendríamos:

Hay errores cuya clasificación no es sencilla. Por ejemplo, si al usuario se le pide un número entero durante la ejecución del

programa, pero introduce uno real, se puede producir un error de ejecución por proceso no válido. Sin embargo, el trasfondo

del error es lógico: el programa no está preparado para reaccionar ante una situación que es posible. A estos errores los

llamaremos errores de fondo lógico.

Prevención, gestión y tipos de errores. Errores de sintáxis, por

procesos no válidos y lógicos. (CU00241A)
Escrito por Mario R. Rancel
Resumen: Entrega nº40 del curso Bases de la programación Nivel II.

Codificación aprenderaprogramar.com: CU00241A

ERRORES. INTRODUCCIÓN.
Llamamos error a cualquier circunstancia que da lugar a un malfuncionamiento de un programa. Por malfuncionamiento se

entiende una respuesta indeseada: desde meros problemas estéticos hasta graves fallos o bloqueos.

Intuitivamente tenemos muchas ideas relacionadas con los errores. Aplicado al devenir diario, estamos acostumbrados a hablar

de “fallos” en las máquinas.

De un coche por ejemplo, puede decirse que “está perfecto” o “tiene un pequeño fallo pues hace un ruidito la correa, pero anda

bien”. Otras veces diremos que “está teniendo problemas graves con el cambio de marchas” o “se paró y tuve que llamar a una

grúa”. Con los programas informáticos pasa algo similar: pueden presentar fallos leves o casi despreciables, fallos

notables pero aún así funcionan y fallos totales en determinadas circunstancias. Sin duda, la mejor situación es la del

programa libre de errores. O dicho de otra manera: el mejor error es el que no existe.

¿Cómo construir programas sin errores? Si tuviéramos la respuesta a esta pregunta quizás fuéramos presidentes de alguna

multinacional, pues es algo a lo que muchísima gente intenta responder. Pero aún no teniéndola, quizás sí podemos indicar

algunos factores importantes al respecto:

· La experiencia derivada de enfrentarnos a errores y buscarles solución nos permite mejorar como programadores. Un

programador más experto comete menos errores.

· Existen metodologías contrastadas que son efectivas para evitar la aparición de errores. Son lo que globalmente se llama

“buenas prácticas de programación” y comprenden multitud de pautas de diseño y construcción de programas, muchas de las

cuales han sido ya expuestas. Estas pautas van desde meras cuestiones de presentación hasta aspectos fundamentales de la

programación. Si algo hemos hecho en estas páginas es hablar de método y de diseño. No vamos a extendernos en esto ahora.

Sí queremos recordar que cuestiones aparentemente sencillas como asumir que “se recomienda no escribir muchas órdenes en

una sola línea” pueden suponernos grandes ventajas. Y ello, sin esfuerzo. Es suficiente con tener método.

· Es importante diseñar y verificar módulos o algoritmos independientes para luego realizar integraciones que habrá a su vez

que verificar. Integrar partes no verificadas supone crear estructuras de difícil verificación y corrección.

· Programar requiere concentración y dedicación. Igual que no imaginamos una partida de ajedrez en un entorno de ruidos y

distracciones, no pensemos que podemos programar en cualquier ambiente. Un buen programador distraído o preocupado en

otras cosas puede ser un mal programador.

Tenemos claro que uno de nuestros objetivos ha de ser construir programas libres de errores. Ahora bien, somos humanos y

hemos de asumirlo. Por suerte o por desgracia vamos a tener que convivir con errores, independientemente de que pongamos

más o menos medios para evitarlos. Si esto es así, el programador no “odia” los errores. Al programador “le interesan” los

errores desde dos puntos de vista:

a) Para su identificación y eliminación, evitando así que aparezcan en momentos inoportunos.

b) Para su gestión cuando, a pesar de todo, se produzcan.

De ello vamos a hablar a continuación.

TIPOS DE ERRORES

Hay distintos tipos de errores y distintas formas de clasificarlos. Vamos a ver primero una serie de definiciones para luego ver

las clasificaciones. Los cuatro tipos básicos de errores son: de sintaxis, por proceso no válido, lógicos tipo bucle infinito y lógicos

tipo resultado incorrecto.

ERRORES DE SINTÁXIS

Son todos aquellos que se generan por infringir las normas de escritura de un lenguaje. Suelen deberse a olvidos o a

desconocimiento (programadores principiantes) y comprenden falta o mal uso de elementos separadores (comas, puntos y

comas, dos puntos, etc.), palabras mal escritas (por ejemplo Mietras en vez de Mientras o Finelizar en vez de Finalizar).

Suelen ser errores obvios y fáciles de detectar. La mayoría de los lenguajes tienen herramientas de ayuda para facilitar la

escritura y la corrección del código desde el punto de vista sintáctico. Además, en general, no es posible la ejecución de un

programa con errores de sintaxis y se insta al programador a su corrección en los distintos puntos donde pueda haber

problemas por parte del programa de gestión del lenguaje que se esté utilizando.
Téngase en cuenta que aparte de olvidos, escritura incorrecta de signos, palabras mal escritas, etc. la omisión de términos

obligatorios también será considerada error de sintaxis. Por ejemplo un Si que no se cierra con un FinSi o un Repetir que no se

corresponde con un Mientras.

ERRORES POR PROCESOS NO VÁLIDOS

Cada lenguaje tiene sus particularidades o formas de concepción. Cualquier sintaxis aparentemente correcta pero que infrinja

las normas de construcción de programas que define el lenguaje dará lugar a un error. Las posibilidades son muy variadas. Por

citar algunas habituales señalaremos:

· Indeterminaciones matemáticas (p. ej. SQR(a) con a < 0).

· Asignar un valor a la variable que no coincide con el tipo declarado para la variable.

· Uso de variables no declaradas.

· Modificaciones no permitidas del número de localizadores de un array dinámico.

· Llamadas a módulos que no existen.

· No pasar los parámetros o pasar un número incorrecto de parámetros a un módulo genérico.

· Tratar de extraer datos o usar ficheros que no se encuentran.

Los procesos no válidos pueden deberse al programa o a circunstancias ajenas al programa, como que el usuario no introduzca

el dato esperado, que un señalero no esté donde tiene que estar, que los datos no estén ordenados como tenían que estarlo,

que un archivo no contenga la cantidad de datos que se espera o que un dato o fichero no esté donde se espera. Suelen ser

errores que se pueden detectar y gestionar. Su localización se ve facilitada por las herramientas de corrección o depuración del

lenguaje que utilicemos, como los ya comentados “paso a paso”.

ERRORES LÓGICOS
Son todos aquellos derivados de un mal diseño de los algoritmos o la arquitectura modular. Las posibilidades son muchas y los

efectos posibles también. Pueden ir desde el bloqueo o detención indeseada del programa hasta un resultado incorrecto, una

parte del programa que no se ejecuta, etc.

Los errores lógicos que afectan al desarrollo del programa son más fáciles de detectar que aquellos que no generan

aparentemente problemas. A su vez, de entre los que aparentan no suponer problema, los que generan muy pequeñas

disfunciones o desviaciones del resultado resultan más difíciles de detectar que los que dan lugar a resultados ostensiblemente

desviados de lo esperado.

Los errores lógicos son quizás los que más grandes quebraderos de cabeza originan a los programadores, los más difíciles de

evitar y los más difíciles de detectar. Un programa lleno de errores de sintaxis pero de lógica exquisita es una bendición

comparado con un programa lleno de errores de lógica pero de perfecta sintaxis.

Evitar errores lógicos no pasa ya por conocer bien el lenguaje y las formas de construcción del lenguaje. Pasa por ser un buen

programador, un buen pensador. Y eso es difícil de enseñar o de aprender. Partamos de estrategias y métodos que se saben

eficientes y dejemos a la experiencia realizar el resto.

Vamos a dividir los errores lógicos en dos tipos.

1. Errores lógicos tipo bucle infinito: son aquellos que dan lugar a una parada o bloqueo del programa. Incluiremos aquí

procesos en realidad no infinitos pero que consumen un tiempo desmedido respecto a lo esperado.

2. Errores lógicos tipo resultado incorrecto: no bloquean el flujo del programa pero dan lugar a un resultado desviado. El

grado de desviación escaso puede dificultar su detección y corrección. El ordenador no puede saber que existe un error pues

sólo el programador que idea el proceso puede decir si éste es correcto o no.

Hasta aquí lo que hemos llamado cuatro tipos básicos de errores. Cuando existe un procedimiento a seguir previsto ante la

presencia de uno de estos errores decimos que se trata de un error gestionado. Ser gestionado es un atributo del error que

cambia sus propiedades. La naturaleza sigue siendo la misma pero los efectos no, al ser “controlados” o “encauzados”. Lo ideal

es que todos los errores posibles sean gestionados, pero esto no garantiza calidad ni buen funcionamiento del programa.

Únicamente asegura que el programador y/o usuario mantienen un cierto control del flujo del programa con el fin de poder

obtener resultados parciales, reorientar procesos o poder proceder a una salida controlada.

En la gestión del error normalmente interviene el propio programa. Cuando se produce el error, éste es detectado y se procede

a su gestión. Por tanto un error lógico tipo resultado incorrecto no puede ser gestionado por esta vía (a la que llamaremos

gestión vía detección) puesto que para el ordenador ese error no existe. La única posibilidad de gestionarlos es a su vez la vía

lógica a través de módulos de control de resultados, lo que según qué casos puede resultar muy complicado.
Errar es humano, a ensuciar realmente las cosas requiere de una computadora.” – Bill
Vaughan

“Un ordenador te permite cometer más errores más rápido que cualquier invención en la
historia de la humanidad -. Con la posible excepción de las pistolas y tequila” – Mitch
Ratcliffe

Los errores de programación, más comúnmente conocidas como ‘Bugs’ en la jerga

informática, son la pesadilla de cualquier desarrollador de software. Puesto que las máquinas
son cada vez más utilizado en modo automático, con sistemas integrados de a bordo o los
ordenadores que controlan su funcionamiento, un error de programación puede tener
consecuencias drásticas. Se han dado casos de naves espaciales y aviones que se estrellan
debido a los errores de software en los equipos de computación empotrados. Un vacío legal
dejado sola en el código del sistema operativo puede proporcionar un punto de entrada para
los hackers, que pueden explotar la vulnerabilidad, poniendo en riesgo la seguridad
informática. Ergo, los errores de programación deben ser tomadas muy en serio a medida
que cada vez dependen de los ordenadores. En este artículo se Buzzle proporciona una lista
de los tipos más comunes de errores de programación que un programador puede venir a
través.

Tipos principales de errores de programación

La programación de computadoras es un vasto campo, con cientos de idiomas que se

dominan y millones de aplicaciones. Desde básica del sistema operativo de programación de
aplicaciones de programación, la codificación del sistema integrado, desarrollo web,
aplicaciones móviles de la plataforma, el desarrollo de programas de software desplegado en
línea para la computación científica, la extensión del campo es simplemente enorme. Así es
la posibilidad de cometer errores de programación de diversos tipos! Éstos son los principales
tipos de errores de programación que todo desarrollador debe tener en cuenta.

Tipo de error de programación

Descripción

La lógica de error

Este es quizás el más grave de todos los errores. Cuando un programa escrito en cualquier
lenguaje compila y se ejecuta correctamente sólo para proporcionar una salida incorrecta, la
falla se encuentra en la lógica de programación subyacente. Es un error que se ha heredado
de una falla en el algoritmo de base. La lógica misma sobre la que se basa la totalidad del
programa es defectuoso, en ese caso. Estos tipos de errores necesita un cambio fundamental
en su enfoque para encontrar una solución. Usted necesita comenzar a excavar en el nivel
algorítmico para reducir a la causa de tal error.
Error de sintaxis

Cada lenguaje de programación como C, Java, Perl y Python tiene una sintaxis específica en
la que el código debe ser escrito. Cuando un programador no se adhiere a la “gramática” de
las especificaciones de un lenguaje de computadora, aparece un error de sintaxis. Este tipo
de errores son fáciles de rectificar durante la fase de compilación.

Error de compilación

La compilación es el proceso donde se convierte en un programa escrito en un lenguaje de

alto nivel de forma legible por máquina. Existen muchos tipos de errores pueden ocurrir
durante esta fase, incluyendo errores de sintaxis. A veces, la sintaxis de un código fuente
puede ser impecable, pero un error de compilación puede ocurrir todavía. Esto puede ser
debido a un problema en el propio compilador. Estos errores son subsanables en la fase de
desarrollo.

Error en tiempo

El código del programa se ha compilado con éxito y un archivo ejecutable se ha creado. Se

respira un suspiro de alivio y ejecutar el programa para probar su funcionamiento para
encontrar un error. Se trata de un “error en tiempo de ejecución ‘. Estos pueden resultar de
la falta por parte del desarrollador para anticipar las condiciones reales de implementación
del programa. Estos pueden ser rectificada por la que se remonta a la fase de codificación.

Un error aritmético

Muchos programas utilizan las variables numéricas y el algoritmo puede incluir una serie de
cálculos matemáticos. Errores aritméticos surgir cuando el equipo no puede manejar los
problemas como “División por cero ‘que lleva a un resultado infinito. Esto es de nuevo un
error de lógica que sólo se puede corregir cambiando el algoritmo.

Errores de recursos

Cuando el valor de una variable desborda su valor máximo permitido, un error de recurso
puede resultar. Desbordamiento de búfer, el uso de una variable no inicializada, violaciónes
de acceso y los desbordamientos de pila, son ejemplos de algunos errores de programación
comunes.

Interfaz de error

Estas pueden surgir debido a la falta de coincidencia de un programa de software con la

interfaz de hardware o interfaz de programación de aplicación que se utiliza. En el caso de
las aplicaciones web, un error en la interfaz puede resultar de un uso incorrecto de un
protocolo de Internet.
Estos son los tipos de errores de programación que usted necesita para tener en cuenta. Una
fase intensiva de pruebas y la depuración es una parte esencial del ciclo de desarrollo de
software que pueden ayudar a evitar estos errores en el brote, antes de la implementación a
gran escala del programa de software. Una gran cantidad de errores se pueden evitar a
través de la planificación previa y la atención durante la fase de codificación. A través de la
práctica y la disciplina y los procedimientos de depuración siguientes rigurosos, la mayoría
de los errores de programación pueden ser corregidos durante el desarrollo de software.
Cometer errores es parte del aprendizaje y que nunca se pueden evitar por completo. Sin
embargo, me permito sugerir que usted se centra en la fabricación de nuevos errores y
evitar la repetición de los que hicieron antes!

Tipos de Errores
¿Qué tipos de errores existen en programación?
En un programa, pueden existir tres tipos de errores:

 De sintaxis (sintácticos).
 De ejecución.
 De lógica (lógicos).

A continuación, vamos a estudiarlos con ejemplos escritos en lenguaje C.

Errores de sintaxis
Cuando en alguna instrucción del código fuente de un programa existe un error de sintaxis, dicho
error impedirá, tanto al compilador como al intérprete, traducir dicha instrucción, ya que, ninguno de
los dos entenderá qué le está diciendo el programador. Por ejemplo, en lenguaje C, si en vez de la
instrucción:

printf( "\n Introduzca el primer numero (entero): " );

un programador escribe:

prrintf( "\n Introduzca el primer numero (entero): " );

cuando el compilador o el intérprete lean esta línea de código, ninguno de los dos entenderá qué es
"prrintf" y, por tanto, no sabrán traducir esta instrucción a código máquina, por lo que, ambos
pararán la traducción y avisarán al programador con un mensaje de error.

En resumen, los errores de sintaxis se detectan en el proceso de traducción del código fuente a
código binario. Al contrario que ocurre con los errores de ejecución y de lógica, que sólo se pueden
detectar cuando el programa se está ejecutando.

Errores de ejecución
Un error de ejecución se produce cuando el ordenador no puede ejecutar alguna instrucción de
forma correcta. Por ejemplo, en lenguaje C, la instrucción:

c = 5 / 0;

es correcta sintácticamente y será traducida a código binario. Sin embargo, cuando la computadora
intente realizar la división:

5 / 0

se producirá un error de ejecución, ya que, matemáticamente, no se puede dividir entre cero.

Errores de lógica
En cuanto a los errores de lógica son los más difíciles de detectar. Cuando un programa no tiene
errores de sintaxis ni de ejecución, pero, aún así, no funciona bien, esto es debido a la existencia de
algún error lógico. De manera que, un error de lógica se produce cuando los resultados obtenidos
no son los esperados. Por ejemplo, en lenguaje C, si en vez de la instrucción:

c = a + b;

un programador hubiera escrito:

c = a * b;

hasta que no se mostrase por pantalla el resultado de la operación, el programador no podría darse
cuenta del error, siempre que ya supiese de antemano el resultado de la suma. En este caso, el
programdor podría percatarse del error fácilmente, pero, cuando las operaciones son más
complejas, los errores de lógica pueden ser muy difíciles de detectar.

9. Errores y excepciones
Hasta ahora los mensajes de error no habían sido más que mencionados, pero si probaste los ejemplos
probablemente hayas visto algunos. Hay (al menos) dos tipos diferentes de errores: errores de
sintaxis y excepciones.

9.1. Errores de sintaxis

Los errores de sintaxis, también conocidos como errores de interpretación, son quizás el tipo de queja
más común que tenés cuando todavía estás aprendiendo Python:

>>> while True print('Hola mundo')

Traceback (most recent call last):
...
while True print('Hola mundo')
^
SyntaxError: invalid syntax

El intérprete repite la línea culpable y muestra una pequeña ‘flecha’ que apunta al primer lugar donde se
detectó el error. Este es causado por (o al menos detectado en) el símbolo que precede a la flecha: en el
ejemplo, el error se detecta en la función print(), ya que faltan dos puntos (':') antes del mismo. Se
muestran el nombre del archivo y el número de línea para que sepas dónde mirar en caso de que la
entrada venga de un programa.

9.2. Excepciones
Incluso si la declaración o expresión es sintácticamente correcta, puede generar un error cuando se
intenta ejecutarla. Los errores detectados durante la ejecución se llamanexcepciones, y no son
incondicionalmente fatales: pronto aprenderás cómo manejarlos en los programas en Python. Sin
embargo, la mayoría de las excepciones no son manejadas por los programas, y resultan en mensajes de
error como los mostrados aquí:

>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

La última línea de los mensajes de error indica qué sucedió. Las excepciones vienen de distintos tipos, y
el tipo se imprime como parte del mensaje: los tipos en el ejemplo
son:ZeroDivisionError, NameError y TypeError. La cadena mostrada como tipo de la
excepción es el nombre de la excepción predefinida que ocurrió. Esto es verdad para todas las
excepciones predefinidas del intérprete, pero no necesita ser verdad para excepciones definidas por el
usuario (aunque es una convención útil). Los nombres de las excepciones estándar son identificadores
incorporados al intérprete (no son palabras clave reservadas).

El resto de la línea provee un detalle basado en el tipo de la excepción y qué la causó.

La parte anterior del mensaje de error muestra el contexto donde la excepción sucedió, en la forma de
un trazado del error listando líneas fuente; sin embargo, no mostrará líneas leídas desde la entrada
estándar.

Excepciones integradas lista las excepciones predefinidas y sus significados.

9.3. Manejando excepciones

Es posible escribir programas que manejen determinadas excepciones. Mirá el siguiente ejemplo, que le
pide al usuario una entrada hasta que ingrese un entero válido, pero permite al usuario interrumpir el
programa (usando Control-C o lo que sea que el sistema operativo soporte); notá que una interrupción
generada por el usuario se señaliza generando la excepción KeyboardInterrupt.

>>> while True:

... try:
... x = int(input("Por favor ingrese un número: "))
... break
... except ValueError:
... print("Oops! No era válido. Intente nuevamente...")
...

La declaración try funciona de la siguiente manera:

 Primero, se ejecuta el bloque try (el código entre las declaración try y except).
 Si no ocurre ninguna excepción, el bloque except se saltea y termina la ejecución de la
declaración try.
 Si ocurre una excepción durante la ejecución del bloque try, el resto del bloque se saltea. Luego,
si su tipo coincide con la excepción nombrada luego de la palabra reservada except, se ejecuta
el bloque except, y la ejecución continúa luego de la declaración try.
 Si ocurre una excepción que no coincide con la excepción nombrada en el except, esta se
pasa a declaraciones try de más afuera; si no se encuentra nada que la maneje, es
una excepción no manejada, y la ejecución se frena con un mensaje como los mostrados arriba.

Una declaración try puede tener más de un except, para especificar manejadores para distintas
excepciones. A lo sumo un manejador será ejecutado. Sólo se manejan excepciones que ocurren en el
correspondiente try, no en otros manejadores del mismo try. Un except puede nombrar múltiples
excepciones usando paréntesis, por ejemplo:

... except (RuntimeError, TypeError, NameError):

... pass

El último except puede omitir nombrar qué excepción captura, para servir como comodín. Usá esto con
extremo cuidado, ya que de esta manera es fácil ocultar un error real de programación. También puede
usarse para mostrar un mensaje de error y luego re-generar la excepción (permitiéndole al que llama,
manejar también la excepción):

import sys

try:
f = open('miarchivo.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
print("Error OS: {0}".format(err))
except ValueError:
print("No pude convertir el dato a un entero.")
except:
print("Error inesperado:", sys.exc_info()[0])
raise

Las declaraciones try ... except tienen un bloque else opcional, el cual, cuando está presente, debe
seguir a los except. Es útil para aquel código que debe ejecutarse si el bloque try no genera una
excepción. Por ejemplo:

for arg in sys.argv[1:]:

try:
f = open(arg, 'r')
except IOError:
print('no pude abrir', arg)
else:
print(arg, 'tiene', len(f.readlines()), 'lineas')
f.close()

El uso de else es mejor que agregar código adicional en el try porque evita capturar accidentalmente
una excepción que no fue generada por el código que está protegido por la declaración try ... except.

Cuando ocurre una excepción, puede tener un valor asociado, también conocido como el argumento de la
excepción. La presencia y el tipo de argumento depende del tipo de excepción.

El except puede especificar una variable luego del nombre de excepción. La variable se vincula a una
instancia de excepción con los argumentos almacenados en instance.args. Por conveniencia, la instancia
de excepción define __str__() para que se pueda mostrar los argumentos directamente, sin
necesidad de hacer referencia a .args. También se puede instanciar la excepción primero, antes de
generarla, y agregarle los atributos que se desee:
>>> try:
... raise Exception('carne', 'huevos')
... except Exception as inst:
... print(type(inst)) # la instancia de excepción
... print(inst.args) # argumentos guardados en .args
... print(inst) # __str__ permite imprimir args directamente,
... # pero puede ser cambiado en subclases de la exc
... x, y = inst # desempacar argumentos
... print('x =', x)
... print('y =', y)
...
<class 'Exception'>
('carne', 'huevos')
('carne', 'huevos')
x = carne
y = huevos

Si una excepción tiene argumentos, estos se imprimen como la última parte (el ‘detalle’) del mensaje para
las excepciones que no están manejadas.

Los manejadores de excepciones no manejan solamente las excepciones que ocurren en el bloque try,
también manejan las excepciones que ocurren dentro de las funciones que se llaman (inclusive
indirectamente) dentro del bloque try. Por ejemplo:

>>> def esto_falla():

... x = 1/0
...
>>> try:
... esto_falla()
... except ZeroDivisionError as err:
... print('Manejando error en tiempo de ejecución:', err)
...
Manejando error en tiempo de ejecución: int division or modulo by zero

9.4. Levantando excepciones

La declaración raise permite al programador forzar a que ocurra una excepción específica. Por ejemplo:

>>> raise NameError('Hola')

Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: Hola

El único argumento a raise indica la excepción a generarse. Tiene que ser o una instancia de
excepción, o una clase de excepción (una clase que hereda de Exception).
Si necesitás determinar cuando una excepción fue lanzada pero no querés manejarla, una forma
simplificada de la instrucción raise te permite relanzarla:

>>> try:
... raise NameError('Hola')
... except NameError:
... print('Voló una excepción!')
... raise
...
Voló una excepción!
Traceback (most recent call last):
File "<stdin>", line 2, in ?
NameError: Hola

9.5. Excepciones definidas por el usuario

Los programas pueden nombrar sus propias excepciones creando una nueva clase excepción
(mirá Clases para más información sobre las clases de Python). Las excepciones, típicamente, deberán
derivar de la clase Exception, directa o indirectamente. Por ejemplo:

>>> class MiError(Exception):

... def __init__(self, valor):
... self.valor = valor
... def __str__(self):
... return repr(self.valor)
...
>>> try:
... raise MiError(2*2)
... except MyError as e:
... print('Ocurrió mi excepción, valor:', e.valor)
...
Ocurrió mi excepción, valor: 4
>>> raise MiError('oops!')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
__main__.MiError: 'oops!'

En este ejemplo, el método __init__() de Exception fue sobrescrito. El nuevo comportamiento

simplemente crea el atributo valor. Esto reemplaza el comportamiento por defecto de crear el
atributo args.

Las clases de Excepciones pueden ser definidas de la misma forma que cualquier otra clase, pero
usualmente se mantienen simples, a menudo solo ofreciendo un número de atributos con información
sobre el error que leerán los manejadores de la excepción. Al crear un módulo que puede lanzar varios
errores distintos, una práctica común es crear una clase base para excepciones definidas en ese módulo
y extenderla para crear clases excepciones específicas para distintas condiciones de error:

class Error(Exception):
 """Clase base para excepciones en el módulo."""
pass

class EntradaError(Error):
"""Excepción lanzada por errores en las entradas.

Atributos:
expresion -- expresión de entrada en la que ocurre el error
mensaje -- explicación del error
"""

def __init__(self, expresion, mensaje):

self.expresion = expresion
self.mensaje = mensaje

class TransicionError(Error):
"""Lanzada cuando una operacion intenta una transicion de estado no
permitida.

Atributos:
previo -- estado al principio de la transición
siguiente -- nuevo estado intentado
mensaje -- explicación de por qué la transición no está permitida
"""
def __init__(self, previo, siguiente, mensaje):
self.previo = previo
self.siguiente = siguiente
self.mensaje = mensaje

La mayoría de las excepciones son definidas con nombres que terminan en “Error”, similares a los
nombres de las excepciones estándar.

Muchos módulos estándar definen sus propias excepciones para reportar errores que pueden ocurrir en
funciones propias. Se puede encontrar más información sobre clases en el capítulo Clases.

9.6. Definiendo acciones de limpieza

La declaración try tiene otra cláusula opcional que intenta definir acciones de limpieza que deben ser
ejecutadas bajo ciertas circunstancias. Por ejemplo:

>>> try:
... raise KeyboardInterrupt
... finally:
... print('Chau, mundo!')
...
Chau, mundo!
KeyboardInterrupt
Traceback (most recent call last):
File "<stdin>", line 2, in ?

Una cláusula finally siempre es ejecutada antes de salir de la declaración try, ya sea que una excepción
haya ocurrido o no. Cuando ocurre una excepción en la cláusula try y no fue manejada por una
cláusula except (o ocurrió en una cláusula except o else), es relanzada luego de que se ejecuta la
cláusula finally. El finally es también ejecutado “a la salida” cuando cualquier otra cláusula de la
declaración try es dejada via break, continue or return. Un ejemplo más complicado:

>>> def dividir(x, y):

... try:
... result = x / y
... except ZeroDivisionError:
... print("¡división por cero!")
... else:
... print("el resultado es", result)
... finally:
... print("ejecutando la clausula finally")
...
>>> dividir(2, 1)
el resultado es 2.0
ejecutando la clausula finally
>>> dividir(2, 0)
¡división por cero!
ejecutando la clausula finally
>>> divide("2", "1")
ejecutando la clausula finally
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

Como podés ver, la cláusula finally es ejecutada siempre. La excepción TypeError lanzada al
dividir dos cadenas de texto no es manejado por la cláusula except y por lo tanto es relanzada luego de
que se ejecuta la cláusula finally.

En aplicaciones reales, la cláusula finally es útil para liberar recursos externos (como archivos o
conexiones de red), sin importar si el uso del recurso fue exitoso.

9.7. Acciones predefinidas de limpieza

Algunos objetos definen acciones de limpieza estándar que llevar a cabo cuando el objeto no es más
necesitado, independientemente de que las operaciones sobre el objeto hayan sido exitosas o no. Mirá el
siguiente ejemplo, que intenta abrir un archivo e imprimir su contenido en la pantalla.:

for linea in open("miarchivo.txt"):

 print(linea, end="")

El problema con este código es que deja el archivo abierto por un periodo de tiempo indeterminado luego
de que esta parte termine de ejecutarse. Esto no es un problema en scripts simples, pero puede ser un
problema en aplicaciones más grandes. La declaración with permite que objetos como archivos sean
usados de una forma que asegure que siempre se los libera rápido y en forma correcta.:

with open("miarchivo.txt") as f:
for linea in f:
print(linea, end="")

Luego de que la declaración sea ejecutada, el archivo f siempre es cerrado, incluso si se encuentra un
problema al procesar las líneas. Objetos que, como los archivos, provean acciones de limpieza
predefinidas lo indicarán en su documentación.

Errores de Sintaxis en Lenguaje C

¿Qué es un error de sitanxis en C?
Los errores de sintaxis son los más fáciles de detectar en el código fuente de un programa. Un error
de sintaxis se produce al escribir, incorrectamente, alguna parte del código.

Ejemplo: Estúdiese el siguiente código fuente de un programa escrito en lenguaje C:

include <stdio.h>

imt main()
{
int a, b;
a = 4;
b = a * 6;

printf( "%d", b )
retunr 0;
}

Existen cuatro errores de sintaxis:

 Se ha escrito include en vez de #include.

 Se ha escrito imt en vez de int.
 Falta un punto y coma (;) después de la llamada a printf.
 Se ha escrito retunr en vez de return.

¿Qué es un error de ejecución en C?

Una vez corregidos los errores de sintaxis en el código fuente de un programa, se debe revisar que
no se puede producir ningún error en la ejecución del mismo. Un error de ejecución se produce
cuando el ordenador no puede ejecutar alguna instrucción de forma correcta.

Ejemplo: En el programa:
#include <stdio.h>

int main()
{
int a;
float b;
 a = 0;

b = 6.4 / a;

printf( "%f", b );

return 0;
}

se produce un error de ejecución, ya que, al intentar evaluar la expresión:

6.4 / a

a vale 0, y no se puede dividir entre cero.

Errores de Lógica en Lenguaje C

¿Qué es un error de lógica en un programa escrito en C?

Los errores de lógica son los más difíciles de detectar. Cuando un programa no tiene errores de
sintaxis ni de ejecución, pero, aún así, no funciona bien, esto es debido a la existencia de algún
error lógico. De manera que, un error de lógica se produce cuando los resultados obtenidos no son
los esperados.

Ejemplo: Estúdiese el siguiente código:

#include <stdio.h>

int main()

{
float base, altura;

base = 6.3;

altura = 4.;

printf( "El area es: %f", base * altura / 3 );

return 0;

Su salida por pantalla es:

El area es: 8.4

No existen errores de sintaxis ni de ejecución, sin embargo, la salida esperada es:

El area es: 12.6

Por consiguiente, existe algún error lógico que hay que corregir. El error está en la expresión:

base * altura / 3

que, aunque no es incorrecta, no sirve para calcular el área de un triángulo. En su lugar se debe
escribir:

base * altura / 2

Errores de programación comunes[editar]

 División por cero
 Ciclo infinito
 Problemas aritméticos como desbordamientos (overflow) o subdesbordamientos (underflow).
 Exceder el tamaño del array
 Utilizar una variable no inicializada
 Acceder a memoria no permitida (Violación de acceso)
 Pérdida de memoria (memory leak)
 Desbordamiento o subdesbordamiento de la pila (estructura de datos)
 Desbordamiento de búfer (buffer overflow)
 Bloqueo mutuo (deadlock)
 Indizado inadecuado de tablas en bases de datos.
 Desbordamiento de la pila de recursión, cuando se dejan demasiadas llamadas en espera.

Defectos de instalación o programación[editar]

 Eliminación o sustitución de bibliotecas comunes a más de un programa o del sistema (DLC Hell).
 Reiniciar arbitrariamente la sesión de un usuario para que la instalación tenga efecto.
 Suponer que el usuario tiene una conexión permanente a internet.
 Utilizar como fuente enlaces simbólicos a ficheros que pueden cambiar de ubicación.

Códigos de errores de lenguajes de

programación[editar]
La mayor parte de los lenguajes de programación presentan al menos dos tipos de errores que permiten a
los programadores manejar las fallas de los programas de una manera eficiente y que no resulte agresiva
con el usuario final. Dichos errores son de compilación y errores en tiempo de ejecución.

Los errores de compilación normalmente inhiben que el código fuente derive en un programa ejecutable,
mientras que los errores en tiempo de ejecución son situaciones específicas en las que un evento externo
al programa impide su ejecución. Regularmente un programador eficiente debe intentar imaginar como
debe responder ante esos eventos de manera que sea el programa y no el usuario o el sistema operativo
los que resuelvan el problema. Así por ejemplo un bloque de error no manejado podría hacer lo siguiente:

Abre el archivo "miarchivo" para escritura

comienza a escribir datos en mi archivo
cierra el archivo

Si "miarchivo" no existe (o el programa o el usuario no tienen privilegios suficientes para abrirlo), el

sistema operativo regresará un error que el programa no atrapará y tendremos un mensaje como "El
archivo "miarchivo" no puede ser abierto para escritura" y botones para reintentar, cancelar y abortar (en
el sistema operativo Windows), que no tendrán otra acción que repetirse indefinidamente sin posibilidad
de salir de ese ciclo como no sea dando por terminado violentamente el programa. Un código que
permitiese atrapar el error en tiempo de ejecución sería:

Abre el archivo "miarchivo" para escritura

Si el sistema operativo lo permite
 comienza a escribir datos en "miarchivo"
si no lo permitió
informa al usuario de lo que sucede
regresa al usuario a un punto donde no haya conflicto (el menú principal, por
ejemplo)
Continúa operando normalmente

Los diferentes lenguajes de programación permiten diferentes construcciones lógicas a los

programadores para atrapar y resolver errores en tiempo de ejecución, como pueden ser
las sentencias assert, try y on error en diferentes lenguajes de programació