100 Días de Código en Python — Día 13: Depuración — Cómo Encontrar y Corregir Errores

Los 10 consejos del curso de un vistazo#

🎯 Objetivo de aprendizaje#

• Formular con precisión qué debería pasar y qué pasa realmente.
• Identificar y poner a prueba las suposiciones.

📖 Explicación conceptual#

"Si el problema es confuso en tu cabeza, es casi imposible depurarlo." Antes de tocar el código, responde:

• ¿Qué debería hacer el programa?
• ¿Qué hace realmente?
• ¿Qué supongo que es cierto? ¿Lo es de verdad?

📝 Ejercicio original del curso: "Lo tienes" nunca aparece#

def my_function():
    for i in range(1, 20):
        if i == 20:
            print("Lo tienes")

my_function()

Descripción del problema (según el curso): el bucle recorre números desde el 1 y se espera que imprima "Lo tienes" cuando i llegue a 20, pero nunca lo hace. Suposición falsa: que i llega a 20. range(1, 20) va del 1 al 19, porque el límite superior no se incluye (Día 5). Comprobado: 20 in range(1, 20) es False. Corrección: range(1, 21).

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: describe en tres frases (qué debería pasar, qué pasa, cuál es la suposición) el problema de este código:

  nombres = ["Ana", "Luis", "Sara"]
  for i in range(1, len(nombres)):
      print(nombres[i])

• 🟡 Reto 2: escribe una "plantilla de reporte de bug" con los campos que usarías para describir cualquier problema.
• 🟠 Reto 3: usa tu plantilla para describir un bug real que hayas tenido en un proyecto anterior.
• 🔴 Reto 4: busca un reporte de error (issue) en un proyecto de código abierto en GitHub. ¿Qué información incluye? ¿Qué le falta según tu plantilla?

🎯 Objetivo de aprendizaje#

• Convertir un error intermitente (a veces sí, a veces no) en uno reproducible (siempre).

📖 Explicación conceptual#

Los bugs que aparecen solo a veces son los más difíciles: pruebas dos veces, todo sale bien… y en la tercera falla. El truco es encontrar exactamente cuándo falla y forzar esa situación.

📝 Ejercicio original del curso: el dado que a veces falla#

from random import randint
dice_images = ["❶", "❷", "❸", "❹", "❺", "❻"]
dice_num = randint(1, 6)
print(dice_images[dice_num])

Estrategia del curso:

1. Revisar la documentación: randint(1, 6) incluye el 1 y el 6.
2. Fijar el valor para probar: dice_num = 1, luego 2, 3… y 6.
3. Con dice_num = 6 siempre aparece IndexError: list index out of range. ¡Bug reproducido!
4. Causa: los índices van de 0 a 5. Corrección: randint(0, 5).

Recordatorio del Día 4: random.choice(dice_images) evita este problema por completo.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: este programa falla "de vez en cuando". Reprodúcelo fijando el valor aleatorio y corrígelo:

  import random
  meses = ["ene", "feb", "mar", "abr", "may", "jun", "jul", "ago", "sep", "oct", "nov", "dic"]
  print(meses[random.randint(1, 12)])

• 🟡 Reto 2: investiga random.seed(n) y úsalo para que una secuencia aleatoria se repita siempre igual. ¿Cómo ayuda eso a reproducir un bug?
• 🟠 Reto 3: un programa falla solo cuando el usuario escribe su nombre con tilde. ¿Cómo lo reproducirías y qué datos de prueba usarías?
• 🔴 Reto 4: diseña una tabla de datos de prueba límite (vacío, 0, negativo, máximo, con espacios, con mayúsculas) para la Calculadora del Día 10. ¿Cuáles reproducen un error?

🎯 Objetivo de aprendizaje#

• Ejecutar el código "a mano", línea por línea, evaluando cada condición.

📝 Ejercicio original del curso: ¿Millennial o Generación Z?#

year = int(input("¿En qué año naciste? "))
if year > 1980 and year < 1994:
    print("Eres millennial.")
elif year > 1994:
    print("Eres de la Generación Z.")

Síntoma: con 1994 no imprime nada (verificado).

Jugando a ser el computador (como el curso):

Corrección: que un extremo incluya el 1994, con <= o con >=, según la clasificación que se quiera usar.

🛠️ Nota: los rangos de años de cada "generación" varían según la fuente (el propio curso aclara que dependen del país). Por ejemplo, el Pew Research Center considera millennials a los nacidos entre 1981 y 1996. Para la programación lo importante es que no queden años sin cubrir.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: juega a ser el computador con año = 1980. ¿Qué pasa? ¿Hay otro "hueco"?
• 🟡 Reto 2: reescribe el programa para que cubra todos los años, con un else final.
• 🟠 Reto 3: haz la tabla de seguimiento "a mano" de la escala de desempeño del Día 3 para las notas 2.99, 3.0, 3.95, 4.0 y 4.6.
• 🔴 Reto 4: juega a ser el computador con este código antes de ejecutarlo y predice la salida exacta. Luego verifica.

  x = 5
  for i in range(3):
      if x % 2 == 0:
          x = x // 2
      else:
          x = x * 3 + 1
      print(i, x)

🎯 Objetivo de aprendizaje#

• Atender los errores del editor (subrayados) y de la consola (al ejecutar).
• Buscar un error en internet quitando las partes específicas de tu código.
• Usar try/except para que el programa no se detenga ante entradas inválidas.
• Reconocer los bugs sin mensaje de error.

📖 Explicación conceptual#

Tres tipos de errores que muestra el curso:

Buscar el error en internet (técnica del curso): copia solo la parte genérica del mensaje (ValueError: invalid literal for int() with base 10), sin los datos propios de tu programa ('Twelve'), y agrega "Python".

Primer contacto con try/except. El curso lo presenta aquí por primera vez:

try:
    age = int(input("¿Cuántos años tienes? "))
except ValueError:
    print("Escribiste un número inválido. Intenta con un número como 15.")
    age = int(input("¿Cuántos años tienes? "))

• try: "intenta esta línea potencialmente peligrosa".
• except ValueError: "si ocurre este error, en lugar de detener el programa, haz esto otro".

🛠️ Nota técnica: en la solución del curso, la segunda pregunta está dentro del except, sin protección. Si el usuario vuelve a escribir un texto, el programa se detiene con ValueError. La solución robusta combina while y try/except, y se trabaja en el proyecto integrador:

123456

while True:
    try:
        age = int(input("¿Cuántos años tienes? "))
        break
    except ValueError:
        print("Escribe un número, por ejemplo 15.")

(break sale del bucle; investígalo en la documentación.)

Los bugs más frustrantes no generan errores: "nadie te ayuda en esto". Ahí cuenta la experiencia. El curso anima a ayudar a otros en foros para practicar resolviendo bugs ajenos.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: provoca a propósito un ValueError, un TypeError, un IndexError, un KeyError y un NameError. Escribe para cada uno la parte "buscable" del mensaje.
• 🟡 Reto 2: protege con try/except la conversión de la oferta en la Subasta Secreta (Día 9).
• 🟠 Reto 3: en la Calculadora (Día 10), atrapa ZeroDivisionError y KeyError con dos bloques except distintos, cada uno con su mensaje.
• 🔴 Reto 4: escribe tres bugs de lógica, sin mensaje de error, en un programa corto y dáselo a un compañero para que los encuentre.

📖 Explicación conceptual#

Cuando el resultado es incorrecto, imprime los valores intermedios para ver dónde se desvían de lo esperado.

📝 Ejercicio original del curso: palabras en un libro#

pages = 0
word_per_page = 0
pages = int(input("Número de páginas: "))
word_per_page == int(input("Número de palabras por página: "))
total_words = pages * word_per_page
print(total_words)

Síntoma: con 45 páginas y 250 palabras por página, el resultado es 0. Técnica del curso: agregar print(f"pages = {pages}") y print(f"word_per_page = {word_per_page}"). Resultado: pages = 45, pero word_per_page = 0. Causa: == compara en lugar de asignar. La comparación da False y la variable no cambia (verificado). Corrección: usar =. El resultado correcto es 11 250.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: encuentra con print por qué esta función siempre devuelve 1:

  def contar_vocales(texto):
      contador = 0
      for letra in texto:
          if letra in "aeiou":
              contador = 1
      return contador

• 🟡 Reto 2: agrega print dentro del while de tu juego Adivina el Número para mostrar turns en cada vuelta.
• 🟠 Reto 3: crea una bandera DEBUG = True (una constante, Día 12) y haz que los print de depuración solo aparezcan si DEBUG es True. Así los desactivas cambiando una sola línea.
• 🔴 Reto 4: investiga el módulo logging de Python. ¿Qué ventajas tiene frente a print en un programa grande?

🎯 Objetivo de aprendizaje#

• Usar puntos de interrupción (breakpoints) y los botones de avance paso a paso.
• Observar las variables mientras el programa se ejecuta.

📖 Explicación conceptual#

Ya usamos Python Tutor (se abre en otra pestaña) y el depurador de Thonny. El de PyCharm (y el de la mayoría de editores) funciona de forma parecida:

El curso lo resume así: el depurador es "como poner un print en todas las variables" y poder detener el tiempo en cualquier momento.

Curiosidad que muestra el curso: con Step Into sobre randint se ve que por dentro usa otra función, randrange. El depurador permite leer cómo está hecho el código de otros.

📝 Ejercicio original del curso: mutate#

from random import randint
from maths import add          # módulo propio con add(n1, n2)

def mutate(a_list):
    b_list = []
    new_item = 0
    for item in a_list:
        new_item = item * 2
        new_item += randint(1, 3)
        new_item = add(new_item, item)
    b_list.append(new_item)
    print(b_list)

mutate([1, 2, 3, 5, 8, 13])

Síntoma: se espera una lista de 6 números, pero se imprime uno solo (verificado). Técnica del curso: poner un punto de interrupción, observar b_list en el panel de variables y notar que no cambia durante el bucle. Solo recibe un elemento al final. Causa: b_list.append(new_item) está fuera del for, por un problema de sangría. Corrección: darle sangría para meterlo dentro del bucle.

🛠️ Nota técnica: el módulo propio del curso se llama maths.py, con "s". No lo llames math.py: Python ya tiene un módulo math y el tuyo lo "taparía", lo mismo que pasaba con random.py en el Día 4. El archivo maths.py no está incluido entre los materiales suministrados: créalo con def add(n1, n2): return n1 + n2.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: usa el depurador para seguir tu Blackjack con la mano [11, 11, 10] y observa cómo cambia la lista dentro de calculate_score.
• 🟡 Reto 2: pon un punto de interrupción dentro de check_answer (Día 12) y usa Step Out para volver a game().
• 🟠 Reto 3: usa Step Into sobre random.choice y describe qué encuentras.
• 🔴 Reto 4: investiga los puntos de interrupción condicionales (se detienen solo si se cumple una condición, por ejemplo i == 15). Úsalos en un bucle de 100 vueltas.

📝 Ejercicio original del curso: retos de depuración#

La lección anuncia "algunos desafíos de codificación que debes depurar" en la lección siguiente. Su contenido no está incluido entre los archivos suministrados. El proyecto del día (Sección 8) propone una actividad equivalente.

Situación#

Llegan 6 "pacientes" (programas enfermos) a la clínica. Tu trabajo es diagnosticarlos y curarlos, documentando qué consejo usaste en cada caso.

Los pacientes#

Paciente 1: el promedio que miente (sugerencia: jugar a ser el computador)

n1, n2, n3 = 3.0, 4.0, 5.0
promedio = n1 + n2 + n3 / 3
print(promedio)   # se espera 4.0

Paciente 2: el contador de vocales (sugerencia: print): la función contar_vocales del Reto 1 del Tema 5.

Paciente 3: la lista incompleta (sugerencia: describir el problema)

compras = ["arroz", "leche", "huevos"]
for i in range(1, len(compras)):
    print(f"- {compras[i]}")

Paciente 4: el mes fantasma (sugerencia: reproducir): el programa de los meses del Reto 1 del Tema 2.

Paciente 5: el descuento que no descuenta (sugerencia: print)

total = 60000
if total > 50000:
    total == total * 0.9
print(f"Total a pagar: {total}")

Paciente 6: la entrada frágil (sugerencia: corregir errores y usar try/except)

edad = int(input("Edad: "))
print(f"El próximo año tendrás {edad + 1}")

Pruébalo con quince, 15.5 y un Enter vacío.

Bitácora de depuración (entregable)#

Para cada paciente, completa:

Criterios#

• Los 6 pacientes quedan curados y verificados.
• Cada diagnóstico usa una técnica distinta, o justifica por qué se repite.

Situación#

En los tutoriales anteriores se documentaron bugs verificados en las soluciones del curso. Tu misión es auditar tus propias versiones de esos proyectos.

Lista de verificación#

Requisitos#

1. Probar los 6 casos en tus propias versiones.
2. Documentar en la bitácora de la Sección 8 los que fallen.
3. Corregir al menos tres.
4. Escribir una reflexión: ¿cuál fue el bug más difícil de encontrar? ¿Qué consejo te sirvió más?

Situación problema#

Casi todos los bugs de "entrada del usuario" de los últimos días (ValueError, opciones en mayúsculas, números fuera de rango) se repiten en cada proyecto. En lugar de corregirlos una y otra vez, crearás un módulo reutilizable.

Pregunta orientadora#

¿Cómo escribir una sola vez un código robusto y reutilizarlo en todos tus proyectos?

Requerimientos#

Un módulo entradas.py con estas funciones (todas con docstring y return):

Después:

1. Refactoriza Adivina el Número (Día 12) para usar pedir_opcion y pedir_entero.
2. Refactoriza la Calculadora (Día 10) para usar pedir_decimal y pedir_opcion.
3. Escribe un archivo pruebas_entradas.py que documente, en comentarios, los casos probados para cada función: vacío, texto, decimal, fuera de rango, mayúsculas y espacios.

Entregables#

• entradas.py, dos proyectos refactorizados y la tabla de pruebas.
• Una bitácora con al menos un bug que hayas encontrado mientras construías el kit.

Criterios técnicos#

• Ninguna entrada, por extraña que sea, detiene los programas refactorizados.
• Las funciones del kit no usan print salvo para los mensajes de error al usuario, y siempre devuelven el valor válido.
• Los proyectos refactorizados son más cortos que los originales.