Exercices corrigés de NSI Première : les bases de Python

7 // 2 vaut 3 (int) : c'est le quotient entier. 7 / 2 vaut 3.5 (float) : l'opérateur / renvoie TOUJOURS un flottant, même quand la division tombe juste. 7 % 2 vaut 1 (int), le reste. 2 ** 10 vaut 1024 (int).

-7 // 2 vaut -4, et non -3. Python arrondit le quotient vers le bas (vers moins l'infini), pas vers zéro. Et -7 % 2 vaut 1, un reste positif. Les deux sont cohérents : la relation $a = b \times (a\ //\ b) + (a\ \%\ b)$ doit rester vraie, et en effet $-7 = 2\times(-4)+1$. En Python, le reste a toujours le signe du diviseur.

0.1 + 0.2 vaut 0.30000000000000004, donc l'expression est FAUSSE. En binaire, 0,1 et 0,2 n'ont pas d'écriture finie, exactement comme 1/3 n'en a pas en base 10 : la machine en stocke une approximation, et les erreurs s'additionnent. On ne teste donc jamais l'égalité de deux flottants ; on écrit abs(a - b) < 1e-9, ou l'on travaille avec des entiers quand c'est possible (des centimes plutôt que des euros).

'3' + '4' vaut '34' : entre deux chaînes, + est la concaténation. '3' * 4 vaut '3333' : chaîne fois entier, c'est la répétition. int(3.9) vaut 3 et int(-3.9) vaut -3 : int() tronque vers zéro, elle n'arrondit pas (attention, ce n'est donc PAS la même chose que //).

round(2.5) vaut 2, round(3.5) vaut 4 et round(0.5) vaut 0. La règle n'est pas « 0,5 s'arrondit au-dessus » mais l'arrondi au pair le plus proche : en cas d'égalité parfaite, Python choisit l'entier pair. Ce choix évite le biais systématique vers le haut quand on arrondit de longues séries de valeurs.

Pour (a, b) valant (F,F), (F,V), (V,F), (V,V), les deux expressions valent respectivement V, V, V, F. Elles coïncident dans les quatre cas : c'est la loi de De Morgan, non(a et b) = (non a) ou (non b). L'autre loi, symétrique, est non(a ou b) = (non a) et (non b).

Le corps entier revient à demander : l'utilisateur est majeur ET (abonné OU invité). D'où la version en une ligne : return age >= 18 and (abonne or invite). Deux remarques de style : les parenthèses sont indispensables car « and » est prioritaire sur « or », et on n'écrit jamais abonne == True mais simplement abonne, qui est déjà un booléen.

Seule x != 0 and 10 / x > 2 est correcte. Python évalue « and » en court-circuit et de gauche à droite : si x vaut 0, le premier facteur est faux, la deuxième condition n'est jamais évaluée et la division par zéro n'a pas lieu. Dans l'autre ordre, 10 / x est calculée en premier et lève une ZeroDivisionError pour x = 0. Le court-circuit n'est donc pas une optimisation, c'est un outil de protection.

On peut écrire x >= 0 and x <= 10, mais Python autorise les comparaisons chaînées : 0 <= x <= 10, qui se lit comme en mathématiques et n'évalue x qu'une fois.

return n % 2 == 0. La comparaison produit déjà un booléen : le if ne fait que le recopier. Écrire if cond: return True else: return False est toujours un signe qu'on peut renvoyer directement la condition.

La suite est 6, 3, 10, 5, 16, 8, 4, 2, 1. Chaque flèche est un tour de boucle, donc etapes vaut 8. Détail : 6 est pair donc 3 ; 3 est impair donc 10 ; 10 pair donc 5 ; 5 impair donc 16 ; puis 8, 4, 2, 1 par divisions successives.

Pour n = 7 : 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1. Cela fait 16 étapes, et la plus grande valeur atteinte est 52. Noter que la suite monte largement au-dessus de son point de départ avant de retomber : c'est ce qui rend la terminaison non évidente.

i prend les valeurs 3, 7, 11, 15, 19, puis 23 dépasserait 20 et la boucle s'arrête : 5 tours. La borne de range est toujours exclue.

Un variant est une quantité entière positive qui décroît strictement à chaque tour, ce qui garantit l'arrêt. Ici, aucun variant n'est connu : n n'a aucune raison de décroître, il triple presque quand il est impair. La conjecture de Syracuse affirme que la suite atteint 1 pour tout entier de départ, mais elle n'est PAS démontrée, malgré une vérification par ordinateur jusqu'à des valeurs colossales. C'est donc un programme dont personne ne sait prouver qu'il termine toujours, tout en étant certain qu'il termine pour tous les cas testés.

Il suffit de mémoriser le maximum au fil du parcours.

L'affichage est [1], puis [1, 2], puis [1, 2, 3].

La valeur par défaut est évaluée UNE SEULE FOIS, au moment où Python lit la définition de la fonction, pas à chaque appel. Il existe donc une unique liste, créée une fois pour toutes et attachée à la fonction ; chaque appel sans deuxième argument travaille sur cette même liste, qui garde les ajouts précédents. La règle à retenir : on ne met jamais d'objet mutable (liste, dictionnaire) comme valeur par défaut.

On utilise None comme sentinelle et on crée la liste à l'intérieur du corps, donc à chaque appel.

Une fonction qui renvoie une valeur laisse son argument intact et produit un nouvel objet : on l'utilise avec t2 = double(t). Une fonction qui modifie son argument agit par effet de bord, ne renvoie rien (None), et s'utilise avec double_sur_place(t) sur une ligne seule. Le bug classique consiste à écrire t = double_sur_place(t), ce qui écrase t avec None. Il faut choisir l'un des deux styles et le documenter, jamais les deux à la fois.

n vaut 5. L'affectation n = 10 à l'intérieur de f crée une variable LOCALE qui porte le même nom et disparaît à la fin de l'appel ; elle ne touche pas la variable globale. Pour modifier la globale il faudrait déclarer global n, ce qu'on évite en pratique.

t[1:4] vaut [1, 2, 3] : les indices 1, 2 et 3, la borne de droite étant exclue. t[::2] vaut [0, 2, 4] : un élément sur deux. t[::-1] vaut [5, 4, 3, 2, 1, 0] : la liste renversée. t[-2:] vaut [4, 5] : les deux derniers, l'indice -1 désignant le dernier élément.

t[:0] et t[2:2] valent tous deux [] : une tranche vide n'est pas une erreur. En revanche t[10] lève une IndexError, car l'indexation d'un élément hors bornes est interdite. Mais t[2:10] vaut [2, 3, 4, 5] sans erreur : les TRANCHES sont tolérantes et se contentent de s'arrêter à la fin de la liste. C'est une asymétrie que l'épreuve aime tester.

m[0] vaut 'i', m[-1] vaut 'e', m[0:5] vaut 'infor', m[::-1] vaut 'euqitamrofni' et len(m) vaut 12. Une chaîne s'indexe et se tranche exactement comme une liste, à une différence près : elle est immuable, donc m[0] = 'I' est interdit.

Par boucle : créer une liste vide puis ajouter les carrés un par un. En compréhension, tout tient sur une ligne. Les deux produisent [1, 4, 9, 16, 25, 36, 49, 64, 81, 100].

t2 = t ne copie rien : les deux noms désignent le MÊME objet, donc modifier t2[0] change aussi t[0]. t2 = t[:] crée une vraie copie (superficielle) : les deux listes sont indépendantes. Exemple : après t = [1, 2, 3] et t2 = t, l'instruction t2[0] = 99 donne t = [99, 2, 3]. Avec t2 = t[:], t reste [1, 2, 3].

La somme vaut 12 + 15 + 9 + 18 = 54, et il y a 4 notes : la moyenne correcte est 54 / 4 = 13,5.

La fonction renvoie 10,5. Le bug est dans range(1, len(t)) : la boucle démarre à l'indice 1 et saute donc le premier élément. Elle additionne 15 + 9 + 18 = 42, puis divise par 4, d'où 10,5. La correction est d'écrire range(len(t)), ou mieux, de parcourir directement les valeurs avec for x in t, ce qui rend l'erreur d'indice impossible.

Avec la moyenne corrigée à 13,5, les notes strictement supérieures sont 15 et 18 : au_dessus renvoie 2, ce qui est correct.

Le défaut est que moyenne(t) est recalculée à CHAQUE tour de boucle, alors qu'elle ne change jamais. Sur une liste de n notes, on fait n calculs de moyenne coûtant chacun n additions, soit un travail proportionnel à $n^{2}$ au lieu de $n$. La correction est de calculer la moyenne une seule fois avant la boucle et de la stocker dans une variable. C'est un réflexe attendu à l'examen : sortir de la boucle tout calcul qui n'en dépend pas.

Trois tests qui couvrent des cas différents : une liste à un seul élément, où la moyenne doit valoir cet élément (ce test échoue immédiatement avec le bug, car la boucle ne fait aucun tour et renvoie 0) ; une liste de valeurs toutes égales, où la moyenne doit valoir cette valeur commune ; et un cas connu calculé à la main. Le premier est le plus utile : les bugs d'indice se révèlent presque toujours sur les cas de taille 0 ou 1, jamais sur les cas moyens.

Entrée : une liste t de nombres. Sortie : un entier i tel que t[i] soit supérieur ou égal à tous les éléments de t. Précondition : t doit être non vide. Sur une liste vide, il n'existe aucun indice à renvoyer ; on choisit d'exiger la précondition plutôt que d'inventer une valeur de retour, et on peut la matérialiser dans le code par assert len(t) > 0.

La spécification doit trancher : on convient de renvoyer le PREMIER indice où le maximum est atteint. Sans cette précision, deux implémentations correctes peuvent donner des réponses différentes sur [3, 9, 9], et un test automatique deviendrait arbitraire. Une spécification qui laisse une ambiguïté est une spécification incomplète.

On mémorise l'indice du meilleur élément vu jusqu'ici, et on ne le remplace que sur une inégalité STRICTE, ce qui garantit qu'on conserve la première occurrence.

Sa version échoue sur toute liste dont tous les éléments sont strictement négatifs. Sur t = [-5, -2, -9], aucun élément ne dépasse 0 : la condition x > m n'est jamais vraie, l'indice n'est jamais mis à jour et la fonction renvoie 0, donc l'indice de -5. Le résultat attendu est 1, l'indice de -2. La leçon générale : on initialise un maximum avec un élément de la liste, jamais avec une constante choisie arbitrairement.

Le jeu de tests figure dans le corrigé ci-dessous. Chaque test vise un risque identifié : le cas général vérifie la logique, la liste à un élément vérifie les bornes de la boucle, les négatifs attrapent le bug d'initialisation de la question d, et le doublon vérifie la convention fixée en b.

grille[1][2] vaut 9 : ligne d'indice 1 (la deuxième), colonne d'indice 2 (la troisième). grille[2][0] vaut 7. La valeur 8 s'obtient par grille[0][1]. L'ordre est toujours [ligne][colonne].

On parcourt chaque ligne, puis chaque élément de la ligne. La somme vaut 3+8+1+4+2+9+7+5+6 = 45.

On fixe la colonne et on fait varier l'indice de ligne. La colonne 0 contient 3, 4 et 7 : sa somme vaut 14.

La transposée est [[3, 4, 7], [8, 2, 5], [1, 9, 6]] : l'élément de la ligne i colonne j vient de la ligne j colonne i.

[0] * p crée bien une ligne de p zéros, mais la multiplication suivante par n ne duplique pas cette ligne : elle recopie n fois la MÊME référence. Les n lignes sont donc un seul et même objet, et g[0][0] = 1 met un 1 en tête de toutes les lignes à la fois. La bonne écriture crée une ligne neuve à chaque tour, par exemple en compréhension : [[0] * p for _ in range(n)]. C'est exactement le même piège que l'argument par défaut mutable de l'exercice 4 : en Python, dupliquer une référence n'est pas dupliquer l'objet.

Il suffit de comparer le mot à son renversé : return m == m[::-1]. Résultats : 'radar' vrai, 'kayak' vrai, 'python' faux, 'ressasser' vrai.

On avance deux indices l'un vers l'autre depuis les deux bouts, et on s'arrête dès qu'ils se croisent ou qu'une paire diffère. La boucle fait au plus n // 2 tours : une fois arrivé au milieu, toutes les paires ont été vérifiées, continuer reviendrait à recomparer les mêmes lettres. Cette version est préférable sur de longs textes, car la version avec tranche construit une copie complète du mot en mémoire.

On repère la position de chaque lettre dans alpha, on ajoute k, on prend le reste modulo 26 et on relit la lettre correspondante. cesar('bonjour', 3) donne 'erqmrxu'.

cesar('xyz', 3) donne 'abc'. C'est le modulo 26 qui assure le rebouclage : la position de 'x' est 23, plus 3 donne 26, et 26 % 26 vaut 0, soit la position de 'a'. Sans ce modulo, l'indice sortirait de l'alphabet et provoquerait une IndexError.

Déchiffrer, c'est chiffrer avec la clé opposée : cesar(message, -k). Le modulo gère aussi les valeurs négatives en Python, puisque le reste y est toujours positif. On vérifie : cesar('erqmrxu', -3) redonne bien 'bonjour'.

amplitude(t) = max(t) - min(t) = 22 - 12 = 10 degrés.

La moyenne vaut $\frac{12+15+14+19+22+21+17}{7}=\frac{120}{7}\approx 17{,}14$. Les températures qui la dépassent strictement sont 19, 22 et 21, aux indices 3, 4 et 5. La fonction renvoie donc [3, 4, 5]. Attention à calculer la moyenne UNE fois avant la compréhension, pas à l'intérieur.

Les écarts d'un jour au suivant sont [3, -1, 5, 3, -1, -4]. La plus forte hausse vaut 5, et elle commence à l'indice 2 (du jour 2 au jour 3, de 14 à 19).

Les suites strictement croissantes sont 12, 15 (longueur 2), puis 14, 19, 22 (longueur 3), puis 17 seul. La plus longue a donc une longueur de 3.

Parce que la question d demande de retenir une information ENTRE les tours : la longueur de la série en cours, qu'il faut remettre à 1 dès que la croissance s'interrompt, tout en conservant le meilleur score vu jusque-là. Une compréhension de liste ne peut pas porter cet état accumulé, elle calcule chaque terme indépendamment des autres. Les questions b et c s'y prêtent au contraire parce que chaque terme s'y calcule à partir des seules données locales, sans mémoire. C'est le critère à retenir : dès qu'il faut un accumulateur qui dépend de l'historique, il faut une vraie boucle.

Pour i = 0, la boucle intérieure range(0) ne fait aucun tour ; pour i = 1, un tour ; pour i = 2, deux tours ; pour i = 3, trois tours. Le compteur vaut donc 0 + 1 + 2 + 3 = 6, et le programme affiche 6.

La boucle intérieure fait i tours pour chaque i de 0 à n - 1 : le total vaut $0 + 1 + \dots + (n-1) = \frac{n(n-1)}{2}$. Pour n = 100 : $\frac{100 \times 99}{2} = 4\ 950$. Le nombre de tours croît comme $n^{2}$ : c'est la signature de deux boucles imbriquées dont les bornes dépendent de n.

Pour i = 1, la boucle intérieure commence avec j = 1 : j == i, donc break immédiat, rien n'est affiché. Pour i = 2 : j = 1 est affiché, puis j = 2 déclenche break. Pour i = 3 : j = 1 et j = 2 sont affichés, puis break. Les lignes sont donc 2 1, puis 3 1, puis 3 2, soit trois lignes. L'instruction break ne sort QUE de la boucle la plus intérieure qui la contient : la boucle sur i continue normalement.

La boucle ajoute 1, puis 2, puis 3 et ainsi de suite tant que s < 50. Après n = 9, s vaut 45, encore inférieur à 50, donc un tour de plus : n = 10 et s = 55. La condition est testée AVANT chaque tour : la boucle s'arrête avec s = 55, qui dépasse 50. Le piège est de répondre n = 9, la dernière valeur pour laquelle s reste sous 50.

range(1, 10) s'arrête à 9, la borne de droite étant exclue : il obtient 45 au lieu de 55. On corrige en écrivant sum(range(1, 11)), et plus généralement range(1, n + 1) pour aller de 1 à n.

age est de type str : il vaut '16'. L'instruction age + 1 lève une TypeError, car Python refuse d'additionner une chaîne et un entier. Il faut convertir : age = int(input('Âge ? ')).

int('16') + 1 vaut 17. float('3.5') vaut 3.5. int('3.5') lève une ValueError : int accepte une chaîne qui représente un ENTIER, pas un décimal. int(float('3.5')) vaut 3 : on convertit d'abord en flottant, puis on tronque vers zéro.

str(12) + '3' vaut '123' : deux chaînes, donc concaténation. int('12') + int('3') vaut 15 : deux entiers, donc addition. '12' * 2 vaut '1212' : chaîne fois entier, donc répétition. Le même symbole change de sens selon le type de ses opérandes.

2 ** 100 vaut 1267650600228229401496703205376, un entier de 31 chiffres : len(str(2 ** 100)) vaut 31. Les entiers Python n'ont pas de taille maximale. Pour la somme des chiffres, on parcourt la chaîne et on reconvertit chaque caractère : sum(int(c) for c in str(2 ** 15)). Comme 2 ** 15 = 32768, cela vaut 3 + 2 + 7 + 6 + 8 = 26.

bool('') vaut False, bool('False') vaut True, bool(0) vaut False et bool([0]) vaut True. Une chaîne est fausse seulement si elle est VIDE, quel que soit son contenu ; une liste est fausse seulement si elle est vide, même si elle contient 0. Si l'utilisateur tape non, 0 ou False, la chaîne n'est pas vide et if reponse: est vrai : il faut comparer explicitement, par exemple if reponse == 'oui':.

2024 est divisible par 4 et pas par 100 : bissextile. 2023 n'est pas divisible par 4 : non. 1900 est divisible par 100 mais pas par 400 : NON, c'est le piège. 2000 est divisible par 400 : bissextile.

return (a % 4 == 0 and a % 100 != 0) or a % 400 == 0. Les parenthèses sont facultatives car and est prioritaire sur or, mais elles rendent la lecture sûre. La version du camarade se lit a % 4 == 0 or (a % 400 == 0 and a % 100 != 0) : pour 1900, le premier terme est vrai, donc elle renvoie True, alors que 1900 n'est pas bissextile. La seconde partie ne peut d'ailleurs jamais être vraie, un multiple de 400 étant toujours multiple de 100.

De 1901 à 2000 : les multiples de 4 sont 1904, 1908, et ainsi de suite jusqu'à 2000, soit 25 années, et 2000 est bien bissextile car multiple de 400 : 25. De 2001 à 2100 : 25 multiples de 4, de 2004 à 2100, mais 2100 est divisible par 100 et pas par 400 : 24.

On parcourt les années de a1 à a2 - 1 et on ajoute 366 ou 365. De 2000 à 2024 inclus, il y a 25 années dont 7 bissextiles, 2000, 2004, 2008, 2012, 2016, 2020 et 2024 : $25 \times 365 + 7 = 9\ 132$ jours. L'erreur classique est d'aller jusqu'à a2 inclus, ce qui compte une année de trop.

Le test sur 1900. L'erreur du camarade ne se voit que sur une année divisible par 4 ET par 100 mais pas par 400 : 2024, 2023 et 2000 donnent le bon résultat avec sa fonction. Un bon jeu de tests ne vérifie pas des cas au hasard, il vise chaque branche de la règle, et le cas le plus rare est le plus précieux.

Lu de droite à gauche : 3, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1. Rangs pairs, gardés : 3, 9, 7, 5, 3, 1, de somme 28. Rangs impairs, doublés : 0 donne 0, 8 donne 16 puis 7, 6 donne 12 puis 3, 4 donne 8, 2 donne 4, de somme 22. Total : 28 + 22 = 50, multiple de 10 : le numéro est VALIDE.

Parcourir s[::-1] avec enumerate, ou avec un indice, donne directement le rang depuis la droite : le dernier chiffre a le rang 0 quelle que soit la longueur du numéro. Sans renversement, la parité du rang dépendrait de la longueur, et un numéro de 15 chiffres ne serait pas traité comme un numéro de 16. Il faut aussi penser à convertir chaque caractère avec int, sinon '8' * 2 donne la chaîne '88'.

On essaie le chiffre manquant de 0 à 9 : il occupe le rang 0, donc il n'est pas doublé et s'ajoute tel quel à la somme des autres. Les onze autres chiffres, décalés d'un rang, donnent une somme de 43. Il faut 43 + k multiple de 10, donc k = 7 : le numéro valide est '521489370127'.

Le 0 est au rang 1, donc doublé : il comptait pour 0, le 1 compte pour 2. La somme passe de 50 à 52, qui n'est pas un multiple de 10 : l'erreur est détectée. Changer un seul chiffre modifie toujours la somme d'une quantité comprise entre 1 et 9, jamais d'un multiple de 10 : toute erreur sur un seul chiffre est détectée.

L'inversion de 0 et 9, dans un sens ou dans l'autre. Si 09 devient 90, le 0 doublé compte 0 et le 9 simple compte 9 avant l'erreur, soit 9 ; après, le 9 doublé donne 18 puis 9 et le 0 simple compte 0, soit encore 9. La somme ne change pas. Pour toutes les autres paires de chiffres différents, la somme change d'un nombre qui n'est pas multiple de 10.

g[0][2] vaut 'X' : ligne 0, colonne 2. g[2][0] vaut 'O'. La grille ne contient aucune case vide : les neuf cases sont remplies.

Il y a 8 alignements : 3 lignes, 3 colonnes et 2 diagonales. La diagonale qui part de g[0][2] passe par g[1][1] et g[2][0] : ses cases sont g[i][2 - i] pour i = 0, 1, 2. La diagonale principale est formée des cases g[i][i].

On teste les trois lignes, les trois colonnes et les deux diagonales. Sur la grille g, les lignes et les colonnes sont toutes mélangées, et la diagonale secondaire contient X, X et O. La diagonale principale contient g[0][0], g[1][1] et g[2][2], qui valent tous 'X' : X a gagné par la diagonale principale, et O n'a aucun alignement.

On parcourt les lignes puis les cases. La grille contient 5 X et 4 O. Comme X commence et que les joueurs alternent, il y a toujours autant de X que de O, ou un X de plus : 5 et 4 est cohérent, et correspond à une partie terminée par le cinquième coup de X.

Avec 2 X et 4 O, O aurait joué deux fois de plus que X : c'est impossible, l'écart compter(g, 'X') - compter(g, 'O') devant valoir 0 ou 1. Une grille où les deux joueurs ont un alignement est aussi impossible : la partie s'arrête dès le premier alignement, et le joueur suivant ne peut plus en compléter un. Vérifier qu'une grille est cohérente avant de désigner un gagnant, c'est tester les préconditions de la fonction.

La première, assert n >= 0, s'exécute à l'ENTRÉE, avant tout calcul, et porte sur l'argument : c'est la PRÉCONDITION, ce que l'appelant doit garantir. La seconde, placée juste avant le return, porte sur le résultat : c'est la POSTCONDITION, ce que la fonction garantit en échange. En français : le carré de r ne dépasse pas n, ET le carré de r + 1 le dépasse strictement, donc r est le PLUS GRAND entier dont le carré tient sous n. La première moitié seule ne dit presque rien : r = 0 la vérifie pour tout n positif, et une fonction qui renverrait toujours 0 passerait le contrôle. C'est la seconde moitié qui interdit de renvoyer trop petit. La docstring dit le contrat à l'humain, les assertions le disent à la machine, qui le vérifie à chaque appel.

Pour n = 30, la boucle teste $(r+1)^{2}\leq 30$ : $1$, $4$, $9$, $16$ et $25$ passent, et r monte de 0 à 5 ; au sixième test, $36\leq 30$ est faux et la boucle s'arrête. Elle a fait 5 tours, et la fonction renvoie 5 ; la postcondition $25\leq 30<36$ est vraie. Pour n = 49, le test $49\leq 49$ passe encore, r atteint 7, puis $64\leq 49$ échoue : la fonction renvoie 7, et $49\leq 49<64$. Pour n = 0, le tout premier test $1\leq 0$ est faux : la boucle ne tourne pas, r vaut 0, et la postcondition $0\leq 0<1$ certifie que ce 0 est juste. C'est le cas limite qu'on oublie : une boucle qui ne tourne jamais doit, elle aussi, rendre un résultat correct.

Avec -4, la précondition est fausse : l'exécution s'arrête sur une AssertionError dont le message est « n doit etre positif », avant le moindre calcul. L'erreur est signalée là où la faute a été commise, c'est-à-dire à l'APPEL. Sans la première assertion, la boucle teste $1\leq -4$, faux, r reste à 0, puis la postcondition $0\leq -4$ est fausse : une AssertionError se déclenche quand même, mais sur la seconde assertion, qui accuse la fonction alors que c'est l'appelant qui s'est trompé. Sans aucune assertion, la fonction renverrait 0 sans broncher, un résultat faux puisqu'aucun entier n'a un carré inférieur ou égal à -4, et ce 0 se propagerait dans la suite du programme. Hors de sa précondition, une fonction ne promet rien : l'assertion d'entrée sert à le dire tout de suite.

Les cinq tests passent : sur 0, la boucle du camarade ne tourne pas et renvoie 0 ; sur 1, 4, 9 et 16, elle s'arrête exactement sur la racine, puisque le test r * r < n devient faux quand r * r = n. Mais racine_camarade(30) fait tourner r jusqu'à 6, car $25<30$ puis $36<30$ est faux : elle renvoie 6, alors que $6^{2}=36>30$. Sa fonction calcule le plus PETIT entier dont le carré atteint n, c'est-à-dire la racine arrondie vers le haut, et les deux versions ne coïncident que sur les carrés parfaits. Or le jeu de tests ne contient QUE des carrés parfaits : il vérifie une seule famille de cas, celle où l'erreur est invisible. Il fallait au moins un entier qui ne soit pas un carré, 2 ou 30 par exemple. C'est la phrase du programme : le succès d'un jeu de tests ne garantit pas la correction d'un programme.

Pour n = 30, la version du camarade arrive au return avec r = 6, et la postcondition exige $36\leq 30$ : elle est fausse, et une AssertionError se déclenche dès le premier appel sur un nombre qui n'est pas un carré. Là où les tests vérifient des CAS choisis à l'avance, la postcondition vérifie une PROPRIÉTÉ à chaque appel, y compris sur les valeurs que personne n'a prévues. Entre 0 et 50, les deux versions coïncident exactement sur les carrés parfaits $0$, $1$, $4$, $9$, $16$, $25$, $36$ et $49$ : la version du camarade n'est juste que pour 8 valeurs sur 51. On garde en général les postconditions pendant la mise au point : elles coûtent un calcul à chaque appel, et rapportent le bug le jour où il apparaît.

La documentation de randint écrit a <= N <= b : les DEUX bornes sont comprises, et randint(1, 30) peut renvoyer $1$, $2$, jusqu'à $30$, soit $30-1+1=30$ valeurs. Celle de randrange renvoie à range(start, stop, step) : elle hérite donc de sa convention, borne de gauche comprise et borne de droite EXCLUE. randrange(1, 30) choisit dans $1$, $2$, ..., $29$, soit $30-1=29$ valeurs, et ne tire jamais 30. Deux fonctions du même module, deux conventions : c'est exactement pour cela qu'on lit la documentation au lieu de deviner d'après le nom.

Il faut que la borne de droite exclue soit 31 : randrange(1, 31) choisit dans $1$ à $30$, comme randint(1, 30). Avec un seul argument, la documentation précise que randrange(30) choisit dans range(30), c'est-à-dire de $0$ à $29$ : la plus petite valeur possible est $0$, qui ne désigne aucun élève, et l'élève numéro 30 ne serait jamais tiré. L'erreur est double et silencieuse : le programme tourne, les numéros semblent plausibles, et le défaut ne se voit qu'au bout de nombreux tirages. On pourrait aussi écrire randrange(30) + 1, qui décale tout d'un cran : c'est juste, mais moins lisible.

Le troisième paramètre, step, a pour valeur par défaut 1 d'après la signature ; ici il vaut 5. randrange(0, 30, 5) choisit dans range(0, 30, 5), c'est-à-dire $0$, $5$, $10$, $15$, $20$ et $25$ : $6$ valeurs, la plus grande étant $25$, puisque $30$ est la borne exclue. On compte sans les écrire : de $0$ inclus à $30$ exclu, par pas de $5$, il y a $\frac{30-0}{5}=6$ valeurs. Lire une signature, c'est aussi lire ses VALEURS PAR DÉFAUT : stop=None et step=1 disent ce que fait la fonction quand on n'écrit pas ces arguments.

range(10, 10) est vide, puisqu'il s'arrête avant 10 sans avoir commencé : la documentation annonce alors une exception, randrange(10, 10) lève ValueError et le programme s'arrête. randint(10, 10), lui, cherche N tel que $10\leq N\leq 10$ : il existe exactement un tel entier, et l'appel renvoie toujours $10$. La même paire d'arguments donne une erreur pour l'une et un résultat pour l'autre. La rubrique des exceptions fait partie du contrat au même titre que la valeur renvoyée : une fonction appelée hors de ce contrat ne renvoie rien de faux, elle refuse.

floor renvoie le plus grand entier inférieur ou égal à x. Pour $3{,}99$, c'est $3$. Pour $-2{,}5$, les entiers inférieurs ou égaux sont $-3$, $-4$, et ainsi de suite, et le plus grand est $-3$ : floor(-2.5) vaut $-3$. L'idée de l'élève, enlever la partie décimale, donnerait $-2$, or $-2>-2{,}5$ : c'est sur la valeur NÉGATIVE que la documentation lui donne tort, et il ne le verrait jamais en testant $3{,}99$. C'est le même arrondi vers le bas que le quotient entier de l'exercice 1, où -7 // 2 vaut -4.