Python : calcul des premiers termes d’une suite

Nous allons voir sur cette page comment calculer à l’aide de Python les premiers termes d’une suite, à travers deux exemples.

Calcul des premiers termes d'une suite avec Python
Calcul des premiers termes d’une suite

Exemple 1 : suite définie de façon explicite avec Python

On considère la suite \((u_n)\) définie pour tout entier naturel n par : $$u_n=\frac{n^2+3n+5}{n^2+1}.$$ Nous souhaitons calculer les 50 premiers termes de cette suite. Nous utilisons alors le programme Python suivant:

def u(n):
    return (n*n + 3*n + 5) / (n*n + 1)

for n in range(50):
    print("u({}) = {}".format(n,u(n)))

S’affiche alors :

u(0) = 5.0
u(1) = 4.5
u(2) = 3.0
u(3) = 2.3
u(4) = 1.9411764705882353
u(5) = 1.7307692307692308
u(6) = 1.5945945945945945
u(7) = 1.5
u(8) = 1.4307692307692308
u(9) = 1.3780487804878048
u(10) = 1.3366336633663367
u(11) = 1.3032786885245902
u(12) = 1.2758620689655173
u(13) = 1.2529411764705882
u(14) = 1.233502538071066
u(15) = 1.2168141592920354
u(16) = 1.2023346303501945
u(17) = 1.1896551724137931
u(18) = 1.1784615384615384
u(19) = 1.1685082872928176
u(20) = 1.1596009975062345
u(21) = 1.1515837104072397
u(22) = 1.1443298969072164
u(23) = 1.1377358490566039
u(24) = 1.1317157712305026
u(25) = 1.1261980830670926
u(26) = 1.121122599704579
u(27) = 1.1164383561643836
u(28) = 1.1121019108280255
u(29) = 1.1080760095011877
u(30) = 1.1043285238623752
u(31) = 1.1008316008316008
u(32) = 1.0975609756097562
u(33) = 1.0944954128440367
u(34) = 1.0916162489196197
u(35) = 1.0889070146818924
u(36) = 1.0863531225905936
u(37) = 1.083941605839416
u(38) = 1.0816608996539792
u(39) = 1.0795006570302235
u(40) = 1.0774515927545285
u(41) = 1.0755053507728893
u(42) = 1.0736543909348442
u(43) = 1.0718918918918918
u(44) = 1.0702116675271038
u(45) = 1.0686080947680159
u(46) = 1.0670760510155881
u(47) = 1.0656108597285068
u(48) = 1.0642082429501085
u(49) = 1.062864279766861

J’ai ici utilisé une fonction de formatage d’affichage pour plus de simplicité; quand on tape en python:

print("{} blabla {}".format(var1,var2))

les valeurs des variables var1 et var2 s’affichent à la place des “{}”.

Exemple 2 : suite définie par récurrence (la suite de Héron)

Soit \((v_n)\) la suite définie par son premier terme \(u_0=7\) et par la relation de récurrence:$$u_{n+1}=\frac{1}{2}\left(u_n+\frac{5}{u_n}\right)$$pour tout entier naturel n. Nous souhaitons calculer les 10 premiers termes de cette suite; on utilise alors le programme suivant:

# on commence par initialiser les variables
v = 7
print("v({}) = {}".format(0,v))

# ici commence le programme de seuil
for n in range(1,10):
    v = 0.5 * (v + 5 / v) # on utilise la relation de récurrence pour calculer le terme suivant
    print("v({}) = {}".format(n,v))

S’affiche alors:

v(0) = 7
v(1) = 3.857142857142857
v(2) = 2.5767195767195767
v(3) = 2.258585661049727
v(4) = 2.2361802260811032
v(5) = 2.2360679803170367
v(6) = 2.23606797749979
v(7) = 2.23606797749979
v(8) = 2.23606797749979
v(9) = 2.23606797749979

À savoir : quand on sait combien de termes on doit calculer, on utilise une boucle itérative “for”.

Retrouvez sur cette page d’autres programmes concernant ces suites : algorithmes de seuil.

Exemple 3: la suite de Fibonacci

La suite de Fibonacci est ainsi définie pour tout entier naturel n :$$F_0=0,\ F_1=1,\ F_{n+2}=F_{n+1}+F_n.$$

On voir alors ici qu’on ne fait plus uniquement appel au terme précédent mais aussi au pénultième. Et ceci va poser quelques problèmes. Il faut en effet extrapoler la philosophie utilisée dans les programmes comme celui qui précède (sur la suite de Héron). Voici une proposition:

def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        a, b = 0, 1
        for k in range(2,n+1):
            c = a + b
            a, b = b, c
            
        return c

Il y a dans cette fonction une subtilité : nous avons dû introduire une variable temporaire (c). Regardons étape par étape ce qui se passe pour n=6:

k23456
c0 + 1 = 11 + 1 = 21 + 2 = 32 + 3 = 53 + 5 = 8
a011235
b112358

Ce programme est loin d’être optimal car il nécessite énormément d’opérations (surtout pour les grandes valeurs de n), mais ce n’est pas grave. L”important est de comprendre son fonctionnement (pour les élèves de NSI, il existe des programmes optimisés qui permettent de réduire la complexité, notamment en passant par une liste et en stockant tous les termes dans cette liste).

N’oubliez pas que si vous souhaitez un cours de maths, vous pouvez réserver un cours sur cette page.