Partie 3 : Modules et mise au point

Programme officiel (B.O.)

B.O. spécial n° 1 du 22 janvier 2019 - NSI Première

Contenus	Capacités attendues	Commentaires
Utilisation de bibliothèques.	Utiliser la documentation d'une bibliothèque.	L'objectif est d'utiliser des modules existants et de savoir consulter leur documentation.
Mise au point de programmes.	Utiliser des techniques de mise au point : affichage intermédiaire, points d'arrêt, pas à pas.	On se limitera à des programmes simples.

---

1. Les modules en Python

1.1 Qu'est-ce qu'un module ?

Un module est un fichier Python (.py) contenant des fonctions, des constantes et des classes réutilisables. Les modules permettent de :

• Organiser le code en fichiers thématiques
• Réutiliser du code sans le réécrire
• Partager du code avec d'autres développeurs

Python dispose d'une riche bibliothèque standard (modules inclus par défaut) et de nombreuses bibliothèques tierces installables.

1.2 Importer un module

Il existe plusieurs façons d'importer un module :

# Import du module entier
import math
print(math.sqrt(16))      # 4.0
print(math.pi)            # 3.141592653589793

# Import de fonctions spécifiques
from math import sqrt, pi
print(sqrt(16))            # 4.0
print(pi)                  # 3.141592653589793

# Import avec alias
import math as m
print(m.sqrt(16))          # 4.0

À éviter

L'import from module import * importe tout le contenu du module dans l'espace de noms. C'est déconseillé car cela peut provoquer des conflits de noms et rend le code moins lisible (on ne sait plus d'où vient chaque fonction).

1.3 Modules de la bibliothèque standard

Module	Contenu	Exemples
math	Fonctions mathématiques	sqrt(), floor(), ceil(), pi, e
random	Nombres aléatoires	randint(), choice(), shuffle()
csv	Lecture/écriture de fichiers CSV	reader(), DictReader()
os	Interaction avec le système	listdir(), path.exists()
time	Mesure du temps	time(), sleep()
json	Manipulation de données JSON	loads(), dumps()
doctest	Tests dans les docstrings	testmod()

1.4 Exemples d'utilisation

import math

# Arrondi, plancher, plafond
print(math.floor(3.7))     # 3 (arrondi vers le bas)
print(math.ceil(3.2))      # 4 (arrondi vers le haut)
print(round(3.5))          # 4 (arrondi au plus proche)

# Racine carrée et puissance
print(math.sqrt(144))      # 12.0
print(math.log2(1024))     # 10.0

import random

# Nombre aléatoire
print(random.randint(1, 6))      # dé à 6 faces
print(random.choice(["pile", "face"]))
liste = [1, 2, 3, 4, 5]
random.shuffle(liste)            # mélange en place
print(liste)

1.5 Créer son propre module

Tout fichier Python est un module. Pour créer le module outils.py :

outils.py

def est_pair(n):
    """Vérifie si n est pair."""
    return n % 2 == 0

def maximum(a, b):
    """Renvoie le plus grand de a et b."""
    if a >= b:
        return a
    return b

Pour l'utiliser depuis un autre fichier :

programme.py

from outils import est_pair, maximum

print(est_pair(42))         # True
print(maximum(7, 12))       # 12

1.6 Le bloc if __name__ == "__main__"

Quand un fichier Python est importé comme module, tout le code au niveau du fichier est exécuté. Pour éviter que les tests s'exécutent à l'importation, on les place dans un bloc spécial :

outils.py

def est_pair(n):
    return n % 2 == 0

if __name__ == "__main__":
    # Ce bloc ne s'exécute QUE si on lance outils.py directement
    # Il ne s'exécute PAS quand on fait "import outils"
    assert est_pair(4) == True
    assert est_pair(7) == False
    print("Tests OK !")

1.7 Consulter la documentation

Pour connaître les fonctions disponibles dans un module :

>>> import math
>>> help(math)              # documentation complète du module
>>> help(math.sqrt)         # documentation d'une fonction
>>> dir(math)               # liste des noms définis dans le module

---

2. Mise au point de programmes

2.1 Les types d'erreurs

Type	Détection	Exemple
Erreur de syntaxe	Avant l'exécution	if x = 5: (= au lieu de ==)
Erreur d'exécution	Pendant l'exécution	Division par zéro, indice hors limites
Erreur de logique	Résultat incorrect	Algorithme faux, condition inversée

Les erreurs de syntaxe et d'exécution sont signalées par Python. Les erreurs de logique sont les plus difficiles à trouver car le programme « tourne » mais produit un résultat faux.

2.2 Les messages d'erreur de Python

Python affiche un traceback qui indique :

• Le fichier et le numéro de ligne de l'erreur
• Le type d'erreur (TypeError, ValueError, IndexError...)
• Un message explicatif

>>> notes = [12, 15, 8]
>>> print(notes[5])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Erreurs courantes :

Erreur	Cause	Exemple
SyntaxError	Faute de syntaxe	if x = 5:
NameError	Variable non définie	print(abc) sans définir abc
TypeError	Type incompatible	"3" + 5
IndexError	Indice hors limites	[1, 2, 3][5]
KeyError	Clé absente dans un dictionnaire	d["cle_inexistante"]
ZeroDivisionError	Division par zéro	10 / 0
ValueError	Valeur invalide	int("abc")

2.3 Technique 1 : affichages intermédiaires

La technique la plus simple consiste à ajouter des print() pour afficher l'état des variables à des endroits stratégiques :

def recherche_max(tableau):
    """Renvoie l'indice du maximum."""
    i_max = 0
    for i in range(1, len(tableau)):
        print(f"  i={i}, tableau[i]={tableau[i]}, max actuel={tableau[i_max]}")  # debug
        if tableau[i] > tableau[i_max]:
            i_max = i
            print(f"  → nouveau max trouvé à l'indice {i}")  # debug
    return i_max

resultat = recherche_max([3, 7, 2, 9, 1])
print(f"Indice du max : {resultat}")

Sortie :

  i=1, tableau[i]=7, max actuel=3
  → nouveau max trouvé à l'indice 1
  i=2, tableau[i]=2, max actuel=7
  i=3, tableau[i]=9, max actuel=7
  → nouveau max trouvé à l'indice 3
  i=4, tableau[i]=1, max actuel=9
Indice du max : 3

Conseil

Pensez à retirer les print() de débogage une fois le problème résolu.

2.4 Technique 2 : le débogueur pas à pas

Un débogueur (debugger) permet d'exécuter un programme instruction par instruction et d'observer l'état des variables à chaque étape.

Dans Thonny :

1. Placer des points d'arrêt (breakpoints) en cliquant dans la marge à côté d'une ligne
2. Lancer le programme en mode débogage (Ctrl+F5 ou menu Exécuter → Déboguer)
3. Utiliser les boutons :
   • Pas à pas : exécuter l'instruction suivante
   • Entrer : entrer dans une fonction
   • Sortir : terminer la fonction en cours
   • Continuer : reprendre l'exécution jusqu'au prochain point d'arrêt

Le débogueur affiche en temps réel les valeurs des variables dans un panneau dédié.

2.5 Technique 3 : diviser pour régner

Quand un programme est long et que l'erreur est difficile à localiser :

1. Tester chaque fonction séparément avec des assertions
2. Commenter des portions de code pour isoler le problème
3. Simplifier les données d'entrée (tester avec un petit tableau avant un grand)

# Tester une fonction isolément
def somme(tableau):
    total = 0
    for x in tableau:
        total += x
    return total

# Tests unitaires
assert somme([]) == 0
assert somme([5]) == 5
assert somme([1, 2, 3]) == 6
print("somme() fonctionne correctement")

2.6 Bonnes pratiques

Pratique	Pourquoi
Nommer clairement les variables	nombre_eleves plutôt que n ou x
Écrire des fonctions courtes	Plus faciles à tester et à déboguer
Tester souvent	Détecter les erreurs tôt, quand le code est encore frais
Lire les messages d'erreur	Python donne le type, la ligne et un message explicatif
Utiliser le débogueur	Plus efficace que des print() pour les erreurs complexes

---

À retenir

• Un module est un fichier Python réutilisable contenant des fonctions et constantes.
• On importe avec import module, from module import fonction ou import module as alias.
• La bibliothèque standard fournit math, random, csv, os, json, doctest...
• help(module) et dir(module) permettent de consulter la documentation.
• if __name__ == "__main__": permet de séparer le code exécutable des tests.
• Trois types d'erreurs : syntaxe (avant exécution), exécution (pendant), logique (résultat faux).
• Techniques de mise au point : affichages intermédiaires (print), débogueur pas à pas (points d'arrêt), tests unitaires.
• Lire le traceback de Python : il indique le fichier, la ligne et le type d'erreur.