Informatique du Tronc Commun TP no 1

TP no 1 – Processus itératifs simples

PCSI B, Lycée Chaptal

Année scolaire 2022-2023

Durée du TP
Ce TP d’introduction va durer 2 séances d’une heure chacune.

Séance 1 – Activité 1 à 13
Séance 2 – Activité 14 à 21.

Objectifs du TP
• se familiariser avec les processus itératif simples, à savoir deux types de structures de boucles : for et while ;
• comprendre comment et quand les employer.
Pour ce faire, nous allons tout d’abord introduire (ou rappeler) un conteneur indexable très important : les listes.

I Rapide introduction aux listes

En Python, certains objets sont susceptibles d’en contenir d’autres. On appelle ces objets des conteneurs.
Il y a plusieurs types de conteneurs : les chaînes de caractères, les tuples, les listes, les ensembles et les dictionnaires.
Nous allons travailler avec chacun de ces objets petit à petit cette année.
Dans le TP 0 précédent, nous avons déjà manipulé des chaînes de caractères. Commençons par revenir rapidement là-dessus.

1) Les chaînes de caractères

Une chaîne de caractères (ou string en anglais, abrégée en str) est une suite de symboles délimités par les caractères ’
ou ".
Le « kit de survie » des opérations de bases pour manipuler des chaînes de caractères est :

Fonctions de base pour manipuler les chaînes de caractères

• Affecter une chaîne de caractères : A="Bonjour" ;
• Reconnaître le type d’une chaîne de caractères : type(A) ;
• Concaténer deux chaînes de caractères : "Bonjour"+"Au revoir" ;
• Longueur d’une chaîne de caractères : len("Alors ?") ;
• Accéder aux caractères d’une chaîne de caractères : A[0],A[6] pour accéder au premier et 7ième caractère,
A[0:2] pour accéder aux deux premiers caractères.

Activité 1
• Tester rapidement les commandes ci-dessus en les tapant dans la console (shell), en vérifiant que tout fonc-
tionne comme prévu et que vous comprenez chacune des fonctions de base.

1/8
Informatique du Tronc Commun TP no 1

2) Les listes
Une liste (ou list en anglais) est une suite de symboles délimités par les caractères ouvrant [ et fermant ]. Chaque
symbole étant séparé par des virgules.
Le « kit de survie » des opérations de bases pour manipuler des listes est :

Fonctions de base pour manipuler les listes

• Affecter une liste : A=[1,[1,2],"bonjour"] ;
• Reconnaître le type d’une liste : type(A) ;
• Concaténer deux listes : [1,2]+[3,4] ;
• Ajouter/retirer un élément à une/d’une liste : A.append(10) pour ajouter 10 à la fin de la liste, A.insert(2,10)
pour insérer 10 à la troisième position, A.pop(2) pour retirer le deuxième élément de la liste ;
• Longueur d’une liste : len([1,2]) ;
• Accéder aux données d’une liste : A[0], A[1], A[2], A[0:2] pour accéder aux deux premières éléments
d’une liste ou à la sous-liste constituée des deux premiers éléments de la liste ;
• Appartenance à une liste : 1 in A, ou "au revoir" not in A.

Activité 2
• Tester rapidement les commandes ci-dessus en les tapant dans la console (shell), en vérifiant que tout fonc-
tionne comme prévu et que vous comprenez chacune des fonctions de base.

3) Comparaison
On observe de nombreuses différences entre les deux types de conteneurs liste et chaîne de caractères.

Activité 3
• Construire la chaîne de caractères contenant les symboles [1,2],toto et demander le type des 5 premiers
caractères. A contrario, construire la liste contenant la liste [1,2] comme première valeur, et la chaîne de
caractère toto comme deuxième valeur. Quel est le type du premier élément de cette liste ?
• Affecter la chaîne de caractère Dalut à une variable A. On réalise qu’on a fait une coquille : en fait on voulait
rentrer la chaîne de caractères Salut. Pour ce faire, on va modifier la première lettre par A[0]="S". Tester. A
contrario, on va saisir les chaînes de caractères D, a, l, u, t dans une liste que l’on va affecter à la variable A.
On réalise qu’on a fait une coquille (mince !) : en fait on voulait rentrer les chaînes de caractères S, a, l,u, t.
Pour ce faire, on va modifier la première lettre par A[0]="S". Tester.

Chaines de caractères vs listes

Ces deux exemples naïfs mettent en lumière deux différences de fond des conteneurs du type liste et chaîne de
caractères.
• Le premier point de l’activité précédente montre qu’une chaîne de caractère ne contient que des objets du type
chaîne de caractères alors qu’une liste peut contenir des objets de type différents ;
• Le deuxième point de l’activité précédente montre que le conteneur « chaîne de caractères », une fois construit,
ne peut plus être modifié lettre à lettre. On dira qu’il ne peut plus muter ou qu’il est immutable. En revanche,
le conteneur liste, une fois construit, peut être modifié, entrée par entrée. On dira qu’il peut muter ou qu’il
est mutable. Cette question s’appelle la mutabilité des conteneurs. Nous la reverrons plus tard dans l’année
quand nous parlerons des tuples et des dictionnaires.

2/8
Informatique du Tronc Commun TP no 1

II Processus itératifs par boucle for

1) La syntaxe de base
Un processus itératif de type for est une répétition (« loop en anglais pour « boucle), d’une chaîne d’instructions définies,
paramétrée par une variable qui parcourt un certain conteneur - le nombre d’éléments de ce conteneur étant fini (comme
toute chose en informatique), ce nombre d’éléments donne le nombre d’itérations de cette répétition.
La syntaxe est la suivante :
for <ma variable> in <mon conteneur>:
<espace d’indentation> <bloc d’opérations>
On retrouve dans cette syntaxe :
1. <ma variable> qui est la variable parcourant les valeurs contenues dans le conteneur (donc un nombre fini de va-
leurs) ;
2. <mon conteneur> qui est le conteneur parcouru par la variable paramétrisant l’itération ;
3. <espace d’indentation> cet espace doit être toujours le même et indique à l’interpréteur que le <bloc d’opérations>
appartient à l’itération et doit être répété itérativement autant de fois que défini par le paramètre.

Modification de l’itérateur
De manière très générale, et indépendamment du langage Python, il est fortement déconseillé de modifier, à l’inté-
rieur de la boucle, la variable de l’itération et/ou le conteneur que la variable parcourt durant l’itération.

Activité 4
• Affecter la chaîne de caractères "Bonjour" à une variable. À l’aide d’une boucle for, ajouter un espace entre
chaque lettre du mot ;
• Construire une fonction mytype prenant en argument une liste L et renvoyant la liste des types de chacun des
éléments de L. Tester.

2) L’itérateur range
Dans l’activité précédente, nous avons construit des itérations à l’aide des deux types de conteneurs itérables que nous
connaissons : les chaînes de caractères et les listes. Il est parfois plus pratique de travailler avec un paramètre d’itération
qui est un entier et qui varie tout simplement entre deux valeurs entières.
Pour ce faire, Python possède l’itérateur range.

L’itérateur range
L’itérateur range(<n>), où <n> désigne la valeur d’un entier, retourne un itérateur sur les n premiers entiers positifs,
à savoir 0, . . . , n − 1. Il existe quelques variantes dont les plus utiles sont :
• range(debut,fin) retourne un itérateur sur les entiers supérieurs ou égaux à debut et inférieurs strictement
à fin ;
• range(debut,fin,pas) retourne un itérateur permettant de travailler sur les entiers supérieurs ou égaux à
debut et strictement inférieurs à n de pas en pas, avec pas un  entier. Autrement
 dit, mathématiquement : tous
f in − debut
les entiers de la forme debut + i · pas pour i variant de 0 à E (E(·) désignant la fonction partie
pas
entière).

3/8
Informatique du Tronc Commun TP no 1

Pour utiliser l’itérateur range dans une boucle for, on tapera :

for <ma variable> in range(<paramètres du range>):

Activité 5
• Calculer la somme A des 1/k pour les k premiers entiers inférieurs ou égale à 100 ;
• Calculer la somme B des 1/k pour les k premiers entiers pairs inférieurs ou égale à 100 (sans utiliser de test
if) ;
• Calculer la somme C des 1/k pour les k premiers entiers impairs inférieurs ou égale à 100 (sans utiliser de
test if) ;
• Vérifier si A = B + C.

Activité 6
• Calculer le produit des 10 premiers entiers strictement positifs.

Activité 7
• Écrire une fonction harmonique prenant un entier strictement positif n en argument et calculant la somme :
n
X 1
k
k=1

En évaluant cette fonction pour de grandes valeurs de n, quelle est votre hypothèse quant à la convergence ou
à la divergence de cette suite ?

Activité 8
• Écrire une fonction mymax prenant une liste en argument et renvoyant le maximum des éléments de cette liste ;
• Tester cette fonction sur des listes comportant des nombres entiers ou flottants ;
• Tester cette fonction sur une liste de chaînes de caractères ;
• Qu’observez-vous ? Que pouvez-vous en conclure ?

3) Construction de listes par compréhension

Il existe un autre cas de figure, extrêmement pratique, dans lequel apparaît une itération à l’aide du constructeur for.
C’est le cas de la construction d’une liste par compréhension.
En mathématiques, vous apprenez qu’il existe deux façons d’exprimer un ensemble abstrait :
• par extension, i.e. en listant ces éléments, par exemple : 2N = {2k, k ∈ N} ;
• par compréhension, i.e. en exprimant les éléments de l’ensemble comme ceux vérifiant une certaine propriété, par
exemple : 2N = {k ∈ N, 2|k}.

Listes par compréhension

Il existe une façon de plagier la construction par extension sous Python en construisant une liste par compréhension
de la manière suivante :
[<ma fonction>(<ma variable>) for <ma variable> in <mon conteneur>
if <ma propriete>(<ma variable>)]
n√ o
Par exemple, k ∈ N, 2|k & k ∈ [1, 20[ s’écrit sous Python [np.sqrt(k) for k in range(1,20) if k%2==0] ou
[np.sqrt(k) for k in range(2,20,2)].

Activité 9
• Afficher la liste des carrés des entiers pairs entre 1 et 100 inclus, générée par compréhension.

4/8
Informatique du Tronc Commun TP no 1

Activité 10
• Écrire une fonction mydiviseur d’argument un entier n et renvoyant une liste contenant tous les diviseurs de
cet entier. Tester.

Activité 11
• Visualiser dans une liste les 100 premières valeurs de la série harmonique déjà étudiée précédemment Sn =
n
X 1 exp(Sn )
. Afin de confirmer l’heuristique de l’activité 7, affichez la liste des 1 000 premières valeurs de .
k n
k=1
Qu’observez-vous ?

Activité 12
Suite de Fibonacci
• Écrire une fonction myfibonacci prenant en argument un entier n et calculant le n-ième terme de la suite de
Fibonacci définie par : 
Fn+2 = Fn+1 + Fn
F1 = 1 et F0 = 0
Afficher les n premières valeurs de la suite dans une liste. Analyser la divergence en considérant cette fois-ci
ln(Fn )
. Quelle est votre heuristique ?
n

Activité 13
Calcul de moyenne/écart type d’un échantillon du générateur aléatoire de Python
• Générer, par compréhension, une liste de 1 000 entiers aléatoires compris entre 1 et 100. Pour cela, on chargera
le module random et on utilisera la fonction randint(1,100) ;
• Calculer la moyenne et l’écart type de cette distribution. On rappelle que la moyenne d’une distribution
(xi )i=1,...,n vaut
n
1X
x= xi
n i=1

et l’écart type vaut v

u n
u1 X
σ=t (xi − x)2 .
n i=1

5/8
Informatique du Tronc Commun TP no 1

III Processus itératifs par boucle while

1) Compréhension
Il existe des cas où nous souhaitons répéter une chaine d’opérations mais il est difficile de connaitre à l’avance le
conteneur dans lequel le paramètre de la boucle va itérer. C’est notamment le cas quand le nombre d’itération à faire est
inconnu. Dans ce cas, nous utiliserons le constructeur while (qui signifie en français « tant que »).
Précisément, un processus itératif de type while est une répétition d’une chaine d’instructions définies, paramétrée par
une variable. Cette chaine d’instructions est exécutée tant qu’une certaine condition portant sur la variable est validée. À
chaque passage de la chaine d’instruction, la variable est modifiée. On ne parle donc plus d’itérateur pour la variable car la
modification de la variable à chaque itération n’est plus nécessairement de la forme i ←− i + pas.

La syntaxe de la boucle while est

while <ma condition>(<ma variable>):
<espace d’indentation> <1ère ligne d’instruction>
<espace d’indentation> <2ème ligne d’instruction si nécessaire>
...

Terminaison d’une boucle while

La force de ce processus itératif est de pouvoir itérer une chaîne d’opérations même lorsque le nombre d’itérations à
faire n’est pas connu, ce qui permet de s’adapter à de nombreuses situations. En revanche, le danger est que, si une
boucle while est mal codée, il peut en résulter une itération infinie. Il faudra dans ce cas interrompre l’exécution
par CTRL-C dans le shell de Python. Afin d’éviter cela, on s’assurera théoriquement de la terminaison de l’itération.

On retrouve dans cette syntaxe :

1. <ma variable> qui est la variable qui sera modifiée à chaque itération.
2. <ma condition> est la condition booléenne qui termine l’itération dès que celle-ci renvoit la valeur False quand elle
est appliquée à <ma variable>.
3. <espace d’indentation> est un espace devant toujours être le même.
Il indique à l’interpréteur que le <bloc d’instructions> appartient à l’itération et doit être répété itérativement
autant de fois que défini par <ma condition>.

Activité 14
• On considère la liste liste=[12,8,5,17,14,13] et le code qui suit
1 k = liste [5]
2 j =4
3 while liste [ j ] > k :
4 j =j -1
5 print ( j )
Prévoir ce qui va s’afficher, puis le tester.
• Tester avec liste=[12,8,5,17,14,4].
Que s’affiche-t-il et pourquoi ? Modifier alors le code afin de supprimer le comportement non souhaité.

Activité 15
• Reprendre le calcul de la moyenne et de l’écart type d’un échantillon du générateur aléatoire de Python (der-
nière question de l’activité 13) et écrire les instructions permettant ces calculs à l’aide d’une boucle while.

6/8
 Informatique du Tronc Commun TP no 1

Activité 16
• Écrire une fonction, qu’on appellera f permettant de déterminer (et renvoyer) le plus petit entier p tel que
Xp
k 2 ≥ n, fonction qui dépend de n ;
k=1
• La tester avec des valeurs faibles de n, puis avec n = 21334.

Ainsi, on utilisera préférentiellement une boucle for lorsque le nombre d’itérations est connu préalablement, et une
boucle while lorsque ce nombre d’itérations est inconnu.

2) Utilisation de la combinaison de touches CTRL et I simultanément

Activité 17
• Essayer de deviner ce que renvoie le programme suivant. Vérifier ensuite en le tapant sous Python.
1 num =1
2 while num <=12:
3 print ( num )
4 num *=2
5 print ( " Enfin dehors " )
6 print ( num )

Activité 18
• Que se passe-t-il si, dans le programme précédent, on initialise num avec la valeur nulle ?
• Deviner à quoi sert le titre de la question en lançant le programme malgré tout ;
• Que se passe-t-il si, dans le programme précédent avec num=1, la ligne num*=2 est remplacée par num/=2 ?
• Que se passe-t-il si, dans le programme précédent avec num=1, la ligne num*=2 n’est pas indentée ?

Ainsi, par exemple :

• tout code du type while True:<n’importe quoi> génèrera probablement une boucle infinie ;
• de même tout code du type while <ma condition>(x): <des opérations qui ne font pas varier x> génèrera
une boucle infinie si tant que est <ma condition>(x) est vraie.
On donne le code suivant
1 num =5
2 while True :
3 if num <2:
4 print ( ’ Il est temps de sortir ’)
5 break
6 print ( num )
7 num -=1
8 print ( ’ Enfin dehors ’)

Activité 19
• Quelle est le risque du code précédent ? Le taper et vérifier. Expliquer le comportement ;
• Modifier légèrement le code afin que celui-ci soit plus lisible. Vérifier qu’il fonctionne exactement comme le
précédent.

3) Calcul de pgcd par l’algorithme d’Euclide

On veut écrire une fonction mypgcd qui prend en arguments deux entiers strictement positifs a et b avec a > b et qui
renvoie le pgcd de a et b. L’algorithme (que vous expliquerez en cours de maths) est le suivant :

7/8
Informatique du Tronc Commun TP no 1

1. Initialisation : r0 = a, r1 = b ;
2. Itération : rn+1 est le reste de la division euclidienne de rn−1 par rn ;
3. Terminaison : la suite des restes est strictement décroissante et positive. On s’arrête quand le reste rn+1 = 0. Dans ce
cas, le résultat est rn .
On rappelle que le reste de la division euclidienne de n par m s’obtient en Python par : n%m

Activité 20
• Écrire la fonction mypgcd prenant 2 entiers en arguments a et b, et renvoyant le pgcd ;
• Combien d’itérations y a-t-il au maximum dans cet algorithme ?
• Modifiez votre fonction mypgcd en une fonction mypgcd2 qui retourne non pas le pgcd mais le nombre d’itéra-
tions nécessaires pour le calculer ;
• Calculer le nombre d’itérations moyen pour a=100 et b variant entre 1 et 99.

4) La suite de Syracuse
La suite de Syracuse est la suite suivante : on part d’un entier strictement positif quelconque u0 ∈ N∗ , ensuite :
( un
un+1 = si un est pair
2
un+1 = 3un + 1 sinon.

La conjecture de Syracuse (1928) stipule que pour tout entier de départ u0 il existe un entier n pour lequel un = 1.

Activité 21
• Écrire une fonction mysyracuse qui prend l’entier u0 en paramètre et qui renvoie la liste de toutes les valeurs
de la suite jusqu’à la première valeur où un vaut 1, soit

[u0 , u1 , . . . , un−1 = 2, un = 1]

L’itération while que vous allez utiliser terminera donc de manière... conjecturale !
• La longueur de cette liste s’appelle la « durée de vol » en partant de l’entier u0 et le maximum de cette liste
s’appelle « l’altitude maximale ». Essayez donc de voler sur une durée supérieure à 100 itérations !

8/8