Chapitre 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 :

Placer des points d'arrêt (breakpoints) en cliquant dans la marge à côté d'une ligne
Lancer le programme en mode débogage (Ctrl+F5 ou menu Exécuter → Déboguer)
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 :

Tester chaque fonction séparément avec des assertions
Commenter des portions de code pour isoler le problème
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.