Suites arithmétiques et géométriques avec Python: commençons par les suites arithmétiques

Calcul des premiers termes

Une suite arithmétique est une suite dans laquelle chaque terme est obtenu à l’aide du précédent auquel nous ajoutons une constante (la raison). Je vous encourage à regarder la fiche de cours sur les suites avant de poursuivre.

Première méthode: liste des premiers termes

Pour calculer les premiers termes d’une suite arithmétique, on peut alors définir une fonction comme suit:

def suite_arithmetique(terme , raison , indice_final):
    U = [ terme ]
    for n in range(indice_final):
        terme += raison
        U.append( terme )
    
    return U

Expliquons cette fonction:

• Pour commencer, la fonction se nomme « suite_arithmetique » et possède 3 arguments : le premier est nommé « terme » (il va correspondre au premier terme de la suite que l’on connait), le deuxième est nommé « raison » et correspond à la raison de la suite, et le dernier est nommé « indice_final » et correspond à l’indice du dernier terme que l’on souhaite connaître.
• On commence par définit une liste nommée « U » qui contient le premier terme de la suite (ligne 2), donc \(u_0\).
• Ensuite, on créée une boucle « for » comportant « indice_final » itérations car il faudra calculer \(u_1\), \(u_2\), … , \(u_n\) (il y a bien n termes à calculer).
• Dans cette boucle, on ajoute au terme connu la raison (ligne 4), puis on l’insère dans la liste (avec la méthode « append », ligne 5).
• Une fois la boucle terminée, la fonction retourne la liste U obtenue, qui contient alors tous les termes.

Cela donne par exemple, pour la suite arithmétique de premier terme \(u_0=3\) et de raison r = 5:

>>> suite_arithmetique(3,5,20)
[3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53, 58, 63, 68, 73, 78, 83, 88, 93, 98, 103]

Autre méthode: affichage des premiers termes

Si on ne souhaite pas avoir de liste, mais un simple affichage, on peut utiliser une méthode plus directe, comme celle-ci:

n = 0
u = 3
r = 5

print(f'u({n}) = {u}')

for n in range(20):
    u = u + r
    print(f'u({n+1}) = {u}')

qui affiche:

u(0) = 3
u(1) = 8
u(2) = 13
u(3) = 18
u(4) = 23
u(5) = 28
u(6) = 33
u(7) = 38
u(8) = 43
u(9) = 48
u(10) = 53
u(11) = 58
u(12) = 63
u(13) = 68
u(14) = 73
u(15) = 78
u(16) = 83
u(17) = 88
u(18) = 93
u(19) = 98
u(20) = 103

J’ai ici utilisé un formatage pour plus de lisibilité (voir page sur les formatages).

En utilisant la formule explicite

On sait que \(u_n=u_0+nr\) donc on peut utiliser cette formule pour afficher les premiers termes:

u = 3 # premier terme
r = 5 # raison
for n in range(21): # de u(0) à u(20), il y a 21 termes à calculer
    print(f'u({n}) = {u + n*r}')

ce qui donne le même affichage que précédemment.

Somme des premiers termes d’une suite arithmétique

Première méthode: avec la liste des premiers termes

Nous allons ici utiliser la fonction suite_arithmetique vue précédemment:

def somme(U):
    S = 0
    for terme in U:
        S += terme
        
    return S

J’ai donc ici défini une fonction nommée « somme » qui admet un unique argument nommé « U »: une suite définie préalablement par la fonction suite_arithmetique.

Ainsi, pour calculer la somme de tous les termes, il suffit de parcourir cette suite (qui est une liste) et d’ajouter tous les termes rencontrés (ligne 4). Il ne faut donc pas oublié avant de rentrer dans la boucle de définir une variable « S » (qui désignera la somme) et de lui attribuer la valeur 0 (car au début, la somme est nulle).

On obtient alors:

>>> U = suite_arithmetique(3,5,20)
>>> somme(U)
1113

Autre méthode: calculs directs

Si l’on n’aime pas les listes, on peut aussi procéder ainsi:

n = 0
u = 3 # premier terme
r = 5 # raison
S = 3 # somme initiale égale au premier terme

for n in range(20):
    u = u + r
    S = S + u
    
print(S)

On s’inspire de ce qui a été fait précédemment pour le calculs des premiers termes: on ajouter une variable « S » (pour la somme), et dans la boucle, on calcule le terme suivant de la suite et on l’ajoute à la somme. Cela donne:

1113

En utilisant la formule explicite

u = 3
r = 5
S = 0

for n in range(21):
    S = S + u + n*r # à la valeur de S précédente, on ajoute le nouveau terme (u + nr)
    
print(S)

Avec la fonction native « sum » (dans certains cas)

sum( range(5,516,2) )

Une manière plus simple est d’utiliser la fonction native sum. Dans l’exemple ci-dessus, nous ajoutons tous les termes de la suite arithmétique de raison r = 2 et de premier terme 5, jusqu’au terme 515.

>>> sum( range(5,516,2) )
66560

Suites arithmétiques et géométriques avec Python: finissons par les suites géométriques

Il ne va pas y avoir beaucoup de choses de changées par rapport à ce que nous venons de voir pour les suites arithmétiques. Il suffit juste de changer les méthodes de calculs des termes.

Calcul des premiers termes

Méthode avec liste

def suite_geometrique(terme , raison , indice_final):
    U = [ terme ]
    for n in range(indice_final):
        terme *= raison
        U.append( terme )
    
    return U

Regardons ce que cela donne avec l’exemple d’une suite géométrique de premier terme \(u_0=24\) et de raison \(q=\frac{1}{2}\):

>>> suite_geometrique(24,0.5,20)
[24, 12.0, 6.0, 3.0, 1.5, 0.75, 0.375, 0.1875, 0.09375, 0.046875, 0.0234375, 0.01171875, 0.005859375, 0.0029296875, 0.00146484375, 0.000732421875, 0.0003662109375, 0.00018310546875, 9.1552734375e-05, 4.57763671875e-05, 2.288818359375e-05]

Méthode directe avec la formule par récurrence

n = 0
u = 24 # premier terme
q = 0.5 # raison

print(f'u({n}) = {u}')

for n in range(20):
    u = u * q
    print(f'u({n+1}) = {u}')

qui donne:

u(0) = 24
u(1) = 12.0
u(2) = 6.0
u(3) = 3.0
u(4) = 1.5
u(5) = 0.75
u(6) = 0.375
u(7) = 0.1875
u(8) = 0.09375
u(9) = 0.046875
u(10) = 0.0234375
u(11) = 0.01171875
u(12) = 0.005859375
u(13) = 0.0029296875
u(14) = 0.00146484375
u(15) = 0.000732421875
u(16) = 0.0003662109375
u(17) = 0.00018310546875
u(18) = 9.1552734375e-05
u(19) = 4.57763671875e-05
u(20) = 2.288818359375e-05

Méthode directe avec la formule explicite

u = 24
q = 0.5

for n in range(21):
    print(f'u({n}) = {u*q**n}')

Somme des premiers termes

Avec les listes

La fonction somme(U) définie plus haut peut être utilisée pour n’importe quel type de suite, donc rien de nouveau:

>>> U = suite_geometrique(24,0.5,200)
>>> somme(U)
47.99999999999999

Méthode directe avec la formule de récurrence

n = 0
u = 24 # premier terme
q = 0.5 # raison
S = 24 # somme initiale égale au premier terme

for n in range(200):
    u = u * q
    S = S + u
    
print(S)

47.99999999999999

Méthode directe avec la formule explicite

u = 24
q = 0.5
S = 0

for n in range(201):
    S = S + u*q**n

print(S)