ère

Informatique 1 année - TP 1 - CORRIGÉ

Exercice 2 : Si on écrivait une après l'autre dans le shell les lignes suivantes, que répondrait
Python à chaque ligne?
Ligne à saisir Réponse
a=3 Ne répond rien (maintenant a vaut 3)
3+4*2 Réponse : 11
(5-4)/3 Réponse : 0.3333333333333333
b=4+a Ne répond rien (maintenant b vaut 7)
b Réponse : 7
a=b*b Ne répond rien (maintenant a vaut 49)
a=a+1 Ne répond rien (maintenant a vaut 50)
a+b Réponse : 57
Question 3 : Comment peut-on consulter la valeur d'une variable, par exemple la variable a
, en utilisant le shell? Réponse : On écrit dans le shell le nom de cette variable : cela constitue
une expression à évaluer.
Listes
Exercice 4 : Pour chacune des lignes suivantes qu'on écrira dans le shell les unes après les
autres :
 si c'est une expression, prédire la valeur qui sera achée par Python en réponse
 si c'est une instruction, prédire la nouvelle valeur de la variable impactée.
total=3 .................... Ne répond rien ( total vaut maintenant 3) ....................
total=10*total+7 .............. Ne répond rien ( total vaut maintenant 37) ..............
total=10*total+2 ..............Ne répond rien ( total vaut maintenant 372)..............
G=[ 2, 23, [4,5] ] .......Ne répond rien ( G vaut maintenant [2,23,[4,5]] ) .......
L=G+[7,2,5] ........ Ne répond rien ( L vaut maintenant [2,23,[4,5],7,2,5] ) ........
L[0] ........................................Réponse : 2 .......................................
L[7-5] ...............Réponse : [4,5] (c'est l'élément numéro 2 dans L ) ...............
L[ L[0] ] ..............Réponse : [4,5] (c'est l'élément numéro 2 dans L ) .............
L[2][0] .................Réponse : 4 (c'est l'élément numéro 0 dans L[2] ).................
L.append( 6 ) .............. ( L vaut maintenant [2,23,[4,5],7,2,5,6] ) ..............
len(L) ......................Réponse : 7 (le nombre d'éléments de L ) ......................
L[len(L)-2] ........................ Réponse : L[5] c'est-à-dire 5 .........................
L[len(L)-1] .........................Réponse : L[6] c'est-à-dire 6 .........................
H=[] ............... Ne répond rien ( H vaut maintenant [] , une liste vide) ...............
H.append( G[0]+G[1]) ........... Ne répond rien ( H vaut maintenant [25] ) ...........
H.append( G[2]+L[2]) ..... Ne répond rien ( H vaut maintenant [25,[4,5,4,5]] ) .....
L[1+1]=4 ........... Ne répond rien ( L vaut maintenant [2,23,4,7,2,5,6] ) ...........
H[0]=L[1] ............Ne répond rien ( H vaut maintenant [23,[4,5,4,5]] ) ............

1
Calculs répétitifs
Regardons le programme suivant :
s=0
for coco in range(5):
s=s+coco
Les deux dernières lignes sont une boucle : elles sont équivalentes au programme répétitif
ci-dessous, où la variable coco prendra successivement comme valeur tous les entiers naturels
strictement inférieurs à 5, et où l'instruction s=s+coco est répétée à chaque fois :
s=0

coco=0
s=s+coco

coco=1
s=s+coco

coco=2
s=s+coco

coco=3
s=s+coco

coco=4
s=s+coco
Question 5 : Avant d'exécuter le programme, prédire quelle est la valeur de s à la n :
Réponse : La variable s est aectée 6 fois dans le programme : la première fois à 0, puis
à 0, puis 1, puis à 3, puis à 6, puis 10. En fait on a ajouté à s chacune des valeurs prises par
la variable coco : les entiers de 0 à 4.
Question 6 : Si on remplace 5 par 10 dans le programme, quelle sera la valeur nale de
s ?
Réponse : Comme on vient de voir que ce programme ajoute à s chacune des valeurs
prises par coco , le résultat est la somme des entiers de 0 à 9, qui vaut 45.
Exercice 7 : En utilisant un programme inspiré du précédent, calculer la factorielle de 12, c'est
à dire le produit 1 × 2 × 3 . . . × 12.
Réponse : Cette question est plus dicile que prévu car avec la forme vue plus haut, la
variable de boucle doit forcément valoir zéro lors de la première répétition. On peut surmonter ce
problème avec le programme à gauche ci-dessous. Certains l'ont aussi contourné en remplaçant
range(13) par range(1,13) , qui démarre à 1 (programme de droite).
p=1 p=1
for k in range(12): for k in range(1,13):
p=p*(k+1) p=p*k
Exercice 8 : Expliquer ce que fait le programme ci-dessous. Si besoin, commencer par écrire le
programme répétitif équivalent.
L=[]
for k in range(10):
L.append( 2*k+1 )

2
 Réponse : Ce programme construit la liste des 10 premiers entiers naturels impairs :
[1,3,5,7,9,11,13,15,17,19] .
Exercice 9 : En utilisant un programme inspiré du précédent, construire la liste des 100 premiers
carrés parfaits (les carrés des 100 premiers entiers) : 0, 1, 4, 9, 16, . . . 9801
Réponse :
L=[]
for n in range(100):
L.append(n*n)
Exercice 10 : Calculer la somme des 100 premiers carrés parfaits.
Réponse :
s=0
for n in range(100):
s=s+(n*n)
Exercice 11 : Écrire un programme qui calcule la somme des éléments d'une liste L , quels que
soit son contenu et sa longueur. Le programme doit fonctionner aussi bien avec L=[3,1,9,2]
, qu'avec la liste des 100 premiers carrés parfaits, sans qu'on doive l'adapter.
Réponse : On utilise range(len(L)) pour parcourir tous les indices de la liste L :
s=0
for k in range(len(L)):
s=s+L[k]
Exercice 12 : Écrire un programme qui, étant donné une liste L , construit la liste des éléments
de L dans l'ordre inverse. Ainsi si L=[3,1,9,2] ce programme construit la liste [2,9,1,3]
Réponse : On a pu voir plut tôt dans le TP que L[len(L)-1] désigne le dernier élément
de la liste, L[len(L)-2] l'avant dernier. En poursuivant cette logique, L[len(L)-1-k]
donne l'élément numéro k en partant de la n.
G=[]
for k in range(len(L)):
G.append(L[len(L)-1-k])
Exercice 13 : Écrire un programme qui, étant donné une liste L , construit la liste des
variations entre un élement de L et le suivant. Ainsi si L=[3,1,9,2] ce programme construit
la liste [-2,8,-7] (Remarquer que la liste à construire doit avoir un élément de moins que
la liste de départ).
Réponse :
G=[]
for k in range(len(L)-1):
G.append(L[k+1]-L[k])
Exercice 14 : Construire à l'aide d'un programme la liste des 11 premiers multiples de 3 : 0, 3,
6, .. 27, 30
Réponse :
M=[]
for k in range(11):
M.append( 3*k)
Exercice 15 : Construire la table de multiplication sous la forme d'une liste T qui contient dix
listes : les multiples de 0, les multiples de 1, ceux de 2, ceux de 3, etc jusqu'à la liste des multiples
3
de 10. T=[ [0,..,0] , [0,1,2,...,10], [0,2,4,..,18,20], ... , [0,10,20,..,90,100] ]

Réponse : On doit répéter pour chaque entier ce qu'on a fait avec l'entier 3 ci-dessus. On
va donc écrire une boucle qui contient à peu près le programme ci-dessus :
T=[]
for n in range(11):
M=[]
for k in range(11):
M.append(n*k)
T.append(M)