ère
Informatique 1 année - TP 2 - CORRIGÉ
Fonctions
Exercice 1 : Dé nir les fonctions suivantes, inspirées de programmes du TP précédent :
1. Une fonction somme_entiers(n) qui prend en argument un entier n et renvoie la somme
des entiers de 1 à n .
2. Une fonction carres(n) qui prend en argument un entier n et renvoie la liste des n premiers
carrés parfaits.
3. Une fonction somme_carres(n) qui prend en argument un entier n et renvoie la somme des
carrés des n premiers entiers. Attention : cette fonction devra faire appel aux fonctions dé nies
plus haut. Elle ne devra contenir aucune boucle dans sa dé nition.
4. Une fonction reverse(L) qui prend en argument une liste L et renvoie une liste contenant
les éléments de L dans l'ordre inverse.
Réponse : (consulter le TP1 et son corrigé pour les explications des programmes)
def somme_entiers(n): def carres(n): def reverse(L):
def somme_carres(n):
s=0 L=[] G=[]
C=carres(n)
for k in range(n+1): for k in range(n): for i in range(len(L)):
r=somme(C)
s=s+k [Link](k*k) [Link]( L[len(L)-1-i])
return r
return s return L return G
Instructions conditionnelles
Exercice 2 : Dé nir les deux fonctions ci-dessous, qui prendont en argument une liste de nombres.
def bim(G): def bam(G):
a=0 b=False
for i in range(len(G)): for i in range(len(G)):
if G[i]==7: if G[i]==7:
a=a+1 b=True
return a return b
1. Prédire le résultat de l'appel bim([4,7,2,0,7,7,5]) :
Réponse : On peut regarder le programme équivalent : 1 G=[4,7,2,0,7,7,5]
La condition à la ligne 4 teste si G[0]==7 : elle est fausse. Donc 2 a=0
l'instruction à la ligne 5 n'est pas exécutée. 3 i=0
La condition à la ligne 7 teste si G[1]==7 : elle est vraie. Donc 4 if G[i]==7:
l'instruction à la ligne 8 est exécutée. 5 a=a+1
etc... 6 i=1
Au total l'instruction a=a+1 est exécutée à chaque fois qu'un 7 if G[i]==7:
élément de G est égal à 7, donc 3 fois dans cet exemple. 8 a=a+1
À la n, la variable a vaut 3 et c'est ce résultat qui est renvoyé. (etc...)
2. De façon générale, si L est une liste, quel est le résultat de l'appel bim(L) ?
Réponse : Le résultat renvoyé est le nombre d'élements égaux à 7 dans la liste L reçue en
argument.
3. Prédire le résultat de l'appel bam([4,7,2,0,7,7,5]) :
Réponse : L'instruction b=True est exécutée trois fois, et la variable b ne subit aucun autre
changement. C'est donc la valeur True qui est renvoyée.
1
4. De façon générale, si L est une liste, quel est le résultat de l'appel bam(L) ?
Réponse : Si au moins un élément de la liste vaut 7, alors à la n la variable b vaut True .
Si aucun élément n'est égal à 7, alors la variable b reste égale à False jusqu'à la n. Cette
fonction teste donc la présence d'un 7 dans la liste.
On voit que dans les deux fonctions précédentes, la variable a , de type nombre entier, ou b
de type booléen, sert de marqueur et renferme l'information utile concernant la partie de la liste déjà
parcourue. Sa valeur est mise à jour au fur et à mesure de l'exécution.
Exercice 3 : Utiliser une méthode similaire pour dé nir les fonctions suivantes :
1. dernier_7(L) qui renvoie comme résultat la position du dernier 7 dans la liste L
2. tous_les_7(L) qui renvoie comme résultat la liste des positions où il y a un 7 dans la liste L
3. que_des_7(L) qui renvoie comme résultat un booléen : True si L ne contient que des 7,
False sinon.
Réponse :
def dernier_7(L): def tous_les_7(L): def que_des_7():
pos=-1 P=[] v=True
for i in range(len(L)): for i in range(len(L)): for i in range(len(L)):
if L[i]==7: if L[i]==7: if L[i] != 7:
pos=i [Link](i) v=False
return pos return P return v
Exercice 4 : Que fait la fonction suivante si on lui donne la liste [4,7,2,0,7,7,5] ? (l'opérateur <
signi e bien sûr strictement inférieur en Python)
def boum(L):
v=L[0]
for i in range(len(L)):
if L[i] < v :
v=L[i]
return v
Réponse : Elle renvoie la plus petite valeur de la liste. En eet, tout au long de l'exécution la variable
v est égale à la plus petite valeur rencontrée : à chaque fois qu'une valeur plus petite que v est
rencontrée, on met à jour v avec cette valeur.
Exercice 5 : Dé nir une fonction position_max(L) qui renvoie la position où se trouve le plus grand
élément dans L .
Réponse : On reprend le code de la fonction précédente en faisant quelques changements :
On change le sens de la comparaison pour trouver le plus grand élément et non le plus petit
On ajoute une variable p pour mémoriser, à chaque fois qu'on change la variable v , de quelle
position elle provient.
à la n, on ne renvoie pas v , mais p
def position_max(L):
v=L[0]
p=0
for i in range(len(L)):
if L[i] < v :
v=L[i]
p=i
return p
