Modules et
bibliothèques.

• Trouver et utiliser la fonction qu’il vous faut dans la bibliothèque standard.
• Découper un projet en plusieurs fichiers.
• Comprendre if __name__ == "__main__":.
• Installer un paquet avec pip sur votre PC.

La forme 1 est la plus claire : en lisant math.sqrt, on sait d’où vient la fonction. La forme 2 est bien pour deux ou trois noms très utilisés. L’alias (3) est la convention pour certaines bibliothèques (import numpy as np). La forme 4 déverse des dizaines de noms dans votre programme et peut en écraser d’autres silencieusement : on ne l’utilise pas. dir(module) liste ce qu’il contient ; help(module.fonction) explique.

Toutes les fonctions trigonométriques travaillent en radians : 360° = 2π rad. Oublier la conversion est l’erreur n°1 des programmes de robots qui tournent dans le mauvais sens. atan2(y, x) donne l’angle du vecteur (x, y) dans le bon quadrant, contrairement à atan(y/x). La séance 14 y consacre une heure entière.

Un ordinateur ne sait pas tirer au hasard : il calcule une suite déterministe qui en a l’air, à partir d’une graine. Fixer la graine avec seed permet de reproduire exactement une simulation (indispensable pour déboguer). gauss(moyenne, écart-type) modélise le bruit réel d’un capteur. Pour de la cryptographie, on utilise le module secrets, pas random.

perf_counter() : pour mesurer des durées (le plus précis). time.time() : secondes écoulées depuis le 1er janvier 1970, pour horodater. datetime.now() : date et heure lisibles. sleep() bloque le programme : sur un robot, on préfère souvent comparer l’heure à chaque tour de boucle plutôt que dormir (séance 20).

Un capteur qui renvoie parfois une valeur aberrante fausse complètement la moyenne (90 tire tout vers le haut) mais pas la médiane. Les filtres médians sont partout en robotique. Counter remplace le comptage manuel de la séance 06 ; deque(maxlen=n) est une fenêtre glissante gratuite ; itertools.product énumère tous les cas d’un problème combinatoire — utile pour vérifier une table de vérité par force brute.

Quand on lance python outils.py, la variable __name__ vaut "__main__" et le bloc de tests s’exécute. Quand on fait import outils depuis un autre fichier, __name__ vaut "outils" et le bloc est ignoré : on récupère les fonctions sans lancer les tests. C’est la convention pour qu’un même fichier soit à la fois une bibliothèque et un programme. Vous verrez cette ligne dans presque tout code Python sérieux.

Un fichier par responsabilité, comme une fonction par tâche. main.py ne contient presque rien : il assemble. Les tests sont à côté, avec le préfixe test_. Les données ne sont jamais mélangées au code. Python trouve les modules dans le dossier du script lancé, puis dans la bibliothèque standard, puis dans les paquets installés : c’est sys.path. Un dossier contenant plusieurs modules s’appelle un paquet et s’importe avec des points : from mon_robot.capteurs import lire_distance.

Le dépôt PyPI contient plus de 500 000 paquets. Pour éviter que les projets se marchent dessus, on crée un environnement virtuel par projet : python -m venv .venv, puis l’activer (.venv\Scripts\activate sous Windows, source .venv/bin/activate ailleurs) avant de pip install. On liste les dépendances dans requirements.txt. Dans cette page, numpy est disponible sans installation ; la plupart des autres paquets ne le sont pas.

import random, time
from collections import Counter

for n in (10_000, 1_000_000):
    t0 = time.perf_counter()
    lancers = [random.randint(1, 6) for _ in range(n)]
    duree = time.perf_counter() - t0
    c = Counter(lancers)
    print(f"{n} lancers en {duree:.3f} s")
    for face in sorted(c):
        print(f"  face {face} : {c[face] / n:.4f}")

Le rapport des temps est proche de 100 : le temps est proportionnel au nombre de lancers. On dit que l’algorithme est linéaire. Séance 11.

def estimer_pi(n):
    dedans = 0
    for _ in range(n):
        x, y = random.random(), random.random()
        if x * x + y * y <= 1:
            dedans += 1
    return 4 * dedans / n

for n in (1_000, 100_000, 1_000_000):
    p = estimer_pi(n)
    print(f"n={n:>9} π≈{p:.5f} erreur={abs(p - math.pi):.5f}")

L’erreur décroît environ comme 1/√n : pour gagner une décimale, il faut 100 fois plus de points. C’est lent mais ça marche pour des problèmes où aucune formule n’existe : les méthodes de Monte-Carlo ont été inventées pour le projet Manhattan et servent aujourd’hui en finance, en physique et en robotique (localisation d’un robot par « filtre à particules »).

import math

def distance(p, q):
    return math.hypot(q[0] - p[0], q[1] - p[1])

def angle(p, q):
    return math.degrees(math.atan2(q[1] - p[1], q[0] - p[0]))

def rotation(p, theta_deg):
    t = math.radians(theta_deg)
    x, y = p
    return (x * math.cos(t) - y * math.sin(t), x * math.sin(t) + y * math.cos(t))

def aire_polygone(points):
    s = 0
    n = len(points)
    for i in range(n):
        x1, y1 = points[i]
        x2, y2 = points[(i + 1) % n]      # le dernier rejoint le premier
        s += x1 * y2 - x2 * y1
    return abs(s) / 2

if __name__ == "__main__":
    assert distance((0, 0), (3, 4)) == 5
    assert angle((0, 0), (0, 1)) == 90 and angle((0, 0), (-1, 0)) == 180
    r = rotation((1, 0), 90)
    assert math.isclose(r[0], 0, abs_tol=1e-12) and math.isclose(r[1], 1)
    assert aire_polygone([(0, 0), (2, 0), (2, 2), (0, 2)]) == 4
    print("geometrie : OK")

Le carré tourné : [geometrie.rotation(p, 45) for p in carre] puis aire_polygone → 4.0 (à 1e-15 près) : une rotation conserve l’aire, et votre code le vérifie numériquement. La formule du lacet est un cas particulier du théorème de Green, que vous verrez en prépa ; (i + 1) % n pour « boucler » sur le premier point est un idiome à retenir. Ces quatre fonctions sont exactement celles dont un robot a besoin pour naviguer (séance 14).