Corrigé du TD I2 Programmation en Python

Lycée Bellevue – Toulouse Année 2016-2017
PCSI 2 – Informatique
Corrigé du TD I2
Programmation en Python
Exercice 6 du cours I2.
# a.
def Somme(L):
"""renvoie la somme des éléments de la liste L."""
S=0
for kin range(len(L)):
S=S+L[k]
return S
# b.
def NbPositifs(L):
"""renvoie la nombre d’éléments positifs dans la liste L."""
c=0 # compteur
for ain L:
if a>=0:
c=c+1
return c
# c.
def Moyenne(L):
"""renvoie la moyenne des éléments de la liste L."""
return Somme(L)/len(L)
# d.
def MoyennePositifs(L):
"""renvoie la moyenne des éléments positifs de la liste L."""
S=0
c=0 # compteur
for ain L:
if a>=0:
S=S=a
c=c+1
if c>0:
return S/c
else:
return 0
page 1/13

PCSI 2 – Informatique Corrigé du TDI2 - Programmation en Python
# e.
def TestAppartenance(x,L):
"""Teste si x est dans L."""
B=False # booléen
for ain L;
if a==x:
B=True
return B
Exercice 1.
a. La fonction NbSup renvoie le nombre d’éléments de la liste Lstrictement supérieurs
au nombre a. En effet, le compteur nest initialisé à 0 (ligne 3), puis incrémenté
(ligne 6) à chaque fois qu’un élément xde Lest strictement supérieur à a(ligne 5).
b. On obtient la liste [6,5,4,3].
c. On obtient la liste [8,8,4,0].
d. La fonction trie la liste qu’elle reçoit dans l’ordre décroissant.
Exercice 2.
# a.
def Maximum(L):
"""renvoie le maximum de la liste de nombres L."""
mp=L[0] # maximum potentiel
for xin L:
if x>mp:
mp=x
return mp
# b.
def PositionMaximum(L):
"""renvoie la position du maximum de la liste de nombres L."""
mp=L[0] # maximum potentiel
i=0 # sa position
for kin range(len(L)):
if L[k]>mp:
mp=L[k]
i=k
return i
page 2/13

PCSI 2 – Informatique Corrigé du TDI2 - Programmation en Python
Exercice 3.
def PremierNonNul(A):
"""Renvoie la position du premier entier non-nul de A,
ainsi que sa position.
A est supposée ne pas contenir que des zéros."""
k=0
while A[k]==0:
k=k+1
return k,A[k]
Exercice 4.
# a.
def TestPositifs(L):
"""Teste si la liste L ne contient que des nombres positifs."""
B=True # booléen
for ain L:
if a<0:
B=False
return B
# b.
def TestCroissante(L):
"""Teste si la liste L est rangée dans l’ordre croissant."""
B=True
for kin range(len(L)-1):
if L[k]>L[k+1]:
B=False
return B
# c.
def TestConstante(L):
"""Teste si la liste L est constante."""
B=True
for kin range(1,len(L)):
if L[k]!=L[0]: # tous les éléments doivent être égaux au premier
B=False
return B
page 3/13

PCSI 2 – Informatique Corrigé du TDI2 - Programmation en Python
# d.
def Testdistincts(L):
"""Teste si la liste L ne contient que des éléments distincts."""
B=True
for kin range(len(L)-1):
for jin range(k+1,len(L)):
if L[k]==L[j]: # chaque élément est comparé à tous les suivants
B=False
return B
Exercice 5.
# a:
def Moyenne(S):
"""renvoie la moyenne de la série statistique S."""
Somme=0
for ain S:
Somme=Somme+a
return Somme/len(S)
# b:
def EcartType(S):
"""renvoie l’écart-type de la série statistique S."""
Somme=0
m=Moyenne(S)
for ain S:
Somme=Somme+(a-m)**2
return (Somme/len(S))**(1/2)
# c:
def Mode(S):
"""renvoie le mode de la série statistique S."""
nma=0 # nombre maximum d’apparition d’un élément de S
for ain L:
# Comptage du nombre d’apparitions de a
c=0 # compteur
for bin L:
if a==b:
c=c+1
# a est-il le plus fréquent des nombres déjà rencontrés ?
if c>nma:
nma=c
m=a # a est le mode
return m
page 4/13

PCSI 2 – Informatique Corrigé du TDI2 - Programmation en Python
# d:
def Mediane(S):
"""renvoie la médiane de la série statistique S."""
L=sorted(S) # tri de S
n=len(L)
if n%2==1:
return L[n//2]
else:
return (L[n//2-1]+L[n//2])/2
Exercice 6.
# a:
def u(n):
"""renvoie le terme n de la suite définie par
u(0)=2 et u(n+1)=(u(n)**2+1)/(2*u(n)+3))."""
u=2 # initialisation
for kin range(n):
u = (u**2+1) / (2*u+3)
return u
# b:
def U(n):
"""renvoie la liste des n premiers termes de la suite définie par
u(0)=2 et u(n+1)=(u(n)**2+1)/(2*u(n)+3))."""
u=2 # initialisation de la suite
U=[u] # initialisation de la liste
for kin range(n):
u = (u**2+1) / (2*u+3)
U.append(u)
return U
Exercice 7.
# a:
def TestConvergence(U):
"""Teste si la suite U est convergente,
ie si ses 100 derniers termes sont égaux au dernier à 1e-3 près."""
lim=U[-1] # limite potentielle de la suite
CV=True # booléen, vrai si U est convergente
for kin range(100):
if abs(U[-1-k]-lim)>1e-3:
CV=False
return CV
page 5/13