Représenter des suites

Chapitre
1
Représenter des suites
1.1
1.1.1
Algorithme
Suite définie par une formule explicite
Par exemple on souhaite représenter la suite un = 1 +
On utilise une fonction :
(−1)n
.
n
fonction : u(E: n de type entier, S: U de type réels)
début
(−1)n
U ←1+
n
Retourner U
Algorithme 1: Suite un = 1 +
(−1)n
n
Écrire cet algorithme en python.
1.1.2
Suite définie par récurrence
Par exemple on souhoite par exemple obtenir les termes de la suite
On représente une suite à l’aide d’une fonction.





un+1 =
u0 = 0
fonction : u(E: n de type entier, S: un de type réel)
Variable : U de type réel
début
U ←0
pour i allant de 1 à n faire
U ← (2 × U + 3)/(U + 4)
Retourner U
Algorithme 2: Suite un
Traduire cet algorithme en python. Aide : attention range(n) va de 0 à n-1
Modifions cet algorithme pour obtenir une liste des termes de la suite (un ).
Entrées : n
fonction : u(E: : n de type entier, S: L : liste de n+1 réels)
Variable : U de type réel
début
S[0] ← 0
Pouri allant de 1 à n
Ajouter (2 × S[i] + 3)/(S[i] + 4) à S.
Retourner S
Algorithme 3: Suite un
1
2 ∗ un + 3
un + 4
1.2
Avec python3
1.2.1
Suite définie par une formule explicite
Par exemple pour la suite un = 1 +
(−1)n
on utilise la fonction :
n
def u(n):
U=1+(-1)**n/n
return U
Tester cette fonction.
1.2.2
Suite définie par récurrence
Par exemple on souhaite représenter la suite





un+1 =
u0 = 0
2 × un + 3
un + 4
Avec affectations
On définie la suite à l’aide d’une fonction
def u(n):
U=0
for i in range(1,n+1):
U=((2*U+3)/(U+4))
return U
On teste cette fonction.
Pour afficher les onzes premières valeurs on appliquera une boucle for.
for i in range(11):
print(``u_{}={}''.format(i,u(i)))
Il souvent utile d’obtenir à la liste de tous les termes de la suite (un ) jusqu’à n à l’aide d’un
tableau.
Modifier la fonction comme ceci
# renvoie la liste
def u(n):
U=[0] # u_0=0
for i in range(1,n+1):
U.append( (2*U[i-1]+3)/(U[i-1]+4))
return U
s=u(11)
print(s)
print(s[-1]) # c'est le dernier
Il existe un module pour faire du calcul formel sous python, c’est sympy.
import sympy
sympy.simplify(1+3/2)
sympy.simplify('1+3/2')
Vous avez compris le principe ?
def u(n):
U=0
for i in range(1,n+1):
U=sympy.sympify("(2*{0}+3)/({0}+4)".format(U) )
return U
print(u(11))
Essayer de modifier la fonction précédente pour retourner une liste de u0 à un sous forme exacte.
def v(n):
U=[0]
for i in range(1,n):
U.append( sympy.sympify( "(2*{0}+3)/({0}+4)".format(U[i-1]) ))
return U
Fonction récursive
Les fonctions récursives existe sous python mais sachez que certain langages comme le lisp sont
plus performant avec des programmes récursif que python ne l’est.
def u(n):
if n==0:
return 0
# c'est u_0
else:
return (2*u(n-1)+3)/(u(n-1)+4)
print(u(11))
Et en utilisant sympy
def u(n):
if n==0:
return 0
else:
return sympy.sympify("(2*{0}+3)/({0}+4)".format(u(n-1)))