Errores de Excepción Comunes

• BaseException: Clase base para todas las excepciones en Python. Es la raíz del sistema jerárquico de excepciones.
• Exception: Clase base para las excepciones estándar, utilizada para capturar errores en programas normales.

Errores Relacionados con Argumentos o Tipos

• TypeError: Error generado cuando una operación o función se aplica a un objeto del tipo inapropiado.
• ValueError: Error lanzado cuando una función recibe un argumento del tipo correcto pero con un valor inapropiado.
• KeyError: Error lanzado al intentar acceder a una clave inexistente en un diccionario.
• IndexError: Error que ocurre al intentar acceder a un índice fuera de rango en una lista, tupla, etc.
• AttributeError: Error generado cuando se intenta acceder a un atributo inexistente de un objeto.
• NameError: Error que ocurre cuando se utiliza una variable no definida en el espacio de nombres.
• UnboundLocalError: Subclase de NameError. Aparece cuando una variable local se utiliza antes de ser asignada.

Errores Matemáticos

• ArithmeticError: Clase base para errores en operaciones aritméticas.
• ZeroDivisionError: Error al intentar dividir por cero.
• OverflowError: Error cuando un cálculo produce un número demasiado grande para ser representado.
• FloatingPointError: Error relacionado con operaciones en punto flotante.

Errores de Entrada/Salida

• IOError: Error general de entrada/salida (obsoleto, ahora se utiliza OSError).
• OSError: Error relacionado con operaciones del sistema operativo (lectura/escritura de archivos, etc.).
• FileNotFoundError: Error lanzado cuando no se encuentra un archivo o directorio.
• PermissionError: Error que ocurre al intentar realizar una operación sin los permisos necesarios.
• IsADirectoryError: Error al tratar de operar en un directorio como si fuera un archivo.
• NotADirectoryError: Error al tratar de operar en un archivo como si fuera un directorio.
• EOFError: Error lanzado cuando una función de entrada llega al final del archivo sin datos adicionales.

Errores de Memoria

• MemoryError: Error que ocurre cuando el sistema no tiene memoria suficiente para completar una operación.
• RecursionError: Error lanzado cuando se supera el límite de recursión.

Errores de Importación

• ImportError: Error que ocurre al intentar importar un módulo que no existe.
• ModuleNotFoundError: Subclase de ImportError. Aparece específicamente cuando no se encuentra un módulo.

Errores de Codificación y Descodificación

• UnicodeError: Clase base para errores relacionados con codificación y descodificación de Unicode.
• UnicodeEncodeError: Error al codificar datos en Unicode.
• UnicodeDecodeError: Error al descodificar datos en Unicode.
• UnicodeTranslateError: Error al traducir datos en Unicode.

Errores de Concurrencia

• BlockingIOError: Error que ocurre cuando una operación de E/S bloqueante es interrumpida.
• TimeoutError: Error generado cuando expira el tiempo de espera de una operación.

Errores Personalizables

• RuntimeError: Error general que no cae bajo otras categorías específicas.
• NotImplementedError: Error utilizado para indicar que un método o función no ha sido implementado.

Errores de Clases y Herencia

• LookupError: Clase base para errores relacionados con búsquedas de índices o claves.
• AssertionError: Error que ocurre cuando una declaración assert falla.
• SystemError: Error que indica un problema interno en el intérprete de Python.

Errores de Sistema y Procesos

• KeyboardInterrupt: Error lanzado cuando se presiona Ctrl+C durante la ejecución de un programa.
• SystemExit: Excepción lanzada para solicitar la finalización de un programa.
• StopIteration: Error lanzado para señalar el final de un iterador.
• StopAsyncIteration: Error lanzado para detener iteradores asíncronos.

Estructura Básica

La estructura básica de un bloque try...except es la siguiente:

                      
                        try:
                            # Código que puede generar una excepción
                            operación_potencialmente_riesgosa()
                        except TipoDeExcepción:
                            # Código que se ejecuta si ocurre una excepción del tipo especificado
                            manejar_la_excepción()
                      
                    

• try: En este bloque se coloca el código que podría generar un error. Python intentará ejecutarlo.
• except: Aquí se especifica qué hacer si se produce una excepción. Se puede manejar un tipo específico de excepción o cualquier excepción.

Tipos de Manejo de Excepciones

• Capturar una excepción específica: Es posible manejar un tipo de excepción específico, como ValueError, ZeroDivisionError, o cualquier otra.

                          
                            try:
                                x = int(input("Introduce un número: "))
                                resultado = 10 / x
                            except ValueError:
                                print("Se debe ingresar un número válido.")
                            except ZeroDivisionError:
                                print("No se puede dividir entre cero.")
                          
                        

• Capturar múltiples excepciones: Si varias excepciones deben manejarse de la misma manera, se pueden agrupar usando una tupla.

                          
                            try:
                                x = int(input("Introduce un número: "))
                                resultado = 10 / x
                            except (ValueError, ZeroDivisionError):
                                print("Ocurrió un error: número inválido o división entre cero.")
                          
                        

• Capturar cualquier excepción: Utilizando un except sin especificar el tipo, se capturan todas las excepciones.

                          
                            try:
                                x = int(input("Introduce un número: "))
                                resultado = 10 / x
                            except:
                                print("Ocurrió un error inesperado.")
                          
                        

  Nota: Capturar todas las excepciones no es recomendable porque puede ocultar errores importantes que deberían ser corregidos.
• Obtener detalles de la excepción: La excepción puede ser capturada en una variable para acceder a información detallada.

                          
                            try:
                                x = int(input("Introduce un número: "))
                                resultado = 10 / x
                            except Exception as e:
                                print(f"Ocurrió un error: {e}")
                          
                        

• Excepciones generadas en una Función: Si una excepción es generada dentro de una función, puede ser manejada:

Bloques else y finally

• else: Este bloque se ejecuta si no se genera ninguna excepción dentro del bloque try:

                            
                              try:
                                  x = int(input("Introduce un número: "))
                                  resultado = 10 / x
                              except ZeroDivisionError:
                                  print("No se puede dividir entre cero.")
                              else:
                                  print(f"El resultado es {resultado}")
                            
                          

• finally: Este bloque siempre se ejecuta, ya sea que ocurra o no una excepción. Se utiliza para realizar limpieza de recursos, como cerrar archivos o conexiones.

                            
                              try:
                                  archivo = open("datos.txt", "r")
                                  contenido = archivo.read()
                              except FileNotFoundError:
                                  print("El archivo no existe.")
                              finally:
                                  print("Cerrando el archivo.")
                                  archivo.close()
                            
                          

Importancia del manejo de excepciones

• Evita interrupciones inesperadas: Un programa bien diseñado no debería cerrarse abruptamente debido a errores no manejados.
• Facilita la depuración: Proporciona información específica sobre los errores.
• Mejora la experiencia del usuario: Ofrece mensajes claros y opciones en lugar de mostrar rastros de errores confusos.

Ejemplo Práctico Completo

Supongamos que se desea leer números de un archivo y calcular el recíproco de cada uno:

                    
                      try:
                          with open("numeros.txt", "r") as archivo:
                              for linea in archivo:
                                  numero = int(linea.strip())
                                  print(f"El recíproco de {numero} es {1/numero}")
                      except FileNotFoundError:
                          print("El archivo no fue encontrado.")
                      except ValueError:
                          print("El archivo contiene datos no válidos.")
                      except ZeroDivisionError:
                          print("Uno de los números es cero, no se puede dividir.")
                      finally:
                          print("Proceso completado.")
                    
                  

Uso de Declaraciones print()

Agregar declaraciones print() estratégicamente en el código ayuda a inspeccionar el flujo de ejecución y los valores de las variables.

Ventajas:

• Fácil de usar.
• No requiere herramientas externas.

                      
                        def suma(a, b):
                            print(f"Valores recibidos: a={a}, b={b}")  # Depuración
                            return a + b
                        resultado = suma(5, '3')  # Error intencional para identificar
                        print(f"Resultado: {resultado}")
                      
                    

Uso de un Depurador (Debugger)

Un depurador permite inspeccionar el estado del programa línea por línea, verificar valores de variables y entender mejor el flujo del programa.

• Módulo pdb (Python Debugger): Python incluye un depurador integrado llamado pdb.
  Uso básico:
  
  • Insertar import pdb; pdb.set_trace() en el punto donde se desea iniciar la depuración.
  • Ejecutar el programa y usar comandos de pdb.
  Ejemplo:

                          
                            import pdb
                            def suma(a, b):
                                pdb.set_trace()  # Pausa la ejecución para depuración
                                return a + b
                            resultado = suma(5, 3)
                            print(f"Resultado: {resultado}")
                          
                        

  Comandos útiles de pdb:
  • n: Ejecuta la siguiente línea.
  • c: Continúa hasta el siguiente punto de interrupción.
  • l: Muestra las líneas de código actuales.
  • p <variable> : Imprime el valor de una variable.
  • q: Salir del depurador.
• Depuración en IDEs: La mayoría de los entornos de desarrollo integrados (IDEs) como PyCharm, Visual Studio Code y Thonny tienen depuradores visuales. Estos permiten:
  • Establecer puntos de interrupción (breakpoints).
  • Inspeccionar valores de variables en tiempo real.
  • Paso a paso por el código (step over, step into, step out).

Registro de Eventos (Logging)

El módulo logging permite registrar información sobre la ejecución del programa en un archivo o en la consola, lo que facilita la depuración.

                    
                      import logging
                      logging.basicConfig(level=logging.DEBUG)
                      def suma(a, b):
                          logging.debug(f"Valores recibidos: a={a}, b={b}")
                          return a + b
                      resultado = suma(5, 3)
                      print(f"Resultado: {resultado}")
                    
                  

Análisis Estático del Código

Herramientas como flake8, pylint y mypy ayudan a encontrar errores comunes y verificar la tipificación estática.

Ejemplo con flake8: Ejecutar en la terminal:

                    
                      flake8 mi_codigo.py
                    
                  

Depuración de Memoria y Rendimiento

Para problemas de memoria o rendimiento, se pueden usar herramientas como:

• cProfile: Para analizar el tiempo de ejecución.
• memory_profiler: Para monitorear el uso de memoria.

Ejemplo con cProfile:

                    
                      python -m cProfile mi_codigo.py