Terminale générale · Sciences de l'ingénieur

Programmer en Python et documenter le programme

Traduire un algorithme en Python puis rendre son usage vérifiable par un autre élève.

Lecture et activités : environ 55 minutes

Objectifs

  • Traduire une séquence et une boucle en programme Python exécutable.
  • Vérifier résultats normaux, frontières et entrées invalides.
  • Documenter unités, conventions et limites par noms, docstrings et commentaires.
Sommaire du chapitre
  1. Définir l’interface du programme avant le code
  2. Traduire et résoudre un bilan énergétique
  3. Rendre le programme compréhensible et réutilisable
  4. Programmer un traitement avec mémoire
  5. Vérifier la traduction et écrire ses limites

Un résultat numérique juste suffit-il si personne ne sait quelles unités fournir au programme ?

Deux programmes Python 3 standard traitent des données pédagogiques originales : bilan énergétique et surintensités. Prérequis : variables, boucles, conditions et P = UI. Vérifie les résultats avant de documenter les fonctions.

Définir l’interface du programme avant le code

L’algorithme somme UIΔt sur des intervalles égaux. Entrées : tensions en volts, courants en ampères et durée en secondes. Sortie : énergie signée en joules. Ici, n valeurs représentent n intervalles, et non n points délimitant n − 1 intervalles.

U et I sont supposés constants sur chaque intervalle. Avec de simples échantillons variables, la somme devient une approximation par rectangles. En convention récepteur, un courant négatif représente une restitution. Le calcul ne donne ni rendement global ni énergie chimique stockée.

À toi d'essayer

Trois valeurs U–I sont utilisées avec Δt = 0,50 s. Quelle durée totale représente le contrat retenu ?

Coup de pouce : Compte les intervalles définis par le contrat, pas les espacements entre points.

Voir la réponse

Trois intervalles représentent 3 × 0,50 = 1,50 s. Si les données étaient trois points temporels encadrant seulement deux intervalles, il faudrait changer l’algorithme et sa documentation.

Traduire et résoudre un bilan énergétique

En Python, def définit une fonction, return fournit le résultat et l’indentation regroupe les blocs. zip associe les valeurs de même rang mais tronque aux données les plus courtes : les tailles sont donc contrôlées. isfinite refuse infinis et NaN ; le contrat exige des nombres.

Exemple résolu

Calculer l’énergie pour U = [24 ; 24 ; 23] V, I = [2 ; 3 ; 2] A et Δt = 0,50 s. Écrire puis exécuter le programme suivant dans un fichier Python.

  1. Étape 1 : Puissances par intervalle : 48 ; 72 ; 46 W. Énergies : 24 ; 36 ; 23 J.
  2. Étape 2 : Total attendu avant exécution : 24 + 36 + 23 = 83 J.
  3. Étape 3 : Programme Python 3 complet : ```python from math import isfinite def energie_j(tensions_v, courants_a, dt_s): """Somme U*I*dt en joules pour des intervalles de durée dt_s. Listes non vides, même longueur, nombres finis, tensions >= 0. dt_s > 0. Un courant négatif représente un retour d'énergie. Les valeurs U et I sont supposées constantes sur chaque intervalle. """ if not isfinite(dt_s) or dt_s <= 0: raise ValueError("La durée doit être finie et positive") if len(tensions_v) != len(courants_a) or not tensions_v: raise ValueError("Deux listes non vides de même longueur sont requises") total_j = 0.0 for u_v, i_a in zip(tensions_v, courants_a): if not isfinite(u_v) or not isfinite(i_a) or u_v < 0: raise ValueError("Valeurs finies et tensions positives ou nulles requises") # Convention récepteur : i_a < 0 soustrait une énergie restituée. total_j += u_v * i_a * dt_s return total_j print(energie_j([24.0, 24.0, 23.0], [2.0, 3.0, 2.0], 0.5)) ```
  4. Étape 4 : La sortie attendue est 83.0. En wattheures : 83/3 600 ≈ 0,02306 Wh.

Résultat : La fonction retourne 83 J, énergie reçue sur 1,50 s sous les hypothèses données. Le signe et l’unité du résultat sont documentés.

Piège à éviter : Fournir 500 pour une durée de 500 ms sans conversion multiplierait le résultat par mille.

À toi d'essayer

Que renvoie energie_j([24.0], [-2.0], 0.5) et comment interpréter ce résultat ?

Coup de pouce : Le signe du courant est conservé.

Voir la réponse

Le résultat est −24.0 J. Pendant cet intervalle, le composant restitue 24 J au port électrique suivant la convention choisie ; cela ne prouve pas que cette énergie atteint une batterie.

Rendre le programme compréhensible et réutilisable

La docstring décrit unités, entrées, convention et résultat. Le commentaire # explique une décision locale, ici le signe des courants. Répéter « ajouter au total » devant += apporte moins d’information que justifier cette convention.

Les noms rappellent les unités. Notice : Python 3, appels, exceptions. Enregistrer le code dans bilan.py puis lancer python3 bilan.py exécute le calcul localement.

À toi d'essayer

Deux listes de tailles 3 et 2 sont fournies au premier programme. Quel comportement est attendu ?

Coup de pouce : Lis le contrôle avant zip.

Voir la réponse

La fonction lève ValueError avant le calcul. Elle ne doit ni ignorer le dernier échantillon ni inventer un courant manquant. La notice doit permettre à l’utilisateur de corriger la taille des listes.

À toi d'essayer

Quel commentaire est le plus utile : « boucle sur i » ou « valeurs supposées constantes sur chaque intervalle » ?

Coup de pouce : Cherche l’information nécessaire pour juger la validité du calcul.

Voir la réponse

Le second précise une hypothèse physique que la boucle ne démontre pas. Il permet de comprendre pourquoi la somme peut devenir imprécise pour des signaux variant rapidement ; le premier répète seulement la syntaxe.

Programmer un traitement avec mémoire

Le second algorithme signale le déclenchement d’une alerte lorsque deux mesures consécutives de courant ont atteint ou dépassé 3,0 A. La série débute dès la première valeur au seuil, mais l’alerte est émise sur la deuxième valeur. Dans les données du cas : débuts aux indices 1 et 4 ; déclenchements aux indices 2 et 5. Il remet son compteur à zéro sous le seuil et émet seulement lorsque le compteur atteint exactement deux. Les données sont déjà validées ; aucune coupure matérielle n’est commandée.

Exemple résolu

Pour I = [2,8 ; 3,1 ; 3,2 ; 2,9 ; 3,4 ; 3,5] A, trouver les indices signalés puis écrire la fonction.

  1. Étape 1 : Les indices Python commencent à zéro : le troisième élément porte l’indice 2.
  2. Étape 2 : Compteurs successifs : 0 ; 1 ; 2 ; 0 ; 1 ; 2. Les indices attendus sont donc [2, 5].
  3. Étape 3 : Programme Python 3 complet : ```python def indices_declenchement_alerte(courants_a, seuil_a=3.0, consecutifs=2): """Indices où une série atteint consecutifs valeurs >= seuil_a. Données supposées validées et finies ; consecutifs entier >= 1. Un seul indice est émis par série, même si elle se prolonge. Les indices commencent à zéro ; aucune commande matérielle. """ if type(consecutifs) is not int or consecutifs < 1: raise ValueError("Le nombre de valeurs doit être un entier positif") compte = 0 indices = [] for indice, courant_a in enumerate(courants_a): if courant_a >= seuil_a: compte += 1 else: compte = 0 # Égalité : un seul événement au franchissement de la condition de deux valeurs consécutives. if compte == consecutifs: indices.append(indice) return indices print(indices_declenchement_alerte([2.8, 3.1, 3.2, 2.9, 3.4, 3.5])) ```
  4. Étape 4 : La sortie attendue est [2, 5]. Ajouter ensuite 3,6 A ne crée pas de nouvel événement dans la même série.

Résultat : Les deux séries commencent aux indices 1 et 4 ; les déclenchements, au moment où la deuxième valeur consécutive atteint le seuil, surviennent aux indices 2 et 5. Avec un échantillonnage à 0,10 s depuis t = 0, ils correspondent aux instants 0,20 s et 0,50 s.

Piège à éviter : Utiliser compte >= consecutifs émettrait plusieurs indices pendant une seule série prolongée.

À toi d'essayer

Pour [3.0, 3.0, 3.2] A, quels indices le programme signale-t-il avec ses paramètres par défaut ?

Coup de pouce : Le seuil est inclus et une série ne produit qu’un événement.

Voir la réponse

Il renvoie [1]. Les compteurs valent 1, 2 puis 3 ; seul le deuxième échantillon atteint exactement deux. Remplacer >= par > dans le test de courant changerait le traitement des valeurs égales au seuil.

Vérifier la traduction et écrire ses limites

Un test compare le calcul à une attente indépendante : trois produits pour 83 J, une trace du compteur pour les indices. Tester aussi durée nulle, listes vides et seuil inclus. Pour ces calculs, abs(obtenu − attendu) < 1e−9 contrôle l’arrondi numérique, sans exprimer une précision physique.

Limites : indices_declenchement_alerte suppose courants et seuil finis et validés ; energie_j suppose des intervalles égaux. Une acquisition irrégulière exige des durées distinctes. Modifier ces conventions impose de mettre à jour code, documentation et tests.

À toi d'essayer

La durée vaut 0 et les listes sont valides. Faut-il retourner 0 J dans le contrat actuel ?

Coup de pouce : Vérifie si la durée nulle fait partie des entrées autorisées.

Voir la réponse

Non : le contrat impose une durée strictement positive, donc ValueError est attendu. Accepter zéro serait un autre contrat possible, mais il faudrait modifier ensemble la validation, la documentation et les tests.

Attention :

Utiliser = à la place de == confond affectation et comparaison. Une mauvaise indentation peut réinitialiser total_j à chaque tour et perdre les sommes précédentes. Un commentaire périmé peut annoncer un seuil strict alors que le code inclut l’égalité ; les cas frontières doivent trancher cette incohérence.

À retenir

  • Une interface indique entrées, unités, sortie et erreurs.
  • La traduction doit préserver l’ordre et la mémoire de l’algorithme.
  • Des attentes calculées séparément permettent de tester le code.
  • Les commentaires expliquent les conventions et les limites.

S'entraîner sur cette notion

Explorer les exercices SI

Fiche de révision

Contrat

unités SI, nombre d’intervalles, convention de signe et entrées autorisées.

Valider les tailles avant zip ; signaler les données manquantes.

def, for, if/else et return structurent des blocs indentés.

Docstring

usage et limites ; commentaire : justification locale.

Énergie

ΣUiIiΔt en J ; diviser par 3 600 pour les Wh.

Compteur

initialisation, incrément et remise à zéro explicites.

Tester cas normaux, seuils et entrées invalides séparément de la validation physique.

Questions fréquentes

Quelle différence entre une docstring et un commentaire ?

La docstring décrit le contrat de la fonction et se consulte avec help(energie_j). Le commentaire explique une décision locale. Les deux doivent rester cohérents avec le code ; des noms explicites facilitent également sa lecture.

Pourquoi le programme peut-il être correct tout en donnant une mauvaise prévision ?

Un code correct peut calculer avec de mauvaises données ou hypothèses. Des millisecondes prises pour des secondes ou un signal variable supposé constant faussent la prévision. Tests logiciels et validation physique restent complémentaires.

Et maintenant ?

Choisis la suite de ton parcours : approfondir la notion suivante, revoir le chapitre ou t’entraîner avec les exercices réellement disponibles.

Besoin d’une révision ? Revoir la leçon précédente : Analyser et traduire un comportement en algorithme

Toutes les leçons de Terminale générale — Sciences de l’ingénieur

Scientia