Seuils

Une boucle while est particulièrement adaptée aux questions qui commencent par « à partir de quand ? » ou « combien d’étapes faut-il ? ». On ne connaît pas forcément à l’avance le nombre de répétitions : c’est la condition d’arrêt qui le détermine.

Dès la première

Trouver un premier rang

Dépasser un seuil

On considère :

\[u_0=1 \qquad\text{et}\qquad u_{n+1}=2u_n.\]

On cherche le plus petit entier \(n\) tel que \(u_n>100\).

Exemple

Premier rang au-dessus de 100

Prêt

u = 1 n = 0 while u <= 100: u = 2*u n = n + 1 print("n =", n) print("u_n =", u)

▶ Exécuter Effacer la sortie

Sortie

La condition de la boucle décrit la situation dans laquelle on doit continuer : tant que \(u_n\leqslant100\), le seuil recherché n’est pas encore franchi.

La boucle s’arrête sur la première valeur située au-delà du seuil.

Atteindre une valeur cible

Le même mécanisme peut compter le nombre d’étapes d’une évolution plus simple.

Exemple

Ajouter 3 jusqu’à 50

Prêt

x = 5 n = 0 while x < 50: x = x + 3 n = n + 1 print("Nombre d'étapes :", n) print("Valeur finale :", x)

▶ Exécuter Effacer la sortie

Sortie

En changeant la valeur initiale de x, il faut prévoir si le nombre d’étapes devrait augmenter ou diminuer.

Seuil sur une suite arithmétique

On considère :

\[u_0=2 \qquad\text{et}\qquad u_{n+1}=u_n+5.\]

On cherche le plus petit rang tel que \(u_n\geqslant50\).

Exemple

Suite et seuil

Prêt

u = 2 n = 0 while u < 50: u = u + 5 n = n + 1 print("n =", n) print("u_n =", u)

▶ Exécuter Effacer la sortie

Sortie

Le terme précédent doit être strictement inférieur à 50. Cette vérification confirme que le rang trouvé est bien le premier.

Étudier un comportement

Dès la terminale

Entrer dans un voisinage d’une limite connue

⏸

⏸

On considère la suite définie par \(u_0=0\) et

\[u_{n+1}=\frac12u_n+1.\]

On sait qu’elle converge vers 2. Le programme suivant ne découvre donc pas la limite : il cherche le premier rang pour lequel \(u_n\) est à moins de 0,01 de 2.

La fonction abs(x) donne la valeur absolue de x. Ainsi, abs(u - 2) mesure ici la distance entre \(u_n\) et 2.

Exemple

Se rapprocher de 2

Prêt

u = 0 n = 0 while abs(u - 2) > 0.01: u = 0.5*u + 1 n = n + 1 print("u_n =", u) print("n =", n) print("écart =", abs(u - 2))

▶ Exécuter Effacer la sortie

Sortie

0.01 est la précision demandée. Remplace-la par 0.001 : la boucle doit effectuer davantage d’itérations.

Une suite qui grandit sans limite

Pour \(u_0=1\) et \(u_{n+1}=1{,}5u_n\), la suite grandit sans limite. Cela ne signifie pas que le programme doit tourner indéfiniment : on choisit un seuil concret, ici 1000.

Exemple

Premier dépassement de 1000

Prêt

u = 1 n = 0 while u <= 1000: u = 1.5*u n = n + 1 print("n =", n) print("u_n =", u)

▶ Exécuter Effacer la sortie

Sortie

Avec les seuils 100 puis 10 000, le rang augmente, mais le programme conserve une condition d’arrêt précise.

Observer une stabilisation numérique

Lorsque la limite n’est pas utilisée dans la condition, on peut comparer deux termes consécutifs. Pour certaines suites convergentes, des termes successifs très proches donnent une indication numérique de stabilisation.

Cette observation n’est pas une preuve générale de convergence : une suite peut évoluer très lentement ou avoir un comportement plus compliqué. Il faut donc l’utiliser dans un contexte mathématique identifié.

Dans l’exemple suivant, u et suivant conservent deux termes consécutifs de la suite définie par \(u_0=1\) et \(u_{n+1}=0{,}5u_n+2\).

Exemple

Comparer deux termes consécutifs

Prêt

u = 1 suivant = 0.5*u + 2 while abs(suivant - u) >= 0.01: u = suivant suivant = 0.5*u + 2 print("Valeur obtenue :", suivant) print("Écart :", abs(suivant - u))

▶ Exécuter Effacer la sortie

Sortie

À chaque passage, l’ancien terme suivant devient le terme actuel, puis un nouveau terme est calculé. Diminue 0.01 et vérifie que l’écart final respecte la précision demandée.

Comparer et modéliser

Comparer deux évolutions

Une recherche de seuil peut aussi comparer deux grandeurs. Deux offres proposent, après n mois, les tarifs \(A_n=30+2n\) et \(B_n=18+3{,}5n\). On cherche le premier mois à partir duquel la première devient strictement moins chère.

Exemple

Comparer deux tarifs

Prêt

n = 0 offre_a = 30 offre_b = 18 while offre_a >= offre_b: n = n + 1 offre_a = 30 + 2*n offre_b = 18 + 3.5*n print("Premier mois :", n) print("Tarifs :", offre_a, "et", offre_b)

▶ Exécuter Effacer la sortie

Sortie

La comparaison des valeurs au rang précédent permet de contrôler qu’il s’agit bien du premier mois convenable.

Une condition décalée

Le programme suivant doit chercher le premier terme strictement supérieur à 100, mais il s’arrête trop tôt. Il s’exécute sans message d’erreur : c’est le résultat qu’il faut contrôler.

À corriger

Corriger le cas frontière

Erreur attendue

u = 4 n = 0 while u < 100: u = u + 12 n = n + 1 print(n, u)

▶ Exécuter Effacer la sortie

Sortie

Comment chercher ?

La valeur 100 doit-elle faire continuer ou arrêter la boucle ? Compare les mots « strictement supérieur » avec l’opérateur utilisé dans la condition, puis vérifie aussi le terme précédent.

Modéliser une situation

Les programmes de seuil interviennent naturellement dans des questions de capital, d’endettement, de population ou de décroissance. Le modèle mathématique doit être choisi avant d’écrire la boucle : Python calcule les conséquences du modèle, mais ne décide pas si celui-ci décrit correctement la situation réelle.

Choisir la condition d’arrêt

Quatre recherches fréquentes

Question	La boucle continue tant que…	Contrôle utile
dépasser un seuil	la valeur est encore sous le seuil	vérifier le terme précédent
approcher une limite connue	la distance à la limite est trop grande	afficher l’écart final
observer une stabilisation	deux termes consécutifs sont trop éloignés	ne pas confondre observation et preuve
comparer deux évolutions	l’ordre recherché n’est pas encore atteint	comparer également le rang précédent

Exercices

Exercice 1

Partir de u = 1 et doubler la valeur. Déterminer le premier rang pour lequel elle dépasse 1000.

À toi

Doubler jusqu’à 1000

À faire

▶ Exécuter Effacer la sortie

Sortie

Exercice 2

Partir de x = 2 et ajouter 5 tant que x < 100. Déterminer le nombre d’étapes nécessaires et afficher également la valeur finale.

À toi

Ajouter 5 jusqu’à 100

À faire

▶ Exécuter Effacer la sortie

Sortie

Exercice 3

On considère \(u_0=10\) et \(u_{n+1}=0{,}8u_n\). Déterminer le plus petit rang tel que \(u_n<1\).

À toi

Premier terme inférieur à 1

À faire

▶ Exécuter Effacer la sortie

Sortie

Exercice 4

On considère \(u_0=4\) et \(u_{n+1}=0{,}5u_n+1\). Calculer les termes jusqu’à ce que la différence entre deux termes consécutifs soit inférieure à 0.001, puis afficher la valeur obtenue.

Dans cette situation, la suite converge et cette valeur donne une approximation numérique de sa limite. Pour réutiliser ce principe avec une autre relation, on peut aussi prévoir un nombre maximal d’itérations : une erreur dans la condition ne doit pas pouvoir créer une boucle sans fin.

À toi

Observer la stabilisation

À faire

▶ Exécuter Effacer la sortie

Sortie

Exercice 5

Écrire une fonction premiere_puissance(a, seuil) qui renvoie le plus petit entier naturel n pour lequel \(a^n\) est strictement supérieur à seuil. La fonction sera testée avec plusieurs valeurs de a strictement supérieures à 1.

À toi

Première puissance suffisante

À faire

▶ Exécuter Effacer la sortie

Sortie

Exercice 6

Un capital de 1 000 € augmente de 2 % chaque année. Écrire une fonction capital_seuil(S) qui renvoie le premier nombre d’années nécessaire pour que le capital soit supérieur ou égal à S. Tester avec 1 200 € puis 1 500 €.

À toi

Évolution d’un capital

À faire

▶ Exécuter Effacer la sortie

Sortie

Exercice 7

Deux populations sont modélisées par \(u_0=500\), \(u_{n+1}=1{,}08u_n\) et \(v_0=800\), \(v_{n+1}=v_n+20\). Déterminer le premier rang auquel u dépasse strictement v et afficher les deux valeurs à ce rang.

À toi

Comparer deux populations

À faire

▶ Exécuter Effacer la sortie

Sortie

Exercice 8

Un emprunt de 10 000 € est soumis chaque mois à un intérêt de 0,4 %, puis un remboursement fixe de 300 € est versé. Simuler l’évolution du capital restant dû et déterminer le nombre de mensualités nécessaires pour le rembourser. La dernière mensualité ne doit pas rendre le capital négatif dans le modèle affiché.

À toi

Remboursement d’un emprunt

À faire

▶ Exécuter Effacer la sortie

Sortie

Dans le parcours

← Page précédente : suites

Page suivante : simulations →