Mon espace Me contacter

Spécialité maths, Première • Fiche de révision à Montréal

Fiche de révision : Python en spécialité maths (Première)

Les questions d'algorithmique de la spécialité maths ne testent pas la connaissance de Python : elles testent la compréhension du chapitre de maths qu'elles mettent en scène. Une recherche de seuil est une question sur les suites, un balayage est une question sur la continuité, la méthode d'Euler est une question sur le nombre dérivé.

Cette fiche ne redit pas la syntaxe du langage. Elle montre les huit endroits où les copies se trompent, le code exact à recopier pour chacun, l'arbre qui dit quelle boucle employer selon la question, et un programme de résolution approchée décortiqué étape par étape.

Marque ici la fiche comme lue ou mets-la en favori : un compte gratuit, sans mot de passe, retient tes fiches lues et tes favoris d'une visite à l'autre, te dit quel chapitre attaquer ensuite et te permet de demander la méthode ou l'exercice qui te manque. Crée ton espace, un courriel suffit.

Le fil du chapitre

Un programme ne se lit pas comme une formule : il S'EXÉCUTE, ligne après ligne, et l'ordre des instructions décide du résultat. Les points se perdent toujours au même endroit : le compteur incrémenté au mauvais moment, la boucle choisie avant de savoir si le nombre de tours est connu, et l'égalité de deux décimaux testée avec un signe égal. Et la seule notion nouvelle de Première, la liste, coûte ses points au même endroit : ses indices partent de 0, et on ne la modifie jamais pendant qu'on la parcourt.

Ce chapitre fait partie de Spécialité mathématiques en Première
Pour s'entraîner Les exercices corrigés de ce chapitre, 21 exercices

Avant ce chapitre

Cette fiche suppose ces notions acquises. Si une méthode ci-dessous reste opaque, c'est presque toujours l'une d'elles qui manque, pas la fiche.

Remonter plus loin : la chaîne complète (4 chapitres) ↓

Le chemin de remédiation, du plus ancien au plus proche. Un élève qui reprend ce chapitre de zéro le reprend dans cet ordre.

  1. 1 Algorithmique et Scratch Cinquième
  2. 2 Algorithmique et Scratch Quatrième
  3. 3 Algorithmique et Scratch Troisième
  4. 4 Algorithmique et Python Seconde

L'essentiel

for ou while : la question à poser avant d'écrire une ligne

  • • Le nombre de tours est CONNU à l'avance : boucle bornée, for k in range(n). C'est le cas d'une somme de nn termes, d'un calcul de unu_{n} pour un nn donné, d'un parcours de liste.
  • • Le nombre de tours est INCONNU et dépend d'une condition : boucle non bornée, while condition. C'est le cas d'un seuil, d'un balayage, d'une recherche du premier rang qui vérifie quelque chose.
  • • range(n) produit les entiers de 00 à n−1n-1, donc nn valeurs et pas n+1n+1. range(1, n+1) produit ceux de 11 à nn.
  • • Une boucle while doit contenir une instruction qui fait PROGRESSER la condition vers sa fin, sinon elle ne s'arrête jamais.

En contrôle, la question « à partir de quel rang » appelle toujours un while, et la question « calculer u20u_{20} » toujours un for. Le mot de l'énoncé décide, pas le goût.

Un programme explore, il ne résout pas

  • • Le balayage teste les valeurs une par une, avec un pas fixé, et s'arrête à la première qui convient. Il ne donne jamais la valeur exacte, seulement un ENCADREMENT.
  • • L'amplitude de cet encadrement est exactement le PAS choisi : un pas de 0,010{,}01 donne un encadrement d'amplitude 0,010{,}01.
  • • Le programme renvoie donc deux nombres, la dernière valeur qui ne convenait pas et la première qui convient. Une seule des deux ne répond pas à la question.
  • • Le principe fonctionne parce que la fonction change de signe entre les deux : c'est le théorème des valeurs intermédiaires, appliqué sans être nommé.
0,511,522,53−6−5−4−3−2−112345x = 2 : négatifx = 2,5 : positif
Le balayage teste x=0x=0, puis 0,50{,}5, puis 11... Le signe change entre 22 et 2,52{,}5 : le programme s'arrête là et renvoie cet encadrement, jamais la valeur exacte 5≈2,236\sqrt{5}\approx 2{,}236.

Diviser le pas par 1010 multiplie par 1010 le nombre de tours, donc le temps de calcul. C'est pourquoi la dichotomie existe, même si elle n'est pas au programme de Première.

return, print, et l'ordre des instructions

  • • return RENVOIE une valeur exploitable : x = f(2) place le résultat dans x. print se contente d'AFFICHER, et une fonction sans return renvoie None.
  • • return termine immédiatement la fonction : tout ce qui suit dans le corps n'est jamais exécuté, et un return placé dans la boucle l'interrompt au premier tour.
  • • Dans une recherche de seuil, l'ordre des deux lignes du corps décide du résultat : on met à jour la valeur, PUIS on incrémente le compteur.
  • • L'indentation est une instruction : une ligne moins indentée sort de la boucle et n'est exécutée qu'une seule fois, à la fin.

Le contrôle mental le plus rentable : exécuter le programme à la main sur deux ou trois tours, en écrivant les valeurs des variables dans un tableau. Trente secondes, et la plupart des erreurs apparaissent.

Les décimaux ne sont pas exacts en machine

  • • Un décimal est stocké de façon APPROCHÉE : 0.1 + 0.2 ne vaut pas exactement 0.3, et l'écart, de l'ordre de 10−1710^{-17}, suffit à faire échouer un test d'égalité.
  • • Une condition d'arrêt s'écrit donc toujours avec une INÉGALITÉ, jamais avec ==. On écrit while x*x < 5, jamais while x*x != 5.
  • • Une somme de nombreux petits pas accumule ces écarts : après cent additions de 0,010{,}01, la valeur obtenue n'est pas exactement 11.
  • • Le nombre dérivé approché f(a+h)−f(a)h\frac{f(a+h)-f(a)}{h} se dégrade quand hh devient TROP petit : la soustraction de deux nombres presque égaux perd les décimales significatives.

Ces limites ne sont pas des défauts de Python, elles sont communes à toutes les machines et à toutes les calculatrices. L'énoncé les évoque souvent sous la forme « expliquer ce résultat surprenant ».

Les listes, seule notion nouvelle de Première

  • • Trois façons de GÉNÉRER une liste : en extension, L = [1, 2, 3, 4, 6] ; par ajouts successifs, L = [] puis L.append(x) dans une boucle ; en compréhension, [d for d in range(1, 37) if 36 % d == 0], qui se lit « l'ensemble des dd de 11 à 3636 tels que dd divise 3636 ».
  • • Les INDICES vont de 00 à len(L) - 1 : L[0] est le premier élément, L[4] le cinquième, L[len(L) - 1] le dernier, et L[len(L)] provoque une erreur.
  • • Dans une compréhension, and traduit l'intersection A∩BA\cap B et or la réunion A∪BA\cup B ; le or est INCLUSIF, un élément des deux ensembles est gardé une seule fois.
  • • SUPPRIMER : L.remove(v) retire la première occurrence de la VALEUR v ; L.pop(i) et del L[i] retirent l'élément d'INDICE i. Pour retirer tous les éléments d'un type, on construit une nouvelle liste par compréhension.
  • • PARCOURIR par indices, for i in range(len(L)), quand la position compte (voisins, rang) ; ITÉRER sur les éléments, for x in L, quand seule la valeur compte.

Le programme lie les listes aux ensembles et à la logique : une question sur une liste en compréhension est souvent une question de dénombrement, Card(A∪B)=Card(A)+Card(B)−Card(A∩B)\text{Card}(A\cup B)=\text{Card}(A)+\text{Card}(B)-\text{Card}(A\cap B), déguisée en Python.

Les pièges qui coûtent des points

Les erreurs ci-dessous sont celles que je corrige le plus souvent en séance. Chacune coûte des points sur une copie, même quand le raisonnement est juste.

1. Écrire print là où l'énoncé demande une fonction qui renvoie

1 point sur 3, et toute question qui réutilise le résultat devient impossible

Ce qu'il ne faut pas écrire

def seuil(S): puis, dans le corps, print(n) à la place de return n.

Ce qu'il faut écrire

def seuil(S): puis return n. La fonction renvoie alors une valeur utilisable : r = seuil(290) place 1111 dans r.

Pourquoi : Une fonction qui se contente d'afficher renvoie None. Le repère : si l'énoncé écrit « la fonction renvoie », il faut return; s'il écrit « le programme affiche », print convient.

2. Incrémenter le compteur avant la mise à jour de la valeur

1 point, et la réponse numérique est décalée d'un rang

Ce qu'il ne faut pas écrire

while u < S: puis n = n + 1 puis u = 0.8 * u + 60.

Ce qu'il faut écrire

while u < S: puis u = 0.8 * u + 60 puis n = n + 1. On met à jour la valeur, PUIS on compte le tour qu'on vient de faire.

Pourquoi : Le compteur doit toujours mesurer le nombre de mises à jour DÉJÀ effectuées. Inversé, il compte un tour qui n'a pas encore eu lieu, et le rang renvoyé est celui d'avant le dépassement.

3. Choisir une boucle bornée quand le nombre de tours est inconnu

1 point de méthode, et le programme est faux pour certaines valeurs du seuil

Ce qu'il ne faut pas écrire

for k in range(100): pour chercher le premier rang où la suite dépasse un seuil.

Ce qu'il faut écrire

while u < S: : le nombre de tours dépend de la condition, donc il n'est pas connu à l'avance. Une boucle bornée à 100100 ne répond pas à la question et échoue si le seuil vient plus tard.

Pourquoi : Le choix de la boucle est la première chose que le correcteur regarde. La question « à partir de quel rang », « au bout de combien de temps », « le plus petit entier tel que » appelle toujours un while.

4. Tester l'égalité de deux décimaux

toute la question : le programme tourne indéfiniment

Ce qu'il ne faut pas écrire

while x * x != 5: pour approcher la racine de 55.

Ce qu'il faut écrire

while x * x < 5: : les décimaux étant approchés en machine, x * x ne vaudra jamais exactement 55 et la boucle ne s'arrêterait pas.

Pourquoi : 0.1 + 0.2 ne vaut pas exactement 0.3 en machine, l'écart étant de l'ordre de 10−1710^{-17}. Une condition d'arrêt se compare donc toujours avec une inégalité.

5. Sortir une instruction de la boucle par une indentation

toute la question, et le programme donne 11 quel que soit le seuil

Ce qu'il ne faut pas écrire

Le n = n + 1 écrit au même niveau que le while, donc exécuté une seule fois, après la boucle.

Ce qu'il faut écrire

Toutes les instructions du corps de la boucle sont indentées du même nombre d'espaces, sous le while. L'indentation n'est pas de la présentation, c'est de la syntaxe.

Pourquoi : En Python, l'appartenance d'une ligne à un bloc se lit uniquement sur son décalage. Une ligne sortie de la boucle s'exécute une seule fois : le compteur reste bloqué à 11.

6. Se tromper d'un tour avec range

1 point, et la somme est amputée de son dernier terme

Ce qu'il ne faut pas écrire

for k in range(10): pour calculer la somme des termes u0u_{0} à u10u_{10}.

Ce qu'il faut écrire

for k in range(11): : range(11) produit les entiers de 00 à 1010, soit onze valeurs, autant que de termes à additionner.

Pourquoi : range(n) s'arrête à n−1n-1 et produit nn valeurs. Le comptage est le même qu'en mathématiques : de u0u_{0} à u10u_{10} il y a onze termes, pas dix.

7. Prendre un pas trop petit pour approcher un nombre dérivé

toute la question d'interprétation, qui vaut souvent 2 points

Ce qu'il ne faut pas écrire

« Plus hh est petit, plus le taux d'accroissement est précis, donc je prends h=10−16h=10^{-16}. »

Ce qu'il faut écrire

« La précision s'améliore jusqu'à h≈10−8h\approx 10^{-8}, puis se DÉGRADE : la soustraction de deux nombres presque égaux perd les décimales significatives. Avec h=10−16h=10^{-16}, le taux vaut 00 au lieu de 22. »

−16−14−12−10−8−6−4−20−10−9−8−7−6−5−4−3−2−11h trop grandh trop petitoptimum vers h = 1e-8
En abscisse le logarithme du pas, en ordonnée celui de l'erreur commise sur f′(1)=2f'(1)=2. L'erreur descend jusqu'à h=10−8h=10^{-8}, puis REMONTE : un pas trop petit dégrade le résultat.

Pourquoi : Deux erreurs se combattent : celle du modèle, qui diminue avec hh, et celle de la machine, qui augmente quand hh diminue. Leur somme est minimale pour un hh intermédiaire, et cet arbitrage est exactement ce que l'exercice fait découvrir.

8. Croire que la méthode d'Euler donne la solution exacte

1 point d'interprétation, et souvent la question de comparaison qui suit

Ce qu'il ne faut pas écrire

« Le programme d'Euler donne N(5)=32,8N(5)=32{,}8, donc la quantité restante après cinq jours est 32,832{,}8. »

Ce qu'il faut écrire

« La méthode d'Euler donne une valeur APPROCHÉE, ici 32,832{,}8 contre 36,836{,}8 pour le modèle continu. L'écart vient du pas de calcul, et il diminue quand le pas diminue. »

12345678910102030405060708090100110cercles : Euler, pas = 1courbe : solution exacte
Les cercles sont les valeurs calculées par Euler avec un pas de 11, la courbe est le modèle continu. L'écart se creuse d'un pas au suivant et va toujours dans le même sens.

Pourquoi : Euler remplace la courbe par une suite de segments : à chaque pas, on suppose la pente constante alors qu'elle varie. L'écart s'accumule d'un pas au suivant, toujours dans le même sens pour une décroissance.

9. Oublier d'initialiser une variable avant la boucle

toute la question : le programme s'arrête sur une erreur dès la première ligne du while

Ce qu'il ne faut pas écrire

while u < S: écrit sans avoir donné de valeur de départ à u ni à n.

Ce qu'il faut écrire

u = 200 puis n = 0, AVANT la boucle. Toute variable modifiée dans une boucle doit exister avant d'y entrer.

Pourquoi : La condition du while est évaluée avant le premier tour : elle a besoin de u. Les deux initialisations correspondent d'ailleurs aux deux données de l'énoncé, le premier terme et le rang de départ.

10. Compter les indices d'une liste à partir de 1

le point de la question, et toutes celles qui réutilisent la valeur

Ce qu'il ne faut pas écrire

« L = [1, 2, 3, 4, 6, 9, 12, 18, 36], donc L[4] vaut 44. »

Ce qu'il faut écrire

« Les indices partent de 00 : L[0] vaut 11 et L[4] est le CINQUIÈME élément, 66. Le dernier est L[8], c'est-à-dire L[len(L) - 1]. »

102132436495126187368LindiceL[4] = 6
Les indices commencent à 00 : L[4] est la cinquième case et vaut 66 (vert). La valeur 44 est rangée à l'indice 33 (rouge).

Pourquoi : Une liste de nn éléments a les indices 00 à n−1n-1, exactement comme range(n). Le même décalage se retrouve partout : alphabet.index('e') vaut 44, pas 55.

11. Supprimer des éléments d'une liste pendant qu'on la parcourt

toute la question : le programme affiche [4, 5, 8, 9] sans aucun message d'erreur

Ce qu'il ne faut pas écrire

for x in M: puis if x % 2 == 0: M.remove(x), avec M = [2, 4, 5, 6, 8, 9], pour retirer les nombres pairs.

Ce qu'il faut écrire

M = [x for x in M if x % 2 != 0] : on construit une NOUVELLE liste, qui vaut [5, 9].

Pourquoi : La boucle avance d'un indice à chaque tour pendant que remove décale vers la gauche ce qui suit l'élément retiré : l'élément qui prend sa place est sauté. Ici le 44 puis le 88 échappent au test.

12. Additionner les effectifs de deux conditions reliées par or

1 point, et le raisonnement de dénombrement qui suit

Ce qu'il ne faut pas écrire

« Entre 11 et 4040 il y a 1010 multiples de 44 et 66 multiples de 66, donc la liste des multiples de 44 ou de 66 en contient 1616. »

Ce qu'il faut écrire

« Le or est inclusif : les multiples de 1212, qui sont dans les deux listes, ne sont gardés qu'une fois. La liste contient 10+6−3=1310+6-3=13 éléments. »

4 8 1620 2832 401224366 1830multiples de 4 : 10de 6 : 610 + 6 − 3 = 13
Les multiples de 1212 (vert) sont à la fois multiples de 44 et de 66 : additionner 1010 et 66 les compte deux fois. La liste en contient 1313.

Pourquoi : Une liste en compréhension avec or décrit une RÉUNION d'ensembles. Additionner les cardinaux compte deux fois l'intersection, qu'il faut retirer une fois.

Quelle méthode choisir

Quelle boucle selon la question posée

On cherche une seule chose dans l'énoncé : le nombre de tours est-il connu avant de commencer ?

  • Si « calculer u20u_{20} », « les nn premiers termes », « la somme des nn premiers » → boucle bornée for k in range(n), avec un accumulateur initialisé avant

    Exemple : S = 0 puis for k in range(11): S = S + u(k) donne la somme de u0u_{0} à u10u_{10}

  • Si « à partir de quel rang », « le plus petit entier tel que », « au bout de combien de temps » → boucle non bornée while condition, avec un compteur incrémenté APRÈS la mise à jour

    Exemple : while u < 290: u = 0.8*u + 60; n = n + 1 puis return n

  • Si « donner un encadrement de », « une valeur approchée à 0,010{,}01 près » → balayage : while f(x) < 0: x = x + pas, puis renvoyer x - pas, x

    L'amplitude de l'encadrement est exactement le pas, donc le pas se lit dans l'énoncé.

  • Si « compléter le tableau », « déterminer le maximum de la liste » → boucle bornée avec une variable qui retient le meilleur candidat, initialisée au premier élément

  • Si « modéliser l'évolution », « méthode d'Euler », « pas de temps » → boucle bornée sur le nombre de pas, avec la mise à jour y←y+h f′(y)y\leftarrow y+h\,f'(y) à chaque tour

    Exemple : une décroissance de 20 %20\,\% par unité de temps donne N = N - 0.2*N, soit N = 0.8*N

  • Si « tester si », « déterminer le nombre de solutions » → pas de boucle du tout : un if avec les conditions du cours, par exemple le signe du discriminant

    Exemple : if d > 0: return 2 puis elif d == 0: return 1 puis else: return 0

  • Si « la liste des ... tels que », « les éléments qui vérifient », « retirer les ... » → liste en compréhension avec une condition, [x for x in L if condition], qui construit une NOUVELLE liste au lieu de modifier celle qu'on parcourt

    Exemple : [d for d in range(1, 37) if 36 % d == 0] donne les 99 diviseurs de 3636

Aucune branche ne s'applique ? Relire la question en cherchant le mot qui décrit l'arrêt. S'il n'y en a pas, c'est un for; s'il y en a un, c'est un while.

Quelle vérification selon ce que le programme renvoie

Avant de rendre la copie, on relit le programme en se demandant ce qu'il renverrait sur un cas simple, connu à la main.

  • Si le programme renvoie un RANG → vérifier que la valeur au rang renvoyé franchit le seuil, et que celle du rang précédent ne le franchit pas

  • Si le programme renvoie un ENCADREMENT → vérifier que la fonction change de signe entre les deux bornes, et que leur écart vaut le pas

    Exemple : 2,232=4,97<52{,}23^{2}=4{,}97<5 et 2,242=5,02>52{,}24^{2}=5{,}02>5, avec 2,24−2,23=0,012{,}24-2{,}23=0{,}01

  • Si le programme renvoie une SOMME → encadrer le résultat par le nombre de termes multiplié par le plus petit et par le plus grand

  • Si le programme renvoie une valeur APPROCHÉE d'un modèle continu → comparer à la valeur exacte quand elle est calculable, et commenter le sens de l'écart

    Pour une décroissance, Euler sous-estime systématiquement. Le dire vaut le point d'interprétation.

  • Si le programme ne renvoie rien, ou renvoie None → chercher un print à la place d'un return, ou un return mal indenté, sorti de la fonction

Le meilleur contrôle reste l'exécution à la main : un tableau à trois colonnes, une par variable, et deux tours suffisent à voir un compteur décalé ou une initialisation manquante.

La rédaction attendue

Le correcteur coche des étapes. Les voici dans l'ordre, avec la phrase de conclusion qu'il attend mot pour mot.

Écrire une fonction demandée par l'énoncé

Quand l'utiliser : La question type : « écrire une fonction qui renvoie ... ». Elle vaut souvent trois points et se rédige toujours dans le même ordre.

  1. 1 Recopier la signature exactement telle que l'énoncé la donne, y compris le nom des paramètres. Les changer coûte un point pour rien.
  2. 2 Initialiser TOUTES les variables du corps avant la boucle, en reprenant les données de l'énoncé.
  3. 3 Choisir la boucle : for si le nombre de tours est connu, while sinon, et l'écrire avec sa condition complète.
  4. 4 Écrire le corps de la boucle en respectant l'ORDRE : d'abord la mise à jour de la valeur, ensuite celle du compteur.
  5. 5 Placer le return en dehors de la boucle, au même niveau d'indentation que le while ou le for.
  6. 6 Vérifier à la main sur un cas simple, et écrire cette vérification à côté du programme.

Phrase de conclusion

La fonction seuil(S) renvoie le plus petit entier nn tel que un≥Su_{n}\ge S; pour S=290S=290 elle renvoie 1111, ce qui est cohérent avec u10≈289,3u_{10}\approx 289{,}3 et u11≈291,4u_{11}\approx 291{,}4.

Le piège : Placer le return à l'intérieur de la boucle. La fonction s'arrête alors au premier tour et renvoie toujours 11, quel que soit le seuil demandé.

Barème : 0,5 point pour les initialisations, 1 point pour la boucle et sa condition, 1 point pour le corps dans le bon ordre, 0,5 point pour le return bien placé.

Interpréter le résultat d'un programme

Quand l'utiliser : La question qui suit toujours l'écriture du programme : « interpréter », « que représente le nombre renvoyé », « commenter ce résultat ».

  1. 1 Redire ce que la variable renvoyée représente dans le contexte de l'énoncé, avec son unité.
  2. 2 Donner la valeur numérique obtenue, arrondie comme l'énoncé le demande.
  3. 3 Encadrer la réponse par les deux valeurs voisines quand il s'agit d'un rang ou d'un encadrement.
  4. 4 Dire si la valeur est exacte ou APPROCHÉE, et pourquoi : pas de balayage, pas d'Euler, arrondi machine.
  5. 5 Conclure par une phrase en français qui répond à la question posée, pas au calcul effectué.

Phrase de conclusion

Le programme renvoie 1111 : c'est au bout de onze années que la population dépasse 290290 individus pour la première fois, puisque u10≈289,3<290u_{10}\approx 289{,}3<290 et u11≈291,4≥290u_{11}\approx 291{,}4\ge 290.

Le piège : Recopier la valeur renvoyée sans l'interpréter. Un nombre seul ne répond à aucune question : le point est donné à la phrase, pas au chiffre.

Barème : 0,5 point pour la valeur, 0,5 point pour les deux valeurs encadrantes, 1 point pour la phrase d'interprétation avec l'unité.

Vérifier avant de rendre

Cinq minutes de vérification récupèrent plus de points qu'un exercice de plus commencé à la hâte.

L'exercice type décortiqué

Un encadrement de la racine de 5 par balayage, comme au contrôle

On considère la fonction ff définie sur [0 ; 3][0\ ;\ 3] par f(x)=x2−5f(x)=x^{2}-5. Elle est continue et strictement croissante sur cet intervalle, avec f(2)=−1<0f(2)=-1<0 et f(3)=4>0f(3)=4>0.

1. Compléter la fonction Python balayage(pas) ci-dessous, de façon qu'elle renvoie un encadrement de la solution de f(x)=0f(x)=0 d'amplitude égale à pas. 2. Donner l'encadrement obtenu pour un pas de 0,010{,}01, et le vérifier.

python
def balayage(pas):
    x = 2
    while x * x < 5:
        x = x + pas
    return x - pas, x

Étape 1

Initialisation : x = 2, parce que f(2)=−1<0f(2)=-1<0 et que l'énoncé garantit que la solution est au-delà.

Pourquoi

On part d'une valeur dont on SAIT qu'elle ne convient pas encore. Partir de 00 marcherait aussi mais ferait deux cents tours de plus; partir de 33 ne marcherait pas du tout, la condition étant déjà fausse.

Étape 2

Condition : while x * x < 5, avec une inégalité stricte, jamais while x * x != 5.

Pourquoi

Les décimaux étant approchés en machine, x * x ne vaudra jamais exactement 55 : avec un test d'égalité, la boucle tournerait indéfiniment. C'est le piège le plus coûteux de la question.

Étape 3

Corps : x = x + pas, l'unique instruction qui fait progresser la condition vers sa fin.

Pourquoi

Sans elle, la valeur testée ne change jamais et le programme ne s'arrête pas. C'est la vérification de terminaison, que le correcteur cherche explicitement.

Étape 4

Sortie : return x - pas, x, en dehors de la boucle, au même niveau que le while.

Pourquoi

À la sortie, x est la première valeur qui convient et x - pas la dernière qui ne convenait pas : ce sont exactement les deux bornes de l'encadrement. Renvoyer x seul ne répond qu'à la moitié de la question.

Étape 5

Pour un pas de 0,010{,}01, le programme renvoie le couple (2,23 ; 2,24)\left(2{,}23\ ;\ 2{,}24\right), donc 2,23≤5≤2,242{,}23\le\sqrt{5}\le 2{,}24.

2,202,212,222,232,242,252,26√5 ≈ 2,236amplitude 0,01

Pourquoi

L'amplitude de l'encadrement est exactement le pas. Diviser le pas par 1010 donnerait une décimale de plus, au prix de dix fois plus de tours de boucle.

Étape 6

Vérification : 2,232=4,9729<52{,}23^{2}=4{,}9729<5 et 2,242=5,0176>52{,}24^{2}=5{,}0176>5, et l'amplitude 2,24−2,232{,}24-2{,}23 vaut bien 0,010{,}01. La valeur exacte est 5≈2,236\sqrt{5}\approx 2{,}236, bien dans l'encadrement.

Pourquoi

Trois contrôles indépendants en trente secondes : le signe de chaque borne, l'amplitude, et l'appartenance de la valeur exacte. Aucun ne demande de réexécuter le programme.

Conclusion rédigée

Le programme renvoie l'encadrement 2,23≤5≤2,242{,}23\le\sqrt{5}\le 2{,}24, d'amplitude 0,010{,}01 comme demandé, et ce résultat est confirmé par le calcul des carrés des deux bornes.

L'erreur classique sur cet exercice : Écrire return x au lieu de return x - pas, x. La fonction ne renvoie alors que la borne supérieure, ce qui n'est pas un encadrement : la question demandait deux nombres et la copie n'en donne qu'un.

À savoir par cœur

  • • Nombre de tours connu : for k in range(n). Nombre de tours inconnu : while condition.
  • • range(n) produit les entiers de 00 à n−1n-1, soit nn valeurs. De u0u_{0} à u10u_{10}, c'est range(11).
  • • return renvoie, print affiche. Une fonction sans return renvoie None.
  • • Dans un seuil : on met à jour la VALEUR, puis on incrémente le compteur. Jamais l'inverse.
  • • Le return se place en dehors de la boucle. À l'intérieur, la fonction s'arrête au premier tour.
  • • Toute variable modifiée dans une boucle doit être initialisée AVANT la boucle.
  • • Une condition d'arrêt s'écrit avec une inégalité, jamais avec un test d'égalité entre décimaux.
  • • Un balayage renvoie un ENCADREMENT dont l'amplitude est exactement le pas, jamais une valeur exacte.
  • • Une liste se génère en extension, par ajouts successifs avec append, ou en compréhension avec if.
  • • Indices de 00 à len(L) - 1 : L[4] est le cinquième élément.
  • • remove retire une VALEUR, pop et del retirent un INDICE ; on ne supprime jamais pendant un parcours.

Questions fréquentes

Comment choisir entre une boucle for et une boucle while ?

On se demande si le nombre de tours est connu avant de commencer. Si oui, on prend une boucle bornée avec range. Si le nombre de tours dépend d'une condition à surveiller, comme un seuil à franchir ou un signe à changer, on prend une boucle non bornée. La question à partir de quel rang appelle toujours une boucle non bornée.

Quelle est la différence entre return et print en Python ?

Return renvoie une valeur que le reste du programme peut réutiliser, par exemple en la rangeant dans une variable. Print se contente de l'afficher à l'écran et ne renvoie rien. Une fonction dont le corps ne contient qu'un print renvoie la valeur vide, ce qui rend inutilisable toute question suivante qui s'appuie dessus.

Pourquoi ne faut-il jamais tester l'égalité de deux nombres décimaux ?

Parce que les décimaux sont stockés de façon approchée en machine. La somme de zéro virgule un et de zéro virgule deux ne vaut pas exactement zéro virgule trois, l'écart étant de l'ordre de dix puissance moins dix-sept. Un test d'égalité échoue donc presque toujours, et une boucle qui l'utilise comme condition d'arrêt ne s'arrête jamais.

Où faut-il incrémenter le compteur dans une recherche de seuil ?

Juste après la mise à jour de la valeur, à l'intérieur de la boucle. Le compteur doit mesurer le nombre de mises à jour déjà effectuées. Placé avant, il compte un tour qui n'a pas encore eu lieu et le rang renvoyé est décalé d'une unité, ce qui rend la réponse fausse même si le programme fonctionne.

Pourquoi la méthode d'Euler ne donne-t-elle pas la bonne valeur ?

Parce qu'elle remplace la courbe par une suite de segments : à chaque pas elle suppose la pente constante alors qu'elle varie continûment. L'écart s'accumule d'un pas au suivant et va toujours dans le même sens. Diviser le pas par deux réduit l'écart, sans jamais l'annuler complètement.

Comment retirer plusieurs éléments d'une liste en Python ?

On construit une nouvelle liste en compréhension qui ne garde que les éléments voulus, par exemple les nombres impairs. Retirer les éléments un par un avec remove à l'intérieur d'une boucle qui parcourt la même liste est une erreur classique : chaque suppression décale les éléments suivants, la boucle en saute certains, et le programme renvoie un résultat faux sans afficher d'erreur. Pour un seul élément, remove retire une valeur et pop retire un indice.

Passer à la pratique

Exercices corrigés : Python en spécialité maths

Une méthode se prouve sur une copie, pas sur une fiche. La série du même chapitre reprend chacun de ces pièges dans un exercice, avec le corrigé rédigé étape par étape.

  • 21 exercices corrigés
  • 210 points
  • 315 minutes
Faire les exercices
Il manque quelque chose dans cette fiche ? Une méthode, un piège, un exercice pour l'appliquer, une erreur repérée : dis-le-moi, je lis chaque demande.

L'envoi passe par ton espace gratuit : c'est ce qui me permet de te répondre et de te prévenir quand l'exercice est ajouté. Un courriel suffit, pas de mot de passe. Crée ton espace. Pas envie de créer un compte ? Écris-moi directement.

De quoi s'agit-il ?
Je lis chaque demande moi-même, personne d'autre ne la voit. Inutile d'écrire ton nom ou celui de ton école.
Quand ta demande est traitée, tu es prévenu par courriel et dans ton espace.

En envoyant, tu acceptes que je lise ta demande pour y répondre. Elle est gardée avec ton compte, effacée avec lui, et jamais publiée : politique de confidentialité.

Fiche précédente Les variables aléatoires

Ce chapitre resservira dans

Les chapitres qui le réclament en amont, plus tard dans l'année ou dans les années suivantes.

Python et méthodes numériques Terminale

© Ahmed Squalli Houssaini. Fiche publiée sur www.letuteurscientifique.ca/fiches/1spe-python-sciences. Libre pour l'usage personnel et en classe ; sa republication ailleurs demande une autorisation écrite (mentions légales).

Voir aussi

Toutes les fiches Tous les exercices Spécialité mathsTuteur de mathématiques

Vous cherchez un tuteur à Montréal pour ce chapitre ?

Contactez-moi pour une première séance. On reprend les points de méthode qui font perdre des points en évaluation, puis on les met à l'épreuve sur des exercices du niveau réel de l'examen.

Me contacter WhatsApp
Site par Studio Squalli