Médaille
N°1 pour apprendre & réviser du collège au lycée.
Recherche de seuils - Python
Découvrez, sur SchoolMouv, des milliers de contenus pédagogiques, du CP à la Terminale, rédigés par des enseignants de l’Éducation nationale.
Les élèves de troisième, de première ou de terminale bénéficient, en plus, de contenus spécifiques pour réviser efficacement leur brevet des collèges, leur bac de français ou leur baccalauréat édition 2023.
Fiche méthode

Introduction :

Dans cette fiche, nous allons voir comment programmer en Python un algorithme de seuil pour une suite numérique, c’est-à-dire un algorithme qui permet de donner le rang à partir duquel les termes de la suite respectent une condition donnée.

Par exemple, pour une suite strictement décroissante, qui diverge vers -\infty, nous souhaitons déterminer le rang à partir duquel les termes seront tous strictement inférieurs à une valeur donnée.
Nous commencerons donc par traiter un tel exemple. Puis, pour être complets, nous traiterons aussi le cas d’une suite strictement croissante et majorée – le principe restera toutefois le même. Enfin, un petit exercice d’application conclura le propos.

Dans les deux cas, nous travaillerons avec des suites définies par récurrence, dites arithmético-géométriques. Nous en donnerons ensuite la définition explicite, pour montrer comment alors simplifier l’algorithme.

Suite strictement décroissante qui diverge vers -\infty

Prérequis

Nous considérons la suite (un)(u_n) définie pour tout entier naturel nn par :

{u0=1un+1=1,5un2\begin{cases} u0=1 \ u{n+1}=1,5u_n-2 \end{cases}

Nous admettons que (un)(u_n) :

  • est strictement décroissante ;
  • diverge vers -\infty.

Nous cherchons donc à connaître le rang n0n_0 à partir duquel les termes de la suite sont strictement inférieurs à un réel donné mm.

Algorithme

Nous allons tout simplement demander au programme de calculer successivement les termes de la suite, en partant de u0=1u_0=1, de s’arrêter dès que le dernier terme calculé est strictement inférieur à la valeur indiquée, et d’afficher le rang de ce terme.

  • Commençons par définir notre fonction, que nous nommons  seuildecdiv\purple{\text{ seuil\textunderscore dec\textunderscore div}}, qui prendra en paramètre m\purple{\text{m}}, le nombre auquel les termes de la suite devront être inférieurs.

def seuildecdiv(m):\text{def seuil\textunderscore dec\textunderscore div(m):}

Puis, nous initialisons nos variables :

  • Nous considérons la variable n\purple{\text{n}}, qui contiendra les rangs successifs de la suite.
  • Nous y assignons d’abord la valeur n=0n=0.
  • Puis nous considérons la variable u\purple{\text{u}} qui contiendra la valeur des termes successifs de la suite (dont le rang sera donné par n\purple{\text{n}}).
  • Nous y assignons pour commencer la valeur de u0=1u_0=1.

n = 0u = 1\begin{aligned} &\text{n = 0} \ &\text{u = 1} \end{aligned}
  • Ce que nous souhaitons, c’est que l’algorithme calcule les termes successifs de (un)(u_n) tant qu’ils sont supérieurs ou égaux à m\purple{\text{m}}, et qu’il s’arrête au premier terme strictement inférieur à m\purple{\text{m}}.
  • Nous utilisons pour cela l’instruction while\purple{\text{while}}, avec la condition souhaitée.

while u >= m:\text{while u >= m:}
bannière attention

Attention

Nous voulons savoir quand les termes de la suite deviendront inférieurs à m\purple{\text{m}}, nous calculons donc les termes tant que ce n’est pas le cas.

  • Il faut ainsi bien faire attention au fait que la condition de while u >= m\purple{\text{while u >= m}} est le contraire de ce que nous cherchons : un<mu_n < m.

À l’intérieur de la boucle, nous allons donc calculer le terme suivant de la suite :

  • Nous commençons par incrémenter n\purple{\text{n}}, pour indiquer que nous sommes passés au terme suivant.
  • Puis nous calculons, grâce à la définition de la suite, le terme suivant.

n = n + 1u = 1.5  u - 2\begin{aligned} &\text{n = n + 1} \ &\text{u = 1.5 }^{\ast}\text{ u - 2} \end{aligned}
  • Quand l’algorithme sera sorti de la boucle, la variable n\purple{\text{n}} contiendra donc le plus petit entier n0n0 tel que : un0<mu{n_0} < \purple{\text{m}}.
  • Nous lui demandons donc d’afficher la valeur de n\purple{\text{n}}.

print(n)\text{print(n)}
  • Notre programme est terminé :

1def seuildecdiv(m):2n = 03u = 14while u >= m:5n = n + 16¨C11C¨C12Cu = 1.5  u - 27¨C13C¨C14Cprint(n)\begin{aligned} \textcolor{#A9A9A9}{\text{1}}&\quad\text{def seuil\textunderscore dec\textunderscore div(m):} \ \textcolor{#A9A9A9}{\text{2}}&\quad\qquad\text{n = 0} \ \textcolor{#A9A9A9}{\text{3}}&\quad\qquad\text{u = 1} \ \textcolor{#A9A9A9}{\text{4}}&\quad\qquad\text{while u >= m:} \ \textcolor{#A9A9A9}{\text{5}}&\quad\qquad\qquad\text{n = n + 1} \ \textcolor{#A9A9A9}{\text{6}}&\quad\qquad\qquad\text{u = 1.5 }^{\ast}\text{ u - 2} \ \textcolor{#A9A9A9}{\text{7}}&\quad\qquad\text{print(n)} \end{aligned}
bannière exemple

Exemple

Nous souhaitons connaître le rang à partir duquel les termes de (un)(un) sont strictement inférieurs à 1000-1\,000.
Nous entrons donc la commande seuildecdiv(-1000)\purple{\text{seuil\textunderscore dec\textunderscore div(-1000)}}dec_div(-1000).

  • La fonction affichera en retour : 1515.

Ce que nous interprétons mathématiquement ainsi : pour tout n15n \geq 15 :

un<1000u_n < -1\,000

Remarque : si nous entrons en paramètre m>u0\purple{\text{m}} > u_0, la boucle ne sera pas exécutée et la fonction renverra 00, i.e. tous les termes de la suite vérifient la condition.

bannière astuce

Astuce

Admettons que le terme général de (un)(u_n) est donné, pour tout entier naturel nn, par :

un=3×1,5n+4u_n=-3\times 1,5^n+4

  • Remarquons au passage que cette définition explicite permet de montrer :
  • que la limite de (un)(u_n) est -\infty (par le théorème de la limite de (qn)(q^n), avec q>1q > 1) ;
  • que, pour tout entier naturel nn, un+1un=1,5n+1<0u{n+1}-un=-1,5^{n+1} < 0, autrement dit, que (un)(u_n) est strictement décroissante.

Nous pouvons alors éviter la création de la variable u\purple{\text{u}}, puisque la seule connaissance du rang nn nous permet de connaître la valeur de unu_n.

  • Et nous intégrons alors dans la condition de while\purple{\text{while}} le calcul de unu_n :

1def seuildecdiv(m):2n = 03while -3  1.5n + 4 >= m:4n = n + 15print(n)\begin{aligned} \textcolor{#A9A9A9}{\text{1}}&\quad\text{def seuil\textunderscore dec\textunderscore div(m):} \ \textcolor{#A9A9A9}{\text{2}}&\quad\qquad\text{n = 0} \ \textcolor{#A9A9A9}{\text{3}}&\quad\qquad\text{while -3 }^\ast\text{ 1.5}^{\ast\ast}\text{n + 4 >= m:} \ \textcolor{#A9A9A9}{\text{4}}&\quad\qquad\qquad\text{n = n + 1} \ \textcolor{#A9A9A9}{\text{5}}&\quad\qquad\text{print(n)} \end{aligned}

Suite strictement croissante et majorée

Prérequis

Nous considérons la suite (vn)(v_n) définie pour tout entier naturel nn par :

{v0=2vn+1=0,8vn+5\begin{cases} v0=2 \ v{n+1}=0,8v_n+5 \end{cases}

Nous admettons que (vn)(v_n) :

  • est strictement croissante ;
  • est majorée par 2525 ;
  • converge vers 2525.

Nous cherchons donc à connaître le rang n0n_0 à partir duquel les termes de la suite sont strictement supérieurs à un réel donné mm.

Algorithme

Cette fois, nous allons demander au programme de calculer successivement les termes de la suite, en partant de v0=2v_0=2, de s’arrêter dès que le dernier terme calculé est strictement supérieur à la valeur indiquée, et d’afficher le rang de ce terme.

  • Nous nommons notre fonction  seuilcroismaj\purple{\text{ seuil\textunderscore crois\textunderscore maj}} et elle prendra aussi en paramètre m\purple{\text{m}}, mais ce sera cette fois le nombre auquel les termes de la suite devront être supérieurs.

def seuilcroismaj(m):\text{def seuil\textunderscore crois\textunderscore maj(m):}

Nous allons procéder de même que pour la suite (un)(u_n).

  • Mais, attention, nous avons dit en préambule que (vn)(v_n) est majorée par 2525.
    Cela signifie que, si le paramètre m\purple{\text{m}} entré est supérieur ou égal à 2525 et que nous n’avons pas prévu le cas, alors l’algorithme tournera ad infinitum, jusqu’à ce qu’on l’arrête manuellement.
  • Nous vérifions donc que le m\purple{\text{m}} entré est bien strictement inférieur à 2525, au moyen d’une condition :

if m < 25:\text{if m < 25:}

Comme tout à l’heure, nous initialisons les variables (nous changeons l’ordre cette fois, pour montrer qu’il n’est pas important dans ce cas) :

  • Nous assignons à v\purple{\text{v}} la valeur de v0=2v_0=2.
  • Nous assignons à n\purple{\text{n}} le rang 00.

v = 2n = 0\begin{aligned} &\text{v = 2} \ &\text{n = 0} \ \end{aligned}
  • Dans le cas de (vn)(v_n), qui est strictement croissante, nous souhaitons que l’algorithme s’arrête dès que le dernier terme calculé est strictement supérieur à m\purple{\text{m}}.
  • Nous utilisons l’instruction while\purple{\text{while}}, en faisant bien attention à la condition associée : la boucle s’exécute tant que le dernier terme calculé est inférieur ou égal à m\purple{\text{m}}.

while v <= m:\text{while v <= m:}

Selon le même principe que dans la partie 1, mais là aussi en changeant l’ordre, qui n’est pas non plus important (à vous de voir la logique que vous préférez) :

  • Nous calculons le terme suivant.
  • Nous incrémentons n\purple{\text{n}}.

v = 0.8  v + 5n = n + 1\begin{aligned} &\text{v = 0.8 $^\ast$ v + 5} \ &\text{n = n + 1} \end{aligned}
  • Au sortir de la boucle, n\purple{\text{n}} contiendra le plus petit entier n0n0 tel que : vn0>mv{n_0} > \purple{\text{m}}.
  • C’est cette valeur qui nous intéresse.

print(n)\text{print(n)}
  • Nous allons maintenant dire au programme ce qu’il doit faire si le m\purple{\text{m}} entré est supérieur ou égal à 2525 :

else:\text{else:}
  • Et, dans ce cas, nous demandons simplement à l’algorithme de rappeler que la suite est majorée par 2525 et qu’aucun terme de (un)(u_n) ne sera strictement supérieur au m\purple{\text{m}} entré :

print(La suite est majoreˊe par 25, aucunterme ne sera strictement supeˊrieur aˋ,m)\begin{aligned} & \text{print($^{\backprime\backprime}$La suite est majorée par 25, aucun} \ & \qquad \text{terme ne sera strictement supérieur à$^{\prime\prime}$,} \ & \qquad \text{m)} \end{aligned}
  • L’algorithme est terminé :

1def seuilcroismaj(m):2if m < 25:3v = 24n = 05¨C11Cwhile v <= m:6¨C12C¨C13C¨C14C¨C15Cv = 0.8  v + 57¨C16C¨C17C¨C18C¨C19Cn = n + 18¨C20C¨C21C¨C22Cprint(n)9¨C23C¨C24Celse:10n\purple{\text{n}}¨C26C¨C27Cprint(La suite est majoreˊe par 25, aucun¨C28C¨C29C¨C30Cterme ne sera strictement supeˊrieur aˋ,¨C31C¨C32Cn=0n=0m)\begin{aligned} \textcolor{#A9A9A9}{\text{1}}&\quad \text{def seuil\textunderscore crois\textunderscore maj(m):} \ \textcolor{#A9A9A9}{\text{2}}&\quad\qquad\text{if m < 25:} \ \textcolor{#A9A9A9}{\text{3}}&\quad\qquad\qquad\text{v = 2} \ \textcolor{#A9A9A9}{\text{4}}&\quad\qquad\qquad\text{n = 0} \ \textcolor{#A9A9A9}{\text{5}}&\quad\qquad\qquad\text{while v <= m:} \ \textcolor{#A9A9A9}{\text{6}}&\quad\qquad\qquad\qquad\text{v = 0.8 $^\ast$ v + 5} \ \textcolor{#A9A9A9}{\text{7}}&\quad\qquad\qquad\qquad\text{n = n + 1} \ \textcolor{#A9A9A9}{\text{8}}&\quad\qquad\qquad\text{print(n)} \ \textcolor{#A9A9A9}{\text{9}}&\quad\qquad\text{else:} \ \textcolor{#A9A9A9}{\text{10}}&\quad\qquad\qquad \text{print($^{\backprime\backprime}$La suite est majorée par 25, aucun} \ &\quad\qquad\qquad \text{terme ne sera strictement supérieur à$^{\prime\prime}$,} \ &\quad\qquad\qquad \text{m)} \end{aligned}
bannière exemple

Exemple

Nous souhaitons connaître le rang à partir duquel les termes de (vn)(vn) sont strictement supérieur à 24,9924,99.
Nous entrons donc la commande seuilcroismaj(24.99)\purple{\text{seuil\textunderscore crois\textunderscore maj(24.99)}}crois_maj(24.99).

  • La fonction affichera en retour : 3535.

C’est-à-dire que, pour tout n35n \geq 35 :

24,99<vn<2524,99 < v_n < 25

Remarque : si nous entrons en paramètre m<v0\purple{\text{m}} < v_0, la boucle ne sera pas exécutée et la fonction renverra 00, i.e. tous les termes de la suite vérifient la condition.

bannière astuce

Astuce

Admettons ici que le terme général de (vn)(v_n) est donné, pour tout entier naturel nn, par :

vn=23×0,8n+25v_n=-23\times 0,8^n+25

  • Remarquons là aussi que cette définition explicite permet de montrer :
  • que la limite de (vn)(v_n) est 2525 (par le théorème de la limite de (qn)(q^n), avec 0<q<10 < q < 1) ;
  • que, pour tout entier naturel nn, vn+1vn=4,6×0,8n>0v{n+1}-vn=4,6\times 0,8^n > 0, autrement dit, que (vn)(v_n) est strictement croissante.

Sachant cela, vous pouvez maintenant adapter et simplifier l’algorithme pour qu’il donne le même résultat.

Exercice : suite strictement décroissante et minorée

Soit la suite (wn)(w_n) définie pour tout entier naturel nn par :

{w0=50wn+1=0,7wn+3\begin{cases} w0=50 \ w{n+1}=0,7w_n+3 \end{cases}

On admet que (wn)(w_n) :

  • est strictement décroissante ;
  • est minorée par 1010 ;
  • converge vers 1010.

Créer une fonction seuildecmin\purple{\text{seuil\textunderscore dec\textunderscore min}} (ou du nom qui vous plaira) qui retourne le rang à partir duquel les termes de (wn)(w_n) sont strictement inférieurs à un réel mm donné.

Voici des exemples de retour, pour que vous puissiez vérifier que votre algorithme fonctionne :

  • seuildecmin(15)\purple{\text{seuil\textunderscore dec\textunderscore min(15)}} affiche : 66.
  • seuildecmin(10.5)\purple{\text{seuil\textunderscore dec\textunderscore min(10.5)}} affiche : 1313.
  • seuildecmin(10.1)\purple{\text{seuil\textunderscore dec\textunderscore min(10.1)}} affiche : 1717.
  • seuildecmin(10.001)\purple{\text{seuil\textunderscore dec\textunderscore min(10.001)}} affiche : 3030.
  • seuildecmin(10.0001)\purple{\text{seuil\textunderscore dec\textunderscore min(10.0001)}} affiche : 3737.
  • seuildecmin(9.5)\purple{\text{seuil\textunderscore dec\textunderscore min(9.5)}} affiche : « La suite est minorée par 1010, aucun terme ne sera strictement inférieur à 9.59.5 ».