Explorer les suites numériques
Créez un compte gratuit pour suivre votre avancement et reprendre où vous avez laissé.
Créer un compteLes suites, version Python
En cours de maths, tu manipules des suites $(u_n)$ comme des objets abstraits. Avec Python, tu vas pouvoir les calculer, les stocker et même les dessiner : utile pour vérifier une formule, observer une convergence, ou conjecturer une limite avant de la prouver.
À la fin de cette fiche, tu sauras programmer une suite définie explicitement par $u_n = f(n)$, une suite définie par récurrence par $u_{n+1} = f(u_n)$, calculer une somme partielle $S_n = u_0 + u_1 + \dots + u_n$, stocker les termes dans une liste, et tracer un nuage de points avec matplotlib.
Remarque
Comment lire cette fiche. Tu vas rencontrer deux types d'exercices à la suite des explications :
- Complète le programme — 1 ou 2 mots à compléter, juste après chaque nouveau concept.
- À toi de jouer — un petit programme à finir, en fin de section.
Chaque cellule s'exécute en cliquant sur Exécuter. En cas d'erreur, lis le message rouge : il indique la ligne fautive.
Suites définies explicitement
Une suite est dite explicite quand on connaît une formule directe qui donne $u_n$ en fonction de $n$. Par exemple $u_n = 2n + 3$ ou $u_n = n^2$. En Python, c'est exactement le rôle d'une fonction : on lui donne $n$, elle renvoie $u_n$.
Pour afficher les premiers termes proprement, on combine for et range :
Complète le programme
Définis la suite explicite $v_n = 3n - 5$ et affiche $v_{10}$ :
Voir la solution
def v(n):
return 3 * n - 5
print(v(10))Complète le programme
Complète le programme pour afficher les six premiers termes de $w_n = (-1)^n \times n$ :
Voir la solution
def w(n):
return (-1) ** n * n
for n in range(6):
print(w(n))À toi de jouer
Écris la fonction Python correspondant à la suite $u_n = \dfrac{1}{n + 1}$, puis affiche $u_0, u_1, \dots, u_{9}$ chacun sur une ligne, sous la forme `u(3) = 0.25`.
Voir la solution
def u(n):
return 1 / (n + 1)
for n in range(10):
print('u(', n, ') =', u(n))Remarque
Spécificité Python — les fonctions remplacent la notation mathématique. En maths, $u_n$ est une notation indicielle. En Python, on écrit u(n) avec des parenthèses : c'est un appel de fonction. Conséquence pratique : tu peux composer les suites comme des fonctions classiques, par exemple u(2 * n) ou u(n) + v(n). Les parenthèses sont obligatoires : sans elles, u désigne la fonction elle-même, pas son image en $n$.
Suites définies par récurrence
Une suite est dite récurrente quand on ne connaît pas de formule directe, mais une règle de fabrication : on part d'un terme initial $u_0$ et on passe d'un terme au suivant par $u_{n+1} = f(u_n)$. Pour calculer $u_{10}$, il faut itérer dix fois.
L'idiome Python est une boucle for qui réaffecte la même variable :
À chaque tour de boucle, u perd son ancienne valeur et reçoit la nouvelle. Cela permet de calculer un terme arbitrairement loin sans stocker l'historique.
Complète le programme
Calcule $u_{20}$ pour la suite définie par $u_0 = 100$ et $u_{n+1} = 0{,}9 \times u_n$ :
Voir la solution
u = 100
for n in range(20):
u = 0.9 * u
print(u)Complète le programme
Complète le programme : suite définie par $u_0 = 1$ et $u_{n+1} = 2 \times u_n + 1$. Affiche $u_{10}$.
Voir la solution
u = 1
for n in range(10):
u = 2 * u + 1
print(u)À toi de jouer
Écris une fonction terme(u0, n) qui calcule $u_n$ pour la suite $u_{k+1} = 0{,}8 \times u_k + 2$, partant de $u_0$. Teste avec terme(0, 50) : tu devrais observer une valeur très proche de la limite théorique 10.
Voir la solution
def terme(u0, n):
u = u0
for k in range(n):
u = 0.8 * u + 2
return u
print(terme(0, 50))
print(terme(50, 50))Remarque
Spécificité Python — réaffectation vs mutation. L'instruction u = 0.5 * u + 3 crée une nouvelle valeur et l'assigne à u : l'ancienne est jetée. Pour les types immuables (entiers, flottants, chaînes, tuples), c'est la seule façon de procéder. Cela diffère des langages comme C où l'on peut modifier la mémoire en place. Cette absence de mutation rend le code plus prévisible : aucune fonction extérieure ne peut changer la valeur d'un entier sous tes pieds.
Stocker les termes dans une liste
Si tu veux conserver tous les termes (pour les afficher, les sommer, les tracer), il faut les empiler dans une liste avec append.
Pour une suite explicite, on peut bâtir la liste en une ligne avec une compréhension (un raccourci très Pythonique) :
Complète le programme
Stocke les 12 premiers termes de la suite arithmétique de premier terme 7 et de raison $-2$ dans une liste, puis affiche-la :
Voir la solution
termes = []
u = 7
for n in range(12):
termes.append(u)
u = u - 2
print(termes)Complète le programme
Avec une compréhension de liste, construis la liste des 10 premiers cubes :
Voir la solution
cubes = [n ** 3 for n in range(10)]
print(cubes)À toi de jouer
Écris une fonction liste_termes(u0, n, f) qui prend un terme initial, un nombre de termes voulus et une fonction f représentant la relation $u_{k+1} = f(u_k)$, et renvoie la liste $[u_0, u_1, \dots, u_n]$ (donc $n+1$ termes). Teste-la pour la suite $u_0 = 1$, $u_{k+1} = 1 + 1/u_k$ — tu devrais voir les termes converger vers le nombre d'or.
Voir la solution
def liste_termes(u0, n, f):
termes = [u0]
u = u0
for k in range(n):
u = f(u)
termes.append(u)
return termes
print(liste_termes(1, 10, lambda x: 1 + 1 / x))Remarque
Spécificité Python — la compréhension de liste. L'écriture [u(n) for n in range(10)] se lit littéralement « la liste des u(n) pour n allant de 0 à 9 ». C'est une notation propre à Python (et inspirée des notations mathématiques sur les ensembles), introuvable en C ou Java sans bibliothèque tierce. Elle remplace souvent une boucle for de trois lignes par une seule, plus lisible. Mais elle ne marche que pour les suites explicites : pour une récurrence, il faut une vraie boucle qui mémorise le terme courant.
Sommes partielles
La somme partielle $S_n = u_0 + u_1 + \dots + u_n$ se calcule de deux manières en Python : un accumulateur dans une boucle, ou la fonction native sum appliquée à une liste.
Les deux donnent le même résultat. La seconde forme est plus concise : on dit qu'elle est plus idiomatique.
Complète le programme
Calcule $\displaystyle \sum_{k=1}^{100} k$ avec un accumulateur (résultat attendu : 5050) :
Voir la solution
S = 0
for k in range(1, 101):
S = S + k
print(S)Complète le programme
Même calcul, mais en une ligne avec sum :
Voir la solution
print(sum(k for k in range(1, 101)))À toi de jouer
On considère la suite $u_n = \dfrac{1}{n^2}$ pour $n \geqslant 1$. Calcule $S_{1000} = u_1 + u_2 + \dots + u_{1000}$. Compare avec $\dfrac{\pi^2}{6} \approx 1{,}6449$ — c'est la limite démontrée par Euler.
Voir la solution
S = sum(1 / (n ** 2) for n in range(1, 1001))
print('S_1000 =', S)
print('pi^2 / 6 =', 3.14159265358979 ** 2 / 6)Remarque
Spécificité Python — la précision flottante. Python (comme tous les langages courants) représente les nombres à virgule en flottants IEEE 754, avec une précision finie. Conséquence : 0.1 + 0.2 vaut 0.30000000000000004, pas 0.3. Pour de longues sommes de termes très petits, des erreurs peuvent s'accumuler. Quand la précision compte (cryptographie, finance), on utilise le module decimal ou fractions (qui manipule des rationnels exacts).
Visualiser : un nuage de points avec matplotlib
Une suite est aussi un objet géométrique : on la représente par les points $(n, u_n)$. La bibliothèque matplotlib permet de tracer ce nuage. Le premier import met quelques secondes (le navigateur doit télécharger la bibliothèque), c'est normal.
Tu peux aussi superposer deux suites pour les comparer visuellement :
Complète le programme
Trace les 25 premiers termes de la suite explicite $u_n = \sqrt{n}$. Indice : importe math ou utilise n ** 0.5.
Voir la solution
import matplotlib.pyplot as plt
abscisses = list(range(25))
ordonnees = [n ** 0.5 for n in abscisses]
plt.scatter(abscisses, ordonnees)
plt.grid(True)
plt.show()Complète le programme
Trace la suite récurrente $u_0 = 0$, $u_{n+1} = 0{,}5 \, u_n + 3$ pour $n$ de 0 à 19. Tu dois voir les points s'approcher d'une horizontale.
Voir la solution
import matplotlib.pyplot as plt
termes = []
u = 0
for n in range(20):
termes.append(u)
u = 0.5 * u + 3
plt.scatter(range(20), termes)
plt.grid(True)
plt.show()À toi de jouer
Trace, sur le même graphique, les 30 premiers termes de la suite arithmétique $a_n = 2 + 0{,}5 n$ et de la suite géométrique $g_n = 1{,}1^n$. Ajoute une légende. Observe à partir de quel rang la géométrique dépasse l'arithmétique.
Voir la solution
import matplotlib.pyplot as plt
abscisses = list(range(30))
arith = [2 + 0.5 * n for n in abscisses]
geo = [1.1 ** n for n in abscisses]
plt.scatter(abscisses, arith, label='a(n) = 2 + 0.5 n')
plt.scatter(abscisses, geo, label='g(n) = 1.1^n')
plt.legend()
plt.grid(True)
plt.show()Remarque
Spécificité Python — matplotlib dans le navigateur. Tu utilises ici Pyodide, une version de Python qui tourne entièrement côté navigateur. Matplotlib y est disponible, mais le premier appel à plt.show() télécharge la bibliothèque, d'où la latence initiale. Ensuite, chaque tracé est instantané. C'est très différent d'un Python « classique » sur ordinateur, où matplotlib est installé une fois pour toutes — mais le confort est immense : tu peux explorer une suite sans rien installer, depuis n'importe quel appareil.
Pour aller plus loin
Les générateurs : des suites infinies « paresseuses ». Un générateur Python produit ses valeurs à la demande avec le mot-clé yield. Avantage : tu peux représenter une suite infinie en mémoire constante, et n'en consommer que ce dont tu as besoin.
itertools.accumulate — les sommes partielles en une ligne. Le module itertools regorge d'outils pour les suites. accumulate prend une liste de valeurs et renvoie un itérable des sommes partielles.
Récursivité naïve vs mémoïsation. La suite de Fibonacci est définie par récurrence : $F_0 = 0$, $F_1 = 1$, $F_{n+2} = F_{n+1} + F_n$. La traduction directe en fonction récursive est élégante… mais désastreuse en performances : chaque appel en déclenche deux, ce qui donne $2^n$ appels pour calculer $F_n$. Python offre un décorateur @lru_cache qui mémorise les résultats déjà calculés et transforme l'algorithme exponentiel en linéaire — sans changer le code.
Comparaison avec d'autres langages. En C ou en Java, calculer une suite récurrente demande de typer chaque variable et de gérer manuellement les débordements (un int Java au-delà de $2^{31}$ devient négatif). En Python, fib(500) s'affiche sans broncher : les entiers sont à précision arbitraire. Et la combinaison générateur + lru_cache n'a pas vraiment d'équivalent ergonomique en C.
À toi de jouer
Écris un générateur suite_recurrente(u0, f) qui produit indéfiniment les termes de la suite définie par $u_{n+1} = f(u_n)$. Utilise-le pour afficher les 15 premiers termes de la suite « à la Collatz simplifiée » : $u_0 = 27$ et $u_{k+1} = u_k / 2$ si $u_k$ est pair, $3 u_k + 1$ sinon.
Voir la solution
def suite_recurrente(u0, f):
u = u0
while True:
yield u
u = f(u)
def collatz(x):
if x % 2 == 0:
return x // 2
return 3 * x + 1
gen = suite_recurrente(27, collatz)
for _ in range(15):
print(next(gen), end=' ')Ce que tu as appris
- Une suite explicite $u_n = f(n)$ se traduit par une fonction Python
def u(n): return .... - Une suite récurrente $u_{n+1} = f(u_n)$ se calcule par une boucle qui réaffecte la même variable :
u = f(u). - On stocke les termes dans une liste avec
termes.append(u), ou en une ligne par compréhension :[u(n) for n in range(10)]. - Une somme partielle se calcule avec un accumulateur ou avec
sum(...)sur une compréhension. matplotlib.pyplotpermet de tracer le nuage $(n, u_n)$ :plt.scatter,plt.legend,plt.grid(True),plt.show().- Pour les suites infinies, les générateurs (
yield) et le moduleitertoolssont les outils Pythoniques. - Les flottants ont une précision finie : pour les calculs sensibles, penser au module
decimaloufractions.
Et après…
Tu vas approfondir le tracé de courbes avec matplotlib + numpy — passer du nuage de points discret à la courbe continue d'une fonction, gérer les axes et superposer plusieurs représentations.