Programmer en Python : comprendre, tester et corriger

Une affectation commence par évaluer l’expression à droite, puis lie le nom à gauche au résultat. Dans x = x + 2, l’ancienne valeur est donc lue avant d’être remplacée : ce n’est pas une égalité mathématique. Après x = 3, puis x = x + 2, puis x = x * 4, les états successifs sont 3, 5 et 20. Inverser deux instructions peut changer le résultat. Pour vérifier une prédiction, note l’état après chaque instruction, pas seulement la valeur finale.

Une condition choisit un chemin. Dans un bloc if / elif / else, la première condition vraie sélectionne sa branche ; les suivantes ne sont pas évaluées. Sans else, aucune branche ne s’exécute si toutes les conditions sont fausses. Deux if séparés sont différents : chacun peut être exécuté. L’indentation délimite les blocs Python. Une boucle for parcourt un objet itérable, par exemple une liste ou un range, tandis que while reteste une condition avant chaque tour.

Le laboratoire fait avancer une valeur par un pas positif jusqu’à atteindre ou dépasser un seuil. Son contrat accepte des entiers, hors booléens : départ et seuil entre -1000 et 1000, pas entre 1 et 1000. Il produit la valeur finale et une liste de tuples (tour, avant, condition, après). Si le départ atteint déjà le seuil, la trace est vide. Le dernier test faux arrête la boucle mais n’ajoute aucun tour à la trace.

Pour raisonner sur l’arrêt, considère max(0, seuil - valeur). Tant qu’un tour reste nécessaire, cet entier positif diminue strictement grâce au pas positif. Le processus finit donc par atteindre ou dépasser le seuil. L’atelier et le code limitent en plus la trace à 200 tours pour garder l’essai lisible : un calcul qui demanderait davantage est signalé, même s’il terminerait mathématiquement. Cette limite d’outil n’est pas la preuve de terminaison.

Définir une fonction avec def lui donne un nom et des paramètres ; cela ne lance pas encore son corps. L’appel fournit des arguments. Dans note_sur_vingt(15, 30), 15 correspond à note et 30 à maximum. return renvoie une valeur et termine cet appel ; print affiche du texte sans remplacer un résultat renvoyé. Une fonction qui atteint sa fin sans return explicite renvoie None. Une chaîne placée au début du corps forme sa documentation, consultable avec help.

Le contrat décrit le comportement attendu avant de choisir l’implémentation. Ici, les deux arguments sont des nombres Python int ou float représentables par un flottant fini, hors booléens ; le maximum est strictement positif et la note appartient à [0, maximum]. Après un appel valide, le résultat est un flottant entre 0 et 20, avec les extrémités conservées. Les arguments ne sont pas modifiés. La formule utilise 20 * (note / maximum) : le rapport est calculé d’abord pour éviter qu’une multiplication intermédiaire de très grands flottants déborde.

La précondition appartient à la responsabilité de l’appelant ; le code peut néanmoins la contrôler pour signaler une erreur claire. Notre choix est une ValueError pour une entrée hors contrat. Une note supérieure au maximum n’est donc pas silencieusement corrigée. Une postcondition ne remplace pas la formule : renvoyer toujours 0 resterait entre 0 et 20, mais ne convertirait pas les notes. Les tests doivent aussi vérifier les résultats attendus et des propriétés comme la croissance.

assert sert à détecter une propriété fausse pendant la mise au point. L’option Python -O peut retirer ces assertions ; une validation nécessaire au comportement doit donc rester dans un if qui lève une exception. Le laboratoire sépare les contrôles d’entrée de l’assertion de sortie. La fonction reussite compose la conversion avec un seuil optionnel, 10 par défaut, lui aussi borné entre 0 et 20. Les calculs flottants restent des approximations : pour un résultat non exact, compare avec une tolérance annoncée.

Chaque appel crée des liaisons locales pour ses paramètres. Le nom utilisé par l’appelant et le nom du paramètre peuvent cependant désigner le même objet. Réaffecter le paramètre à une nouvelle liste ne change pas la liaison de l’appelant ; modifier une case de la liste reçue change l’objet partagé. La portée répond à « où ce nom est-il utilisable ? » ; l’identité répond à « est-ce le même objet ? ». Ce sont deux questions distinctes.

Dans le schéma, b = a crée une seconde liaison vers la liste, pas une copie. c = a.copy() crée une nouvelle liste extérieure avant l’ajout de 8. Ainsi a et b voient [2,5,8], tandis que c reste [2,5]. Pour une liste de listes, la copie est superficielle : les sous-listes peuvent encore être partagées. Un dessin de liaisons permet de repérer ce partage sans confondre une égalité de contenus avec une identité d’objets.

Le laboratoire borner reçoit une liste ou un tuple d’entiers, hors booléens, et deux bornes entières ordonnées. Il renvoie toujours une nouvelle liste, même lorsque toutes les valeurs sont déjà dans l’intervalle ou que l’entrée est vide. Chaque valeur trop petite est remplacée par le minimum, chaque valeur trop grande par le maximum, les autres sont conservées. C’est ici une transformation demandée, contrairement à une validation qui doit refuser les données invalides.

Pour tester la non-mutation, conserve une copie du contenu avant l’appel, puis compare l’entrée après l’appel à cette copie. Pour vérifier l’identité, compare le résultat à l’objet effectivement passé : resultat is not source. Le comparer à une autre liste ne prouverait rien. Ce calcul est sans effet de bord sur ses arguments et dépend seulement d’eux. Une fonction mutante reste possible, mais son nom et son contrat doivent annoncer la modification.

Un jeu de tests part de la spécification, pas de ce que le programme rend déjà. Pour cet exercice, les températures sont des entiers et les catégories sont conventionnelles : froid pour x<0, tempéré pour 0≤x<20, chaud pour x≥20. Ces étiquettes ne décrivent pas une règle scientifique universelle. Les trois intervalles n’ont ni trou ni recouvrement ; chaque entrée valide doit donc recevoir une seule catégorie.

Choisis des représentants des classes, puis examine les frontières. Autour de 20, les entiers 19, 20 et 21 contrôlent l’avant, la borne et l’après. Tester trois fois 20 apporte moins d’information. Pour des nombres réels, ±1 ne désignerait pas les voisins immédiats : il faudrait choisir une précision adaptée au problème. La fonction cas_frontieres produit ici des cas entiers distincts et triés, même si les seuils sont répétés ou voisins.

L’oracle est le moyen de connaître le résultat attendu sans recopier la condition testée. Une table écrite depuis les intervalles sert d’oracle à nos six cas. Des propriétés complètent ces exemples : une catégorie appartient au vocabulaire prévu ; son rang ne diminue pas lorsque la température augmente. Mais une fonction qui renvoie toujours « chaud » respecte ces deux propriétés. Les valeurs attendues restent donc indispensables.

Commence par un cas qui échoue pour la bonne raison, corrige le minimum nécessaire, puis rejoue l’ensemble. Le cas du bogue devient un test de non-régression. Tester de nombreuses entrées ne prouve pas à lui seul le comportement pour toutes les autres. La qualité d’un test vient aussi de sa capacité à distinguer une implémentation correcte d’une erreur plausible, par exemple < remplacé par <=.

Une erreur de syntaxe empêche l’analyse d’un fragment : par exemple un if auquel il manque les deux-points. Une exception apparaît pendant un chemin exécuté, comme une division par zéro ; le programme peut avoir correctement fonctionné sur d’autres entrées. Une erreur de logique peut ne déclencher aucune exception : le résultat a le bon type, mais ne respecte pas le contrat. La catégorie de l’erreur oriente la recherche sans suffire à localiser sa cause.

Pour déboguer, conserve une entrée qui reproduit le symptôme, le résultat attendu et le résultat observé. Réduis ensuite l’entrée sans faire disparaître l’écart. Trace uniquement les variables utiles, aux mêmes instants dans le calcul attendu et dans le programme. La ligne d’une exception indique où un problème devient observable ; une valeur incorrecte a pu être produite plus tôt. Supprimer cette ligne risquerait de cacher le symptôme.

Le laboratoire moyenne accepte une liste ou un tuple non vide d’au plus 1000 entiers entre -10 000 et 10 000, hors booléens. Ce domaine borné garde la somme et son affichage faciles à suivre. Chaque tuple de trace contient (indice, valeur lue, total avant, total après). La division a lieu seulement après la boucle. Pour [2,4,6], les sommes sont 2,6,12 ; diviser 12 par 3 donne 4.

Le bogue total = valeur produit lui aussi 2 au premier tour, mais 4 au deuxième au lieu de 6. La première divergence précède donc le résultat final erroné. Deux éléments dont le premier est non nul suffisent à révéler ce défaut ; ils n’ont pas besoin d’être différents, puisque [2,2] le révèle aussi. Un singleton ne le détecte pas. Le correctif doit restaurer l’accumulation, puis conserver un cas discriminant et les tests des autres exigences.

Une bibliothèque propose des fonctions réutilisables sous une interface documentée. import math rend le module disponible sous ce nom ; math.isfinite indique si un flottant n’est ni infini ni NaN. La documentation précise le paramètre, le résultat et les limites. La fonction ne certifie ni qu’une note est dans l’intervalle voulu ni qu’un booléen est une note : ces règles appartiennent à notre contrat. Le module standard est déjà fourni avec Python, sans installation supplémentaire.

Comparer des langages consiste à conserver un problème et ses résultats attendus, puis à repérer les constructions communes. Python et JavaScript expriment tous deux affectations, conditions, boucles et fonctions, mais avec indentation ou accolades, mots-clés et interfaces différents. Les styles peuvent aussi varier : impératif pour des changements d’état successifs, fonctionnel pour composer des calculs, événementiel pour réagir à des actions. Un même langage peut servir plusieurs styles. HTML décrit la structure d’un document ; il ne joue pas le rôle de notre programme de calcul.

Le laboratoire teste un palindrome selon une règle volontairement précise : conserver uniquement les caractères ASCII A à Z, a à z et 0 à 9, puis mettre les majuscules conservées en minuscules. Les espaces, accents et autres caractères sont supprimés, sans translittération. Ainsi 'Été' devient 't', tandis que 'étéx' devient 'tx'. Le résultat vide est considéré comme palindrome. Cette règle d’exercice n’est pas une définition linguistique générale du palindrome.

Après ce filtrage, la chaîne ne contient que de l’ASCII : ses indices et sa longueur se correspondent en Python et JavaScript. Sans ce périmètre, la longueur JavaScript compte des unités UTF-16 et peut différer du nombre de points de code parcourus par for...of. On compare les caractères symétriques jusqu’à la moitié, puis on renvoie un booléen. Filtrer avant de changer la casse évite qu’un caractère non ASCII se transforme en lettre admise par notre règle.

En JavaScript, = affecte, == peut convertir les types et === compare sans cette conversion. Pour deux chaînes primitives, == et === donnent le même résultat : il serait faux de rejeter == sur cet exemple pour une différence inexistante. En revanche, '3' et 3 donnent vrai avec ==, faux avec ===. Python donne faux à '3'==3 mais vrai à True==1. Choisis donc le contrat, puis des cas qui révèlent les différences réelles, sans conclure que les langages seraient globalement équivalents.