Débogage

# Le bug est quelque part dans 100 lignes.
# Stratégie : commenter la moitié du code
# et tester si le bug est encore là.

def traiter_donnees(data):
    data = nettoyer(data)         # ← est-ce que le bug est ici ?
    # --- POINT DE TEST DICHOTOMIE ---
    print("data après nettoyage:", data)  # vérifier ici
    # ---------------------------------
    data = transformer(data)      # ou ici ?
    data = calculer_stats(data)   # ou ici ?
    return exporter(data)         # ou ici ?

# Si le print montre des données correctes :
# → le bug est APRÈS (dans transformer, calculer_stats, exporter)
# Si les données sont déjà incorrectes :
# → le bug est DANS nettoyer ou dans les données d'entrée
# Recommencer avec la moitié qui contient le bug.

# Transformer un bug complexe en exemple minimal

# ✗ Trop complexe pour déboguer
app = Application()
app.charger_config("config.json")
app.connecter_base()
app.lancer_serveur()
# ... 200 lignes plus tard : KeyError quelque part

# ✓ Cas minimal : isoler le dictionnaire incriminé
d = {"utilisateurs": [{"nom": "Alice"}]}
# Reproduit l'erreur sans l'application entière :
print(d["utilisateurs"][0]["email"])  # → KeyError: 'email'

# Maintenant la cause est évidente :
# la clé "email" n'existe pas dans le dict utilisateur.

# ✗ Print inutile — ne donne aucune info
print(x)

# ✓ Print informatif — type, valeur, contexte
print(f"[DEBUG] x = {x!r} (type: {type(x).__name__})")
# !r utilise repr() → montre None vs "None", '' vs " ", etc.

# ✓ Inspecter un dictionnaire ou une liste
import json
print(json.dumps(data, indent=2, default=str))  # lisible

# ✓ Tracer le flux d'exécution
def ma_fonction(x, y):
    print(f"→ ma_fonction appelée avec x={x!r}, y={y!r}")
    result = x + y
    print(f"← ma_fonction retourne {result!r}")
    return result

# ✓ Afficher la pile d'appels depuis n'importe où
import traceback
traceback.print_stack()  # qui a appelé cette fonction ?

# ✓ Breakpoint express (Python 3.7+)
breakpoint()  # équivalent à import pdb; pdb.set_trace()
              # mais peut être désactivé avec PYTHONBREAKPOINT=0

import logging

# Configuration de base (à mettre dans le main)
logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    datefmt="%H:%M:%S",
    # filename="app.log"  ← pour écrire dans un fichier
)
logger = logging.getLogger(__name__)

# 5 niveaux — du plus détaillé au plus critique
logger.debug(f"Valeur intermédiaire : {x}")    # dev uniquement
logger.info("Traitement démarré")              # flux normal
logger.warning(f"Liste vide reçue pour {id}") # suspect
logger.error("Connexion DB échouée")           # erreur récupérable
logger.critical("Crash imminent")              # fatal

# En production : passer à WARNING pour ne voir que les problèmes
logging.basicConfig(level=logging.WARNING)

# Avantage sur print : on peut filtrer, horodater,
# rediriger vers fichier/Sentry/Datadog sans changer le code

# assert condition, "message si faux"
# Lance AssertionError si la condition est False

def calculer_moyenne(notes: list) -> float:
    # Préconditions : rendre les hypothèses explicites
    assert isinstance(notes, list), f"notes doit être une liste, reçu {type(notes)}"
    assert len(notes) > 0,          "La liste ne doit pas être vide"
    assert all(0 <= n <= 20 for n in notes), "Toutes les notes doivent être entre 0 et 20"

    # Traitement
    moyenne = sum(notes) / len(notes)

    # Postcondition : vérifier le résultat
    assert 0 <= moyenne <= 20, f"Résultat incohérent : {moyenne}"
    return moyenne

# Utilisation
calculer_moyenne(["a", "b"])  # → AssertionError: notes doit être une liste...
calculer_moyenne([])          # → AssertionError: La liste ne doit pas être vide
calculer_moyenne([10, 14])   # → 12.0

# ⚠️ assert est désactivé avec python -O (optimized)
# → pour les vraies validations d'entrée, utiliser ValueError/TypeError
if not notes:
    raise ValueError("La liste de notes ne peut pas être vide")

# Vérifier qu'un invariant est maintenu à chaque itération
def tri_bulles(lst):
    n = len(lst)
    for i in range(n):
        for j in range(0, n - i - 1):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
        # Invariant : les i derniers éléments sont à leur place
        assert lst[n-i-1:] == sorted(lst)[n-i-1:], \
            f"Invariant violé à l'itération {i}: {lst}"
    return lst

# Méthode 1 — breakpoint() dans le code (Python 3.7+)
def ma_fonction(x):
    breakpoint()   # le programme s'arrête ici
    return x * 2

# Méthode 2 — depuis la ligne de commande
python -m pdb mon_script.py

# Méthode 3 — après une exception (post-mortem)
import pdb
try:
    code_qui_plante()
except:
    pdb.post_mortem()  # inspecter l'état au moment du crash

# L'invite pdb ressemble à ceci :
# > main.py(8)ma_fonction()
# -> return x * 2
# (Pdb) _

# Code
def traiter(items):
    total = 0
    breakpoint()
    for item in items:
        total += item["valeur"]
    return total

# Session pdb
# > traiter(items)
# (Pdb) p items
# [{'valeur': 10}, {'val': 20}]   ← ici ! "val" pas "valeur"
# (Pdb) p items[1]
# {'val': 20}                     ← clé différente !
# (Pdb) n                         ← avancer
# (Pdb) n
# KeyError: 'valeur'              ← bug trouvé !
# (Pdb) q

// .vscode/launch.json
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Python : fichier courant",
      "type": "debugpy",
      "request": "launch",
      "program": "${file}",
      "console": "integratedTerminal"
    },
    {
      "name": "Python : main.py avec args",
      "type": "debugpy",
      "request": "launch",
      "program": "${workspaceFolder}/main.py",
      "args": ["--input", "data.csv"],
      "env": { "DEBUG": "1" }
    },
    {
      "name": "Python : tests pytest",
      "type": "debugpy",
      "request": "launch",
      "module": "pytest",
      "args": ["-v", "tests/"]
    }
  ]
}

class Animal:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

    # ✓ Toujours implémenter __repr__ pour le débogage
    def __repr__(self):
        return f"Animal(nom={self.nom!r}, age={self.age!r})"

a = Animal("Rex", 3)
print(a)  # Animal(nom='Rex', age=3)  ← utile dans print() et pdb

# Inspecter tous les attributs d'un objet
vars(a)       # → {'nom': 'Rex', 'age': 3}
a.__dict__    # idem
dir(a)        # liste TOUS les attributs + méthodes héritées

# Inspecter l'héritage
type(a)       # → <class '__main__.Animal'>
type(a).__mro__  # → MRO : ordre de résolution des méthodes
isinstance(a, Animal)   # → True
issubclass(Chien, Animal) # → True si Chien hérite de Animal

# Savoir d'où vient une méthode
a.afficher.__qualname__  # → 'Animal.afficher' ou 'Chien.afficher' ?

# ✗ Attribut de classe vs attribut d'instance
class Compteur:
    total = 0   # ← attribut de CLASSE, partagé par toutes les instances !
    def incrementer(self):
        Compteur.total += 1  # toutes les instances voient le même total

# ✓ Attribut d'instance dans __init__
class Compteur:
    def __init__(self):
        self.total = 0   # attribut de l'instance uniquement

# ✗ Oublier self — appel de méthode échoue
class Foo:
    def calculer(self):
        return helper()    # NameError : manque self.helper()

# ✗ super() oublié dans __init__ → attributs du parent manquants
class Chien(Animal):
    def __init__(self, nom, age, race):
        # oubli de super().__init__(nom, age) !
        self.race = race
    # → AttributeError: 'Chien' object has no attribute 'nom'

# ✓ Correction
class Chien(Animal):
    def __init__(self, nom, age, race):
        super().__init__(nom, age)  # ← obligatoire
        self.race = race

F5            # Lancer / Continuer
F9            # Poser / retirer un breakpoint
F10           # Step over (ligne suivante)
F11           # Step into (entrer fonction)
Shift+F11     # Step out (sortir fonction)
Shift+F5      # Arrêter
Ctrl+Shift+F5 # Redémarrer

□ J'ai lu le traceback complet (pas juste la dernière ligne)
□ J'ai affiché les valeurs des variables au point du crash
□ J'ai un cas minimal qui reproduit le bug
□ J'ai vérifié le type réel de chaque variable impliquée
□ J'ai testé avec des valeurs limites (None, [], 0, "")
□ J'ai cherché le message d'erreur exact sur le web
□ J'ai essayé d'expliquer le bug à voix haute (rubber duck)