TP Python – Limites et seuils en Python

BTS SIO SISR 2e année – Pour aller plus loin – S05

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 – Limite d'une suite géométrique

Écris limite_geo(u0, q) qui renvoie la limite de \(u_0 q^n\) : le nombre 0 si \(u_0 = 0\) ou \(|q| < 1\) ; u0 si \(q = 1\) ; la chaîne "+inf" ou "-inf" si \(q > 1\) selon le signe de u0 ; la chaîne "aucune" si \(q \le -1\) et \(u_0 \ne 0\).

###

assert limitepy-undgeo(3, 0.8) == 0bksl-nlassert limitepy-undgeo(2, 1.05) == '+inf'bksl-nlassert limitepy-undgeo(-2, 3) == '-inf'bksl-nlassert limitepy-undgeo(5, 1) == 5bksl-nlassert limitepy-undgeo(1, -1.5) == 'aucune'bksl-nlassert limitepy-undgeo(0, 7) == 0bksl-nlassert limitepy-undgeo(4, -0.5) == 0bksl-nlassert limitepy-undgeo(4, -1) == 'aucune'bksl-nlbksl-nl ∞/∞

def limitepy-undgeo(u0, q):bksl-nl """Limite de u0 py-str qpy-strpy-strn (voir l'enonce)."""bksl-nl ...bksl-nlbksl-nl

Je comprends. Pourquoi q = -1 n'a-t-il pas de limite alors que les valeurs restent bornées ?

Exercice B – Point fixe et formule explicite

Pour \(u_{n+1} = a u_n + b\) avec \(a \ne 1\), écris point_fixe(a, b) qui renvoie \(L = b/(1-a)\) et terme_affine(a, b, u0, n) qui renvoie \(u_n = L + (u_0 - L)a^n\).

J'anticipe. Pour a = 0.5, b = 10, que vaut le point fixe ? Et terme_affine(0.5, 10, 0, 10) ?

###

assert pointpy-undfixe(0.5, 10) == 20bksl-nlassert abs(pointpy-undfixe(0.8, 30) - 150) < 1e-9bksl-nlassert abs(termepy-undaffine(0.5, 10, 0, 10) - 19.98046875) < 1e-9bksl-nlassert abs(termepy-undaffine(0.8, 30, 50, 6) - 123.7856) < 1e-9bksl-nlassert termepy-undaffine(0.5, 10, 0, 0) == 0bksl-nlbksl-nl ∞/∞

def pointpy-undfixe(a, b):bksl-nl """L = b / (1 - a), pour a != 1."""bksl-nl ...bksl-nlbksl-nldef termepy-undaffine(a, b, u0, n):bksl-nl """upy-undn = L + (u0 - L) py-str apy-strpy-strn."""bksl-nl ...bksl-nlbksl-nl

Je comprends. Compare avec une boucle qui applique 10 fois la récurrence : que constates-tu ?

Exercice C – Rang de seuil avec garde-fou

Écris rang_seuil(f, u0, seuil, nmax) qui renvoie le plus petit \(n \le\) nmax tel que \(u_n \ge\) seuil pour \(u_{k+1} = f(u_k)\), ou None si ce rang n'existe pas dans cette limite.

J'anticipe. Pour l'exercice 6 (seuil 25), que doit renvoyer ta fonction ?

###

assert rangpy-undseuil(lambda x: x + 3, 2, 20, 100) == 6bksl-nlassert rangpy-undseuil(lambda x: 0.5 py-str x + 10, 0, 25, 1000) is Nonebksl-nlassert rangpy-undseuil(lambda x: 0.5 py-str x + 10, 0, 19.9, 1000) == 8bksl-nlassert rangpy-undseuil(lambda x: x, 5, 5, 10) == 0bksl-nlassert rangpy-undseuil(lambda x: x + 1, 0, 50, 10) is Nonebksl-nlassert rangpy-undseuil(lambda x: 0.8 py-str x + 30, 50, 120, 100) == 6bksl-nlbksl-nl ∞/∞

def rangpy-undseuil(f, u0, seuil, nmax):bksl-nl """Plus petit n <= nmax avec upy-undn >= seuil, sinon None."""bksl-nl ...bksl-nlbksl-nl

Je comprends. Quel est le variant de ta boucle ? Pourquoi s'arrête-t-elle dans tous les cas ?

Exercice D – Somme qui dépasse un seuil

Écris rang_somme(seuil) qui renvoie le plus petit entier \(n \ge 0\) tel que \(1 + 2 + \dots + n \ge\) seuil (la somme vide vaut 0).

J'anticipe. Pour un seuil de 1 000, quel rang attends-tu (exercice 5) ?

###

assert rangpy-undsomme(1000) == 45bksl-nlassert rangpy-undsomme(1) == 1bksl-nlassert rangpy-undsomme(0) == 0bksl-nlassert rangpy-undsomme(10) == 4bksl-nlassert rangpy-undsomme(11) == 5bksl-nlassert all(rangpy-undsomme(s) py-str (rangpy-undsomme(s) + 1) // 2 >= s for s in range(0, 200))bksl-nlbksl-nl ∞/∞

def rangpy-undsomme(seuil):bksl-nl """Plus petit n >= 0 avec 1 + 2 + ... + n >= seuil."""bksl-nl ...bksl-nlbksl-nl

Exercice E – Stabilisation

Écris rang_stable(f, u0, eps, nmax) qui renvoie le premier rang \(n \le\) nmax tel que \(|u_{n+1} - u_n| <\) eps, ou None. Cela signale qu'une suite se stabilise.

J'anticipe. Pour \(u_{n+1} = 0{,}5u_n + 10\), \(u_0 = 0\) et eps = 0.001, devine à quel rang la suite devient stable (utilise \(u_{n+1} - u_n = 10 \times 0{,}5^n\)).

###

assert rangpy-undstable(lambda x: 0.5 py-str x + 10, 0, 0.001, 1000) == 14bksl-nlassert rangpy-undstable(lambda x: x + 1, 0, 0.5, 50) is Nonebksl-nlassert rangpy-undstable(lambda x: x, 3, 0.1, 5) == 0bksl-nlassert rangpy-undstable(lambda x: 0.8 py-str x + 30, 50, 0.01, 1000) == 35bksl-nlbksl-nl ∞/∞

def rangpy-undstable(f, u0, eps, nmax):bksl-nl """Premier n <= nmax avec |upy-und{n+1} - upy-undn| < eps, sinon None."""bksl-nl ...bksl-nlbksl-nl

Je comprends. Une différence petite entre deux termes prouve-t-elle que la suite converge ? Cherche un contre-exemple.