15 minutes de Python
Calcul des termes d’une suite récurrente simple
Rappels fondamentaux
En langage Python, une boucle for est utilisée dès que l’on souhaite répéter un bloc d’instructions similaires
un certain nombre de fois, connu à l’avance. La forme la plus classique est :
for i in range(N):
# instructions répétées
La fonction range(N) génère la liste des entiers de \( 0 \) à \( N-1 \).
Si tu veux commencer à un autre entier ou changer le pas, tu peux ajouter des paramètres :
for n in range(debut, fin, pas):
...
Par exemple, dans l’instruction for n in range(2, 10, 2), la variable n prendre successivement les valeurs \( 2, 4, 6, 8 \).
En particulier on peut remarquer que, si l’on souhaite calculer \( u_{10} \) où \( (u_n)_{n \in \mathbb{N} }\) est une suite vérifiant une relation de récurrence du type \( u_{n+1} = f(u_n) \), on est à calculer \( u_1 = f(u_0 ) \) puis \( u_2 = f(u_1) \), …, jusqu’à \( u_{10}=f(u_9) \) ; on effectue donc dix fois la même instruction : calculer l’image par \( f \) du résultat précédent.
On pourra ainsi utiliser une boucle for défiler les rangs d’une suite :
\( n = 0, 1, \ldots, N-1 \) et, à chaque tour, mettre à jour le terme \( u_n \).
Commençons par un exemple simple : une suite arithmético-géométrique. C’est parfait pour comprendre la mécanique “prendre un terme et calculer le suivant”.
Exemple
u = 1.0
a = 0.8
b = 2
N = 5
for n in range(1,N+1):
print("Avant : n =", n, "u=", u)
u = a * u + b
print("Après : n =", n, "u=", u)Explication
Ici, on calcule les premiers termes d’une suite définie par : \( u_0 = 1 \) et par la relation \( u_{n+1} = a\,u_n + b \).
La boucle for fait défiler les rangs
\( n = 1, 1, \ldots, N \) pour \( N=4\). À chaque tour, on calcule le nouveau terme \( u_n \).
Les instructions print permettent ici de montrer les valeurs stockées dans les variables n et u à chaque étape.
Trois commandes utiles aujourd’hui
Clique sur une carte pour voir l’instruction utile.
X > a
Si X est un tableau numpy de valeurs simulées, alors cette instruction :
- compare chaque valeur de
Xau réela, - renvoie un tableau de booléens,
- met
Truequand la valeur est strictement supérieure àa, - et
Falsesinon.
En particulier, np.mean(X > a) donne la proportion de valeurs de X supérieures à a,
ce qui fournit une estimation de la probabilité \(\mathbb{P}(X > a)\).
np.sum(A)
Cette instruction :
- calcule la somme des valeurs du tableau numpy
A, - renvoie un nombre (entier ou flottant selon le cas).
Si A est un tableau de booléens, alors True compte pour 1 et False pour 0 :
np.sum(A) renvoie donc le nombre de cas où la condition est vérifiée.
Par exemple, np.sum(X > 1) compte le nombre de simulations pour lesquelles \(X > 1\).
plt.hist(X, bins=..., density=True)
Cette instruction :
- construit l’histogramme des valeurs contenues dans le tableau
X, - découpe l’axe horizontal en classes (définies par
bins), - compte le nombre de valeurs dans chaque classe.
L’option density=True normalise l’histogramme pour que l’aire totale soit égale à 1 :
on obtient alors une approximation graphique de la densité de la variable aléatoire simulée.
Cela permet de visualiser la loi de X et de la comparer à une densité théorique.
Un exercice pour vérifier ta maîtrise
On considère la suite définie par \( u_0 = 1 \) et par la relation : \[ \forall n \in \mathbb{N},\ u_{n+1} = u_n + \exp\bigl(-\sqrt{n+1}\bigr) \]
Complète le code suivant afin que son exécution demande à l’utilisateur une valeur de \( N \) puis calcule et affiche les valeurs de \( u_0, u_1, \ldots, u_N \).
import numpy as np
u = 1.0
N = int(input("Choisir N : "))
for n in range(N):
print("Avant :", n, u)
u = u + np.exp(-np.sqrt(n + 1))
print("Après :", u)Et pour quelques minutes de plus…
Prendre en main la programmation, pas à pas.
Ces exercices sont conçus pour t’aider à maîtriser progressivement la programmation en Python, en partant de la lecture et de la compréhension du code, jusqu’à l’écriture autonome de scripts complets.
L’objectif n’est pas d’aller vite, mais de construire des automatismes solides, en comprenant ce que fait chaque instruction, puis en apprenant à les utiliser par toi-même.
L’ordre des exercices est volontaire : on lit, on comprend, on complète, puis on écrit seul. Prends le temps de chaque étape : c’est la clé pour progresser durablement.
Niveau 1 Analyser un code
Comprendre avant d’écrire.
Dans cette première série, tu observes et analyses des scripts Python déjà écrits.
L’objectif est de comprendre la logique du programme, le rôle des variables, des boucles
et des conditions, et d’être capable de prévoir ce que le code affiche ou calcule.
Niveau 2 Compléter un code
Écrire, mais avec un cadre.
Ici, tu passes à l’écriture sans partir de zéro.
Le squelette du programme est fourni : il te reste à compléter certaines instructions
pour que le code fonctionne correctement.
Ce format permet de se concentrer sur l’essentiel, sans se perdre dans la structure générale.
Niveau 3 Écrire un code complet
Passer à l’autonomie.
Dans cette dernière série, tu écris un programme complet à partir d’une consigne.
Tu dois organiser ton code, choisir les bonnes instructions et construire la logique globale du script.
C’est ici que tu mets en pratique tout ce que tu as appris dans les niveaux précédents.
Contenu réservé aux membres
Il faut être membre et connecté pour accéder aux exercices et aux corrigés.