TP Python n°1 — Suites arithmétiques & géométriques

1

Palier guidé

🔵 Guidé — lire et compléter

🏙️

Contexte — démographie La ville de Villeneuville comptait 15 000 habitants en 2015. Depuis, sa population augmente de 200 habitants par an. On modélise cela par une suite arithmétique : l'année n correspond à 2015 + n.

❓ Exercice 1 — Lire un programme

Un élève a écrit le programme ci-dessous pour connaître la population en 2022 (soit n = 7 ans après 2015). Quelle valeur va-t-il afficher ?

population.py

u0 = 15000
r  = 200
n  = 7
print(u0 + n * r)

A15 200

B16 200

C16 400

D17 400

✅ Bonne réponse : C — le programme affiche 16400.

Python calcule : 15 000 + 7 × 200 = 15 000 + 1 400 = 16 400 habitants. La réponse D (17 400) correspond à n = 12, pas n = 7. La réponse B (16 200) résulte d'une erreur classique : 200 × 6 au lieu de 200 × 7.

✏️ Exercice 2 — Compléter

On veut afficher la population chaque année de 2015 à 2024 (soit n = 0 à 9). Trois éléments manquent dans le code. Complète-les.

exercice2.py

u0 = 15000
r  = 200
for n in range(, ) :
    pop = u0 + n * 
    print(pop)
# affiche 15000, 15200, 15400, ..., 16800

Trou 1 : la boucle doit commencer à n = 0 (année 2015).
Trou 2 : range(0, ?) doit produire les valeurs 0, 1, …, 9 — la borne est exclue.
Trou 3 : la formule est u₀ + n × r — on utilise la variable, pas le nombre brut.

Terminal Python

2

Palier semi-guidé

🟠 Semi-guidé — déboguer et adapter

💶

Contexte — placement financier Léa place 2 000 € sur un compte rémunéré à 3 % par an. Chaque année, son capital est multiplié par 1,03. La valeur de son capital forme une suite géométrique de premier terme u₀ = 2 000 et de raison q = 1,03.

🐛 Exercice 3 — Corriger le code

Un camarade a écrit un programme pour afficher le capital de Léa chaque année, de l'année 0 à l'année 9. Son code contient deux erreurs — repère-les et corrige-les dans les deux champs.

capital_bugue.py

u0 = 2000
q  = 1.03
for n in range(0, 11) :         # ← bug 1
    capital = u0 * q * n    # ← bug 2
    print(capital)

Explique chaque bug et donne la correction :

Bug 1 — range(0, ) remplace 11

Bug 2 — u0 * q n remplace *

Bug 1 : range(0, 11) génère 0, 1, …, 10 — soit 11 valeurs. On veut n = 0 à 9, donc 10 valeurs.
Bug 2 : q * n multiplie q par n — ce n'est pas une puissance. La puissance en Python s'écrit **.

Terminal Python

✏️ Exercice 4 — Adapter

On veut maintenant calculer le capital total accumulé par Léa sur 10 ans, c'est-à-dire la somme u₀ + u₁ + … + u₉. Complète le programme ci-dessous. Quatre éléments manquent.

exercice4.py

u0    = 2000
q     = 1.03
total =         # accumulateur
for n in range(0, ) :
    capital = u0 * q ** n
    total   =  + capital
print()
# doit afficher environ 22927.76

L'accumulateur démarre à 0 (neutre pour l'addition). À chaque tour on fait total = total + capital. Le print est en dehors de la boucle pour n'afficher qu'une seule fois la somme finale.

Terminal Python

❓ Exercice 5 — Raisonner

Léa veut savoir au bout de combien d'années son capital dépasse 2 500 € pour la première fois. Elle modifie son programme pour chercher cela. Lequel de ces codes répond correctement à sa question ?

A

for n in range(0, 20):
    if 2000 * 1.03 * n > 2500:
        print(n)

B

for n in range(0, 20):
    if 2000 * 1.03 ** n > 2500:
        print(n)
        break

C

for n in range(0, 20):
    if 2000 * 1.03 ** n > 2500:
        print(n)
        break

(identique à B — mais avec la bonne puissance ** et un break)

D

for n in range(0, 20):
    if 2000 * 1.03 ** n > 2500:
        print(n)

✅ Bonne réponse : B (ou C, ils sont identiques).

Il faut deux choses : la formule géométrique correcte (1.03 ** n, pas 1.03 * n) et un break pour s'arrêter dès le premier dépassement. Sans break (réponse D), le programme afficherait toutes les années où le capital dépasse 2 500 €, pas seulement la première. La réponse A utilise une multiplication simple au lieu d'une puissance — calcul complètement faux.

Le capital dépasse 2 500 € à n = 9 (soit en 2024) : 2 000 × 1,03⁹ ≈ 2 609 €.

3

Palier autonome

🟣 Autonome — écrire son propre code

🏃

Contexte — entraînement sportif Karim prépare un championnat de 400 m. En semaine 0, son meilleur temps est 72,0 secondes. Grâce à son entraîneur, il améliore son temps de 0,8 seconde par semaine. Son objectif est de passer sous 65 secondes.

⌨️ Exercice 6 — Écrire le code

Écris un programme qui affiche le temps de Karim semaine par semaine, de la semaine 0 à la semaine 12.
Le temps évolue selon une suite arithmétique : tₙ = 72 − 0,8 × n.
En Python, 0,8 s'écrit 0.8.

exercice6.py

corrigé6.py

t0 = 72
r  = -0.8
for n in range(0, 13) :
    t_n = t0 + n * r
    print(t_n)

range(0, 13) génère 0, 1, …, 12 (13 valeurs). La raison est négative car le temps diminue. En Python, -0.8 est valide tel quel.

⌨️ Exercice 7 — Aller plus loin

Améliore ton programme : au lieu d'afficher tous les temps, fais-le s'arrêter dès que Karim passe sous 65 secondes et affiche le numéro de semaine correspondant.

Tu auras besoin de :
— une condition if t_n < 65 :
— l'instruction break pour sortir de la boucle
— print(n) pour afficher la semaine

exercice7.py

corrigé7.py

t0 = 72
r  = -0.8
for n in range(0, 50) :
    t_n = t0 + n * r
    if t_n < 65 :
        print(n)
        break

Karim atteint son objectif à la semaine 9 : t₉ = 72 − 0,8 × 9 = 64,8 s. On peut vérifier algébriquement : 72 − 0,8n < 65 ⟺ 0,8n > 7 ⟺ n > 8,75, donc le premier entier est n = 9.