La depuración es una habilidad esencial en el desarrollo de software. Python ofrece múltiples herramientas integradas para identificar y resolver errores de manera eficiente. Este artículo explora técnicas clave para la depuración, desde el manejo de excepciones hasta el uso de depuradores interactivos.

1. Generación Controlada de Excepciones con raise

La sentencia raise permite al programador interrumpir la ejecución de forma intencional cuando se detecta un estado inválido. Esto es útil para validar supuestos o condiciones críticas dentro del código.

# Ejemplo de validación con raise
def sumar_numeros(valor_a, valor_b):
    if not isinstance(valor_a, (int, float)) or not isinstance(valor_b, (int, float)):
        raise TypeError("Ambos argumentos deben ser numéricos.")
    return valor_a + valor_b

# Uso con manejo de excepción
try:
    resultado = sumar_numeros("5", 10)
except TypeError as error:
    print(f"Error capturado: {error}")

Las excepciones pueden encadenarse para transofrmar un error en otro más específico, manteniendo el contexto del error original.

def acceder_atributo(objeto, clave):
    try:
        return objeto[clave]
    except KeyError:
        raise AttributeError(f"El objeto de tipo '{type(objeto).__name__}' no posee el atributo '{clave}'.")

2. Inspección de la Traza de Errores (Traceback)

Cuando una excepción no es capturada, Python genera una traza (traceback) detallada. Esta ifnormación es vital para seguir el flujo de ejecución que condujo al error.

def funcion_a():
    funcion_b()

def funcion_b():
    raise RuntimeError("Fallo simulado en función B.")

# Ejecución que producirá la traza
funcion_a()

Para registrar la traza en un archivo o variable de forma programática, se puede utilizar el módulo traceback.

import traceback

try:
    funcion_a()
except RuntimeError:
    traza_completa = traceback.format_exc()
    # Guardar 'traza_completa' en un archivo de registro o mostrarla

3. Verificación de Supuestos con Aserciones (assert)

Las aserciones (assert) son chequeos de consistencia que deben ser siempre verdaedros durante el desarrollo. Su uso incorrecto revela bugs en la lógica del programador, no errores del usuario.

def procesar_senal(semaforo_actual):
    # Aserción: siempre debe haber un color rojo activo en un cruce.
    assert 'rojo' in semaforo_actual.values(), f"¡Peligro! Ningún semáforo en rojo: {semaforo_actual}"
    # ... lógica de cambio de estado

Las aserciones pueden desactivarse en producción mediante la ejecución del intérprete con la opción -O (optimización).

4. Registro de Eventos (Logging) con el Módulo logging

El registro sistemático (logging) es una alternativa superior a las sentencias print() para depurar y monitorear aplicaciones.

import logging

# Configuración básica para consola
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(levelname)s - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)

def calcular_factorial(numero):
    logging.debug(f"Iniciando cálculo del factorial de {numero}.")
    producto = 1
    for i in range(1, numero + 1):
        producto *= i
        logging.debug(f"i={i}, producto parcial={producto}")
    logging.info(f"Factorial de {numero} es {producto}.")
    return producto

resultado = calcular_factorial(5)

Niveles de Severidad

Los niveles permiten filtrar la cantidad de información registrada: DEBUG, INFO, WARNING, ERROR, CRITICAL. Se puede configurar el nivel mínimo deseado.

# Solo mostrar mensajes de nivel ERROR y superior
logging.basicConfig(level=logging.ERROR)

Para deshabilitar toda la salida de registro: logging.disable(logging.CRITICAL).

Para dirigir los registros a un archivo: logging.basicConfig(filename='app.log', ...).

5. Uso del Depurador Integrado (IDE)

Los entornos de desarrollo (IDEs) como PyCharm, VS Code o el propio IDLE incluyen depuradores gráficos con funcionalidades avanzadas:

• Puntos de Interrupción (Breakpoints): Marcar líneas de código donde la ejecución debe pausarse.
• Ejecución Paso a Paso: Avanzar línea por línea (Step Into, Step Over, Step Out).
• Inspección de Variables: Observar el valor de todas las variables en el ámbito actual en tiempo real.
• Evaluación de Expresiones: Evaluar código Python en el contexto actual durante la pausa.

Estas herramientas permiten analizar el flujo de datos y el estado del programa de manera interactiva y precisa.