Aller au contenu

TP Python – Relevés et débogage

BTS SIO SISR 1re année – Mathématiques pour l'informatique – S18

Note

Comment ce TP fonctionne. Chaque exercice a un éditeur Python intégré à la page (il s'exécute dans ton navigateur, rien à installer). Avant de lancer, écris sur ta feuille ce que tu anticipes (« J'anticipe »). Puis lance et compare. Le bouton Valider exécute des tests : un test réussi ne dispense pas de comprendre pourquoi.

Exercice A – Analyser des relevés

Complète nb_alertes(releves, seuil), premiere_alerte(releves, seuil), plus_longue_serie(releves, seuil) et ecart_max(releves). Un relevé est en alerte s'il est strictement supérieur au seuil.

J'anticipe. Pour [21, 25, 27, 26, 31, 32, 33, 24, 29, 30] et le seuil 25, quels résultats attends-tu pour les quatre fonctions ?

Je comprends. Pourquoi plus_longue_serie met-elle meilleure à jour dans la boucle et pas seulement quand la série s'arrête ?

###
t = [21, 25, 27, 26, 31, 32, 33, 24, 29, 30]bksl-nlassert nbpy-undalertes(t, 25) == 7 and nbpy-undalertes(t, 40) == 0 and nbpy-undalertes([], 25) == 0bksl-nlassert nbpy-undalertes(t, 20) == 10 and nbpy-undalertes([25], 25) == 0bksl-nlassert premierepy-undalerte(t, 25) == 2 and premierepy-undalerte(t, 40) == -1 and premierepy-undalerte([], 25) == -1bksl-nlassert premierepy-undalerte(t, 20) == 0 and premierepy-undalerte([30, 10], 25) == 0bksl-nlassert pluspy-undlonguepy-undserie(t, 25) == 5 and pluspy-undlonguepy-undserie(t, 40) == 0 and pluspy-undlonguepy-undserie([], 25) == 0bksl-nlassert pluspy-undlonguepy-undserie(t, 20) == 10 and pluspy-undlonguepy-undserie([30, 10, 30], 25) == 1bksl-nlassert pluspy-undlonguepy-undserie([10, 30, 31, 10, 30, 31, 32], 25) == 3bksl-nlassert ecartpy-undmax(t) == 9 and ecartpy-undmax([5]) == 0 and ecartpy-undmax([]) == 0bksl-nlassert ecartpy-undmax([10, 10, 10]) == 0 and ecartpy-undmax([3, 8]) == 5 and ecartpy-undmax([8, 3]) == 5bksl-nlassert t == [21, 25, 27, 26, 31, 32, 33, 24, 29, 30]bksl-nlbksl-nl ∞/∞

def nbpy-undalertes(releves, seuil):bksl-nl """Nombre de relevés strictement supérieurs à seuil."""bksl-nl n = 0bksl-nl for r in releves:bksl-nl # À compléter : compter les relevés en alertebksl-nl passbksl-nl return nbksl-nlbksl-nldef premierepy-undalerte(releves, seuil):bksl-nl """Indice du premier relevé strictement supérieur à seuil, ou -1 s'il n'y en a pas."""bksl-nl for i in range(len(releves)):bksl-nl # À compléter : renvoyer i dès qu'un relevé dépasse le seuilbksl-nl passbksl-nl return -1bksl-nlbksl-nldef pluspy-undlonguepy-undserie(releves, seuil):bksl-nl """Plus grand nombre de relevés consécutifs strictement supérieurs à seuil."""bksl-nl courante = 0bksl-nl meilleure = 0bksl-nl for r in releves:bksl-nl # À compléter : si r dépasse le seuil, courante augmente de 1, sinon elle retombe à 0 ;bksl-nl # mettre à jour meilleurebksl-nl passbksl-nl return meilleurebksl-nlbksl-nldef ecartpy-undmax(releves):bksl-nl """Plus grande différence, en valeur absolue, entre deux relevés consécutifs (0 s'il y a moins de 2 relevés)."""bksl-nl e = 0bksl-nl for i in range(len(releves) - 1):bksl-nl # À compléter : comparer abs(releves[i + 1] - releves[i]) à ebksl-nl passbksl-nl return ebksl-nlbksl-nl

Exercice B – Déboguer (1)

Les trois fonctions de debug.py sont incorrectes. Fais passer les tests en les corrigeant. Pour chacune, écris en commentaire l'erreur trouvée :

  • maximum(t) : valeur maximale d'une liste non vide ;
  • somme_positifs_moyenne(t) : moyenne des valeurs strictement positives (0 s'il n'y en a pas) ;
  • trie_sans_modifier(t) : renvoie une copie triée sans modifier t.
###
assert maximum([3, 9, 4]) == 9 and maximum([-5, -2, -9]) == -2 and maximum([7]) == 7bksl-nlassert sommepy-undpositifspy-undmoyenne([4, -2, 6]) == 5 and sommepy-undpositifspy-undmoyenne([-1, -2]) == 0 and sommepy-undpositifspy-undmoyenne([]) == 0bksl-nlassert sommepy-undpositifspy-undmoyenne([0, 4, 0]) == 4bksl-nloriginal = [3, 1, 2]bksl-nlassert triepy-undsanspy-undmodifier(original) == [1, 2, 3]bksl-nlassert original == [3, 1, 2]bksl-nlbksl-nl ∞/∞

def maximum(t):bksl-nl m = 0 # erreur : ...bksl-nl for x in t:bksl-nl if x > m:bksl-nl m = xbksl-nl return mbksl-nlbksl-nldef sommepy-undpositifspy-undmoyenne(t):bksl-nl s = 0bksl-nl n = 0bksl-nl for x in t:bksl-nl if x > 0:bksl-nl s = s + xbksl-nl n = n + 1 # erreur : ...bksl-nl if n == 0:bksl-nl return 0bksl-nl return s / nbksl-nlbksl-nldef triepy-undsanspy-undmodifier(t):bksl-nl r = t # erreur : ...bksl-nl r.sort()bksl-nl return rbksl-nlbksl-nl

Exercice C – Déboguer (2)

Même consigne pour debug2.py :

  • compte_pairs(t) : nombre d'éléments pairs de t ;
  • est_croissant(t) : True si t est rangé dans l'ordre croissant (au sens large) ;
  • pourcentage(partie, total) : pourcentage de partie dans total (0 si total vaut 0).

Je comprends. Pour chaque erreur, quel test du jeu de tests la révèle ? Quel tableau de suivi la ferait apparaître ?

###
assert comptepy-undpairs([4, 7, 8, 10]) == 3 and comptepy-undpairs([2]) == 1 and comptepy-undpairs([]) == 0bksl-nlassert comptepy-undpairs([1, 3, 5]) == 0 and comptepy-undpairs([6, 1, 1]) == 1bksl-nlassert estpy-undcroissant([1, 2, 2, 5]) is True and estpy-undcroissant([3]) is True and estpy-undcroissant([]) is Truebksl-nlassert estpy-undcroissant([1, 3, 2, 5]) is False and estpy-undcroissant([5, 1]) is Falsebksl-nlassert estpy-undcroissant([1, 2, 3, 2]) is Falsebksl-nlassert pourcentage(1, 4) == 25 and pourcentage(3, 4) == 75 and pourcentage(0, 5) == 0bksl-nlassert pourcentage(5, 5) == 100 and pourcentage(1, 3) > 33.3 and pourcentage(1, 3) < 33.4bksl-nlassert pourcentage(3, 0) == 0bksl-nlbksl-nl ∞/∞

def comptepy-undpairs(t):bksl-nl n = 0bksl-nl for i in range(1, len(t)): # erreur : ...bksl-nl if t[i] % 2 == 0:bksl-nl n = n + 1bksl-nl return nbksl-nlbksl-nldef estpy-undcroissant(t):bksl-nl for i in range(len(t) - 1):bksl-nl if t[i] <= t[i + 1]:bksl-nl return True # erreur : ...bksl-nl return Falsebksl-nlbksl-nldef pourcentage(partie, total):bksl-nl if total == 0:bksl-nl return 0bksl-nl return partie // total py-str 100 # erreur : ...bksl-nlbksl-nl

Pour aller plus loin

Dans la console, écris avant de coder trois tests pour une fonction pic(connexions) qui renvoie (valeur, indice) du premier maximum (exercice 8 de la feuille d'exercices), puis écris la fonction.