15. METHODES /1

15.1. Pour faciliter la relecture et la correction d’un programme

But: limiter la charge cognitive, afin de pouvoir comprendre, corriger ou réutiliser plus rapidement un programme.

Méthode:

• adopter un style aéré (en python on peut ajouter des lignes vides après ou avant toute instruction).

• utiliser des noms d’identificateurs qui évoquent clairement leurs usages et/ou l’intention du programmeur.

• formuler les conditions complexes à l’aide de variables booléennes et des opérateurs and, or et not(). Voir Combinaisons de conditions (merci George).

• ne pas utiliser de variables globales, car elles sont une source intarissable d’erreurs.

• adopter le canevas suivant, qui évite les interférences indésirables entre les variables des différentes parties du programme:

  #-*- coding: utf-8 -*-
  # directive "coding" pour la gestion des accents dans les chaînes et les commentaires
  
  # puis les "import"
  
  from __future__ import division # division flottante par défaut
  
  import math
  import ...
  
  # ensuite les définitions de fonctions
  
  def f1 ...
  
  def f2 ...
  
  
  
  def main():
    # ici le code de la fonction "principale"
    ...
  
  # et enfin l'instruction de lancement de la fonction "principale" du programme
  # (aucune autre instruction à l'extérieur des définitions de fonctions,
  # hormis les "import", pour éviter la création de variables globales)
  main()
  

15.2. Pour trouver les erreurs dans un programme

• ajouter des print pour tracer l’exécution, en affichant les valeurs des principales variables, notamment celles résultant d’expressions calculées et celles correspondant à des indices utilisés dans les boucles. Simuler l’exécution du programme à la main et vérifier que les valeurs affichées dans la trace sont bien celles attendues.
• utiliser des commentaires pour activer/activer si besoin des parties de programmes lorsque l’on fait différents essais.
• utiliser le débogueur (de l’anglais debugger) depuis idle.
• vérifier dans un shell python interactif le comportement des instructions sujettes à caution, et aussi celui des appels aux fonctions des modules utilisés.
• tester séparément les différentes fonctions que l’on a écrites dans le programme, et ce pour différentes valeurs de paramètres. Par exemple, pour tester maFonction(x) dans monPrograme.py:
  • ajouter des lignes dans monProgramme.py pour réaliser des appels à maFonction et afficher avec des print les résultats correspondants.
  • ou exécuter le programme et rester en mode interactif après son exécution, afin de pouvoir utiliser la définition de maFonction. Pour cela:
    • lancer python avec python - i monProgramme.py
    • ou depuis l’interpréteur interactif python faire: import monProgramme
    • ou encore exécuter le programme depuis idle.

(AV) Pour détecter les erreurs, il est aussi possible d’ajouter des points de vérification dans le programme pour s’assurer que l’exécution se déroule comme prévue. Ceci s’effectue à l’aide de l’instruction assert dont la forme est:

assert CONDITION

Si à l’exécution de cette instruction la condition est fausse alors le programme s’arrête et affiche un message d’erreur indiquant la condition elle-même ainsi que le numéro de la ligne où se trouve cet assert.

Une forme plus complète est:

assert CONDITION, 'MESSAGE'

Son fonctionnement est identique, avec en plus, si la condition est fausse, l’affichage de la chaîne de caractère 'MESSAGE'. On l’utilise par exemple pour indiquer des valeurs de variables liées au problème détecté:

assert x>0, "x n'est pas strictement positif, et vaut " + str(x)

15.3. Pour trouver un principe de calcul

• essayer de trouver comment faire le calcul/traitement à la main (ou avec une calculette).
• essayer de découper le problème en sous-problèmes qui seront plus simples à traiter séparément.
• repérer les cas qui semblent les plus délicats à gérer (e.g., valeurs singulières, cas limites) et essayer tout d’abord de trouver un principe de calcul général qui ne tienne pas compte de ces cas.
• étudier des programmes/algorithmes réalisant des traitements similaires.
• une fois que l’on commence à avoir des pistes:
  • vérifier que l’on sait bien faire le calcul à la main jusqu’au bout ...
  • essayer de consigner sur papier (avec des mots, formules et schémas) le principe.
  • expliquer le principe à une autre personne, en donnant suffisamment de détails pour qu’elle soit ensuite capable de l’appliquer elle-même pour faire le calcul/traitement.
• envisager le traitement des cas particuliers que l’on avait éventuellement écartés.