polyINF204 2020

INF204
Méthodes informatiques et techniques de programmation en Python

Responsables d’UE : Lydie du Bousquet et Julie Peyre
Polycopié créé conçu à partir de documents conçus par :

Lydie du Bousquet, Aurélie Lagoutte, Julie Peyre,
Florent Bouchez Tichadou, Amir Charif,
Grégoire Cattan, Emna Mhiri
2019-2020
2
Table des matières
1 Transparents de cours 5
2 Exercices de TD 33
2.1 Premiers programmes, variables, instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.2 Boucles while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.3 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.4 Fonctions (consolidation) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.5 Listes et révision des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.6 Boucles for - quelques exercices complémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.7 Dictionnaires et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.8 Révisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3 Sujets de TP 51
3.1 TP1 : prise en main des outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.2 TP2 : modules, boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.3 TP3 : boucles, dessin avec turtle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.4 TP4 et TP5 : fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.5 TP6 et TP7 : listes, boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
3.6 TP8 : Fichiers, dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4 Annales et fiche mémo 79
3
4 TABLE DES MATIÈRES
Chapitre 1
Transparents de cours
5
Introduction Variables et expressions In/Out Si... sinon
Présentation UE
• Objectifs :
– comprendre et utiliser des schémas algorithmiques . . .
– . . . en utilisant le langage Python 3
INF204 - Semaine 1 • Organisation, chaque semaine :
– 2 TD d’1h30
– 1 TP de 3h en classe entière (encadré environ 2h30)
Université Grenoble Alpes
• Évaluation : pour toutes les évaluations, une fiche mémo sera
fournie (voir en fin de poly)
2019-2020 – CC1 : devoir surveillé écrit (semaine des partiels) 20%
2016-2017 INF204 Semaine 1 1 / 27 – CC2 : évaluation de projet 20%
– Examen écrit 60% (règle du max seulement en session 2)
INF204 Semaine 1 1 INF204 Semaine 1 2
Introduction Variables et expressions In/Out Si... sinon Introduction Variables et expressions In/Out Si... sinon
Un outil de travail : CaseInE Notions de la semaine :

CaseInE est une plateforme d’apprentissage en • Introduction :
ligne
– algorithme, programme
http://caseine.org
– Interpréteur, compilateur
• Quelques exercices à faire chaque semaine • Variables
• Vous pouvez demander de l’aide à votre enseignant, qui a
– expressions
accès à vos programmes – expressions booléennes
• Certains exercices de CaseInE seront demandés au partiel et à • Entrées / Sorties
l’examen (au moins un à chaque épreuve)
• Instructions conditionnelles
Compilation et interprétation Algorithme vs Programme

• L’ordinateur permet d’automatiser des tâches • Problème complexe: travail en 2 temps
• Mais il faut utiliser un programme 1. Résolution du problème
– syntaxe précise dans un langage donné lisible par l’humain en s’autorisant syntaxe approximative, fautes
– doit être transformé en un texte lisible par la machine d’orthographe, abréviations (et en s’aidant avant avec des
(suite d’octets) → compilateur ou interpréteur
schémas) => algorithme
• compilateur : traduit une fois pour toute le code
2. Rédaction de la solution finale
source en exécutable
produire le programme qui permettra de faire faire ce qui
• interpréteur : traduit au fur et à mesure à chaque est demandé à l’ordinateur
lancement du programme interprété
• Notion d’algorithme est plus générale :
• Python est un langage interprété cuisine, protocole expérimental, indications routières…

Exercice Programmes en Python

• Donner l’algorithme pour faire une omelette • Deux modes d’exécution d’un code Python
(un seul œuf) – utiliser l’interpréteur Python, instruction par
instruction, un peu à la façon d’une calculatrice
• Préciser
– les ingrédients nécessaires,
– les ustensiles nécessaires,
– les actions à mener (dans l’ordre) – écrire un ensemble d’instructions dans un fichier
puis on l’exécute (via un interpréteur Python)
Variables Identificateurs en Python

• Conteneur d’information • Suite non vide de caractères
– commençant par une lettre ou le caractère _
• Identifié par un nom = un identificateur – contenant seulement des lettres, des chiffres et/ou le caractère _
– Ne peut pas être un mot réservé de Python
• Ayant un « contenu » • Exemples d’identificateurs
– valides : toto, proch_val, max1, MA_VALEUR, r2d2, bb8, _mavar
– non valides : 2be, C-3PO, ma var
• Les identificateurs sont sensibles à la casse : ma_var != Ma_Var
• Conventions pour les variables en Python :
– utiliser des minuscules
– pas d’accents
Affectation Exemple
• Pour mémoriser une valeur dans une variable,
on fait une affectation en utilisant le signe =
• Exemples :
n = 33 ch = "bonjour"
a = 42 + 25 euro = 6.55957
• L’identificateur (à gauche de =) reçoit la valeur (à La valeur d’une variable peut changer
droite du =; l’expression doit d’abord être évaluée). au cours de l’exécution d’un programme
La valeur antérieure est perdue.
• La première affectation d’une variable est aussi
appelée initialisation

Affectation vs Condition en Python Notion de typage

• Les valeurs des variables sont de natures différentes
• Le signe “=” sert seulement à faire une affectation. – entier n = 33
• Pour savoir si 2 nombres sont égaux, on utilise “==” – réel a = 42 + 25
– chaîne de caractères euro = 6.55957
ch = "bonjour"
Exemples :
• En programmation, on parle de type
>>> a = 6
• Selon les langages de programmation, le type des variables
>>> a
– est déclaré dans le programme : typage statique
6
>>> b = 9 – est déterminé par le compilateur/interprète : typage dynamique
>>> a == b
False • En Python, le typage est dynamique
– Pour connaître le type d’une variable: type(ma_var)
Exemples Expression
>>> a = 17 • C’est une formule qui peut être évaluée
>>> type(a) • Exemples :
<class ’int’> 42 + 2 * 5.3
3*2.0 - 5
>>> a = ‘‘salut’’ "bonjour"
>>> type(a) 20 / 3
<class ’str’>
• Expression : des opérandes et des opérateurs.
>>> a = 3.14
• Les opérateurs que l’on peut utiliser dépendent du type des
>>> type(a) valeurs qu’on manipule
<class ’float’>
>>> type(21==7*3) • Une expression qui ne peut prendre que les valeurs
True ou False est appelée expression booléenne
<class ’bool’>
Quelques opérateurs Exercice

Quelle est la réponse de l’interpréteur après chaque expression?
• arithmétiques (sur des nombres) : >>> 2 + 3
+, -, *, **, /, %, // >>> 2*3
>>> 2**3
>>> 20/3
• de comparaison (résultat booléen) : >>> 20//3
== , !=, < , >, <=, >= >>> 20%3
>>> 2 > 8
>>> (2 <= 8) and (8 < 15)
• logiques (entre des booléens, résultat booléen) : >>> 2 <= 8 < 15
>>> (x % 2 == 0) or (x >= 0)
or, and, not

Entrées / Sorties Les entrées : fonction input()

• On a généralement besoin de pouvoir interagir • A l’exécution, l’ordinateur :
avec un programme : – interrompt l’exécution du programme
• pour lui fournir les données à traiter, – affiche éventuellement un message à l’écran
– attend que l’utilisateur entre une donnée au
par exemple au clavier : entrées clavier et appuie Entrée.
• pour pouvoir connaître le résultat d’exécution
ou pour que le programme puisse écrire ce • C’est une saisie en mode texte
qu’il attend de l’utilisateur, – valeur saisie vue comme une chaîne de caractères
par exemple, texte écrit à l’écran : sorties – on peut ensuite changer le type
Introduction Variables et expressions In/Out Si... sinon
Les entrées (1) Les entrées (2)

>>> texte = input()
123 >>> val = int(texte)
>>> texte >>> val
'123' 123
>>> type(texte) >>> type(val)
<class 'str'> <class 'int'>
>>> texte = texte + 1 >>> val = val + 1
Traceback (most recent call st): >>> val
File "<pyshell#3>", line 1, in <module>
124
texte = texte + 1
TypeError: must be str, not int
Les entrées (3) Les sorties : la fonction print()

>>> x = float(input("Entrez un nombre :")) • affiche la représentation textuelle de n’importe quel
Entrez un nombre : nombre de valeurs fournies entre les parenthèses et
12.3 séparées par des virgules
>>> type(x) • à l’affichage, ces valeurs sont séparées par un espace
<class 'float'> • l’ensemble se termine par un retour à la ligne
>>> x – modifiable en utilisant sep et/ou end
12.3
>>> x + 2 • Possibilité d’insérer
14.3 – des sauts de ligne en utilisant \n et
– des tabulations avec \t

Exemples de sorties Instructions conditionnelles : if

>>> a = 20 • Objectif : effectuer des actions seulement si
>>> b = 13 une certaine condition est vérifiée
>>> print("La somme de", a, "et", b, "vaut",
a+b, ".") • Syntaxe en Python :
La somme de 20 et 13 vaut 33. if condition :
>>> print(a,b,sep= ";")
instructions à exécuter si vrai
20;13
>>> print("a=",a, "b=",b, sep="\n") La condition est une expression booléenne
a=
20 • Attention à l’indentation !
b= – Indique dans quel bloc se trouve une instruction.
13
– obligatoire en Python.
Instructions conditionnelles : if . . . else Exemple d’instruction conditionnelle

• Objectif : effectuer des actions différentes selon x = float(input("Entrez un nombre :"))
qu’une certaine condition est vérifiée ou pas if x > 0 :
• Syntaxe en Python print(x, "est plus grand que 0")
print("il est strictement positif")
if condition : else :
instructions à exécuter si vrai
print(x, "est négatif ou nul")
else :
instructions à exécuter si faux print("Fin")
Attention : le else n’est pas suivi d’une condition
Instructions conditionnelles : avec elif Instructions conditionnelles : avec elif

• Objectif : enchaîner plusieurs conditions a = 3.2 # coefficient du monôme de degré 2
• Exemple : calculer le nombre de racines réelles b = 5 # coefficient du monôme de degré 1
d’un polynôme du second degré c = -7.9 # coefficient du monôme de degré 0
d = b**2 - 4*a*c # delta
Soit une fonction du second degré : f (x) = a x2 + b x + c if d>0 :
Les racines : valeurs de x telle que l’équation f(x) = 0 print("Deux racines reelles distinctes")
elif d==0 :
On calcule le discriminant : D= b2 - 4 *a *c print("Une seule racine reelle")
D > 0 : 2 solutions else : # ici on a forcement d < 0

D = 0 : 1 solution print("Aucune racine reelle")
D < 0 : 0 solution On utilise autant de blocs elif que nécessaire.

Introduction au while
Notion de la semaine :
• Boucle while :
– Fonctionnement et syntaxe
INF204 – Semaine 2 – Compteur de boucle
– Accumulateur et drapeau
2019 - 2020
2016-2017 INF204 Semaine 1 1 / 27

Introduction au while Introduction au while
Fonctionnement et syntaxe Exemple: division de a par b

Un programme qui demande un entier a, puis un entier b
• But: répéter des instructions jusqu'à ce qu'une jusqu’à ce que celui-ci soit non-nul, puis qui calcule le
condition change. quotient de a par b.
• Syntaxe:
while condition: a = int(input("Donnez la valeur de A : "))
instructions b = int(input("Donnez la valeur de B : "))
suite_du_programme while b == 0 :
• Les instructions seront répétées tant que b = int(input("B est nul! Recommencez : "))
condition est vraie. print("A / B = ", a // b)
Lorsque que condition devient fausse, on exécute
suite_du_programme.
Note: si b est non-nul dès le premier essai, on n’entre pas dans le while.

Introduction au while Compteur de boucle
Attention aux boucles infinies! Compteur de boucle

Si la condition de la boucle while ne devient jamais fausse, • Sert à compter combien de fois l’on passe dans la
le programme boucle indéfiniment: boucle (ou un nombre qui dépend de cela)
Exemple 1:
n=5 b = int(input("Donnez un entier b non-nul:"))
while n<10 : n = 0 # n est le compteur de boucle
while b==0:
print("n vaut :", n)
n=n+1
print("Fin") b=int(input("Incorrect, recommencez: "))
print("Merci, il vous a fallu ", n , "essais
Exemple 2: supplémentaires.")
while True :
print("Je boucle.") Important: Toujours penser à initialiser le compteur !
print"("Fin")
Compteur de boucle Compteur de boucle
Compteur de boucle: exemples Compteur de boucle: exemples

• On peut se servir du compteur dans la condition. • On peut utiliser un pas différent de 1 (même négatif)
i = 0 # variable compteur i = 0 # variable compteur

while i<10 : while i<100 :
print( 2 ** i ) # 2 puissance i print(i)
i = i + 1 # incrémenter notre compteur i = i + 2
print("Fin") print("Fin")
Le pas = augmentation du compteur à chaque étape Ici le pas = 2

Ici le pas est égal à 1.

Compteur de boucle Acccumulateur
Compteur de boucle: exemples Variable "accumulateur"

• On peut utiliser un pas différent de 1 (même négatif) • Pour stocker des informations sur les valeurs parcourues,
par exemple la somme:
i = 10 # variable compteur i=1
while i>0 : somme = 0 # initialement, la somme est égale à 0
while i <= 10 :
print(i) somme = somme + i
i = i - 1 # chaque valeur de i est rajoutée à la somme
#(accumulation)
print("Fin") i = i + 1
# ne jamais oublier de mettre à jour le compteur
print("La somme des 10 premiers entiers est : ", somme)
Ici, pas : -1

Acccumulateur Drapeau
Initialisation de « l’accumulateur » Variable « drapeau »

• Un accumulateur booléen est appelé drapeau.
1. Attention à ne pas l’oublier • Exemple: lire 10 entiers et vérifier qu'ils sont tous impairs:
2. Utiliser l'élément neutre de l’opération i=0
– Pour l'addition entre nombres: 0 (car x+0=x) tous_impairs = True
while i < 10 :
– Pour la multiplication entre nombres: 1 (car x*1=x) x = int(input(’Entrez un entier:’))
– Pour la concaténation entre str: "" (chaîne vide) tous_impairs = tous_impairs and (x % 2 != 0)
i=i+1
(car ""+"bonjour"="bonjour") if tous_impairs :
print(’Tous les nombres entrés sont impairs’)
else :
print(’Au moins un nombre entré n’était pas impair’)

Drapeau
Autre programme possible Initialisation d’un « drapeau »

i=0
tous_impairs = True
• Utiliser l’élément neutre des opérations
booléennes
while i < 10 :
x = int(input(’Entrez un entier:’)) – Pour un ET : True
if x%2 == 0: car True and b vaut b
tous_impairs = False
i=i+1 – Pour un OU : False
if tous_impairs :
car False or b vaut b
print(’Tous les nombres entrés sont impairs’)
else :
print(’Au moins un nombre entré n’était pas impair’)

Boucles imbriquées
Boucles imbriquées
INF204 – Semaine 3
Université Grenoble Alpes • Une instruction d’une boucle while peut être
2019-2020
une boucle while
Ex : résultat produit par ce programme ?
i = 1
Quelques compléments : while i <= 3 :
j = 1
• boucles while imbriquées while j <= 2 :
print(i, ",", j)
• compléments sur les chaînes de caractères j = j + 1
• expressions booléennes i = i + 1
Boucles imbriquées Chaîne de caractères
Exemple d’application Précisions sur les chaînes de caractères

On veut écrire un programme qui affiche un « carré » de n x n
fois le caractère ‘*’. L’utilisateur choisit le côté n du carré. On a déjà utilisé les chaînes de caractères, notamment
dans les fonctions print() et input().
Exemple de résultat : En Python, il existe 3 syntaxes pour les chaînes de
caractères :
Entrez la valeur de n : 5 – avec des guillemets :
print("toto")
*****
***** – avec des apostrophes :
print('toto')
*****
– avec des guillemets triples :
***** print("""toto""")
*****
Chaînes de caractères Chaînes de caractères
Intérêt de ces syntaxes Exemples

>>> print("C’est toto")
• On peut utiliser " dans une chaîne délimitée par ' ... '
C’est toto
>>> print('C'est toto')
• On peut utiliser ' dans une chaîne délimitée par "…" SyntaxError : invalid syntax
>>> print("Il a dit "hello" !")
SyntaxError : invalid syntax
• On peut utiliser " et ' dans une chaîne délimitée par >>> print('Il a dit "hello" !')
"""…""" Il a dit "hello" !
• """…""" permet aussi d'écrire des chaînes de >>> print("""C'est toto qui a dit "hello" !""")
caractères sur plusieurs lignes (on y reviendra plus tard) C’est toto qui a dit "hello" !
>>> print("""C'est toto qui a dit "hello"""")
SyntaxError : …

Chaînes de caractères
Opérations sur les chaînes de Parcourir une chaîne de caractères

caractères
• Pour parcourir les caractères d’une chaîne de caractères, on
utilise une boucle for (qu’on étudiera plus en détails en
• Longueur : semaine 7)
>>> s = "abcde"
>>> len(s) • Syntaxe dans ce cas :
5 for nom_var in nom_chaine :
• Concaténation : instructions
>>> "abc" + "def" Remarque : avec ces opérations, on • Cette instruction définit la variable nom_var, et elle prend
'abcdef' peut obtenir très facilement le carré successivement pour valeur les différents caractères de la
chaîne stockée dans la variable nom_chaine
• Répétition : d’étoiles demandé page 5 :
>>> "ta " * 4 print( n * (n * "*" + "\n" ))

'ta ta ta ta '
Expressions booléennes
Exemple d’application « ou » logique : or

Qu’affiche le programme suivant ? • expr1 or expr2 vaut vrai si et seulement si au moins
une des deux expressions expr1 et expr2 est vraie.
ch = "Vive Python !"
chres = "" • En Python, le « ou » est fainéant, c’est-à-dire que si la 1ère
for carac in ch : expression vaut vrai, la deuxième n’est pas évaluée
print(carac) ( 2 == 1 + 1 ) or (a > = 5)
chres = carac + chres ne provoque pas d’erreur même si a n’existe pas, le résultat vaut vrai
print(chres) ( 3 == 1 + 1 ) or (a > = 5)
provoque une erreur si a n’existe pas.
Expressions booléennes Expressions booléennes
« et » logique : and Lois de De Morgan

• expr1 and expr2 vaut vrai si et seulement si les not(expr1 or expr2) = not(expr 1) and not(expr2)
deux expressions expr1 et expr2 sont vraies. Exemple :
not( a > 2 or b <= 4 ) équivaut à
( a <= 2 ) and ( b > 4 )
• En Python, le « et » est fainéant, c’est-à-dire que si la 1ère
expression vaut faux, la deuxième n’est pas évaluée
( 2 > 8 ) and (a > = 5) not(expr1 and expr2) = not(expr 1) or not(expr2)
ne provoque pas d’erreur même si a n’existe pas, le résultat vaut faux Exemple :
( 2 < 8 ) and (a > = 5) not( a > 2 and b <= 4 ) équivaut à
provoque une erreur si a n’existe pas. ( a <= 2 ) or ( b > 4 )

Introduction
Notion de la semaine :
les fonctions
But : structurer son code lorsque l’on fait
INF204 – Semaine 4 plusieurs fois la même chose (ou presque)
Université Grenoble Alpes • Pour qu’il soit plus lisible (plusieurs morceaux)
• Pour qu’il soit plus facilement modifiable
2019-2020 • Pour qu'il soit plus facile à tester
2016-2017 INF204 Semaine 1 1 / 27

Introduction Introduction
Un exemple du TP Un exemple du TP
import turtle # programme principal
def carre(cote) : carre(100)

# trace un carre de taille egale a cote turtle.up()
i = 1 # compteur du nb de cotes turtle.forward(130)
while i <= 4 : turtle.down()
turtle.forward(cote) carre(50)
turtle.right(90)
i=i+1

Principe Principe
Principe Exemple
• Une suite d’instructions encapsulées dans une « boîte » Dans un exercice de géométrie, on doit souvent
• Qui prend zéro, un ou des arguments calculer la distance entre deux points.
• Qui retourne zéro, une ou plusieurs valeurs de retour
• Et qui contient éventuellement des "effets de bord" qui (!! − !! )! + (!! − !! )!
modifient l'environnement (interactions entrées/sorties,
turtle…) Abscisse A,
Argument(s) Valeur(s) de Ordonnée A, Distance entre
Fonction Abscisse B, Distance
retour A et B
Ordonnée B
Effets de bords Effets de bords (ici : aucun)

(Interactions Entrées/Sorties, turtle…) (Interactions Entrées/Sorties, turtle…)
Principe Principe
Exemple de la distance Exemple de la distance

Fonction à définir au dessus de votre if __name__=="__main__": # prog. principal
programme principal: print(distance(1, 2, 1, 5))

xA=2
def distance(absA, ordA, absB, ordB ) : yA=3
d=(absB-absA)**2 + (ordB-ordA)**2 z=distance(xA, yA, 0, 0)
d=d**(1/2) print("Distance de (0,0) à A :", z)
return d
Ou directement dans l'interpréteur:
4 arguments: absA, ordA, absB, ordB >>> distance(0, 1, 3, 5)
1 valeur de retour de type float (d) 5.0
Pas d'effets de bord
Principe Syntaxe
Python Tutor Syntaxe d’une nouvelle fonction
def nom_fonction(argument1,…, argumentN) :

instructions à exécuter
return valeur de retour
Note : le return est facultatif, ainsi que les

arguments (mais pas les parenthèses!)

Syntaxe Syntaxe
Programme principal
Appel d'une fonction
À placer en-dessous de la définition des fonctions. nom_fonction(argument1, argument2, …)
è vaut la valeur de retour de la fonction (s'il y en a)
if __name__=='__main__': # programme principal
instructions à exécuter Exemple, en supposant que les fonctions distance et carre
ont été définies au-dessus.
z=distance(2, 3, 4, 5)
Note : cette ligne est facultative dans les TD/TP mais print(z)
obligatoire dans Caseine. carre(50) # pas de valeur de retour,
# mais des effets de bord (turtle)
Note : un appel de fonction peut se faire dans le programme

principal mais aussi à l'intérieur d'une autre fonction.
Syntaxe Syntaxe
Appel d'une fonction

depuis une autre fonction Fonction sans argument
import turtle
En supposant que la fonction carre a été définie au-dessus.
def carre_standard():
def deplace_sans_tracer(distance): i = 1 # compteur du nb de cotes
while i <= 4 :
up() turtle.forward(100)
forward(distance) turtle.right(90)
i=i+1
down()
def demander_nom():
def ligne_carres(nb_carres, cote): nom=input("Quel est ton nom?")
i=0 # compte le nb de carres déjà tracés return nom
while i<nb_carres:
carre(cote) # appel a la fonction Exemple d'appels:
carre name=demander_nom() # pas d'argument
deplace_sans_tracer(cote+10) # appel carre_standard() # pas d'argument ni valeur de retour
i=i+1
Syntaxe Syntaxe
Différence Différence
Effets de bord vs. Valeur de retour Effets de bord vs. Valeur de retour
def somme(x,y): def affiche_somme(x,y):
return x+y print(x+y)
x (int ou float) x+y x (int ou float) Valeur(s) de

y (int ou float) somme y (int ou float) affiche_somme
(int ou float) retour
Aucun
Effets de bord Effets de bord

Aucun un print
Syntaxe Syntaxe
Différence Différence
arguments vs. input arguments vs. input
def demande_somme():
def somme(x,y): x=float(input("x ?"))
return x+y y=float(input("y ?"))
return x+y
x (int ou float) x+y Argument x+y

y (int ou float) somme demande_somme
(int ou float) Aucun (int ou float)
Effets de bord Effets de bord

Aucun deux inputs
Mise en situation Mise en situation
Un exemple à étudier (1) – les fonctions Un exemple à étudier (2) – prog. principal
def moyenne(x,y):
# renvoie la moyenne de x et y if __name__=="__main__": # prog. principal
resultat=(x+y)/2 # demande deux nombres, affiche leur moyenne,
return resultat
# et recommence si les nombres étaient proches
def ecart_plus_grand_que(x,y,seuil):
seuil=2
# calcule l'ecart entre x et y continuer=True
# et renvoie True si l'ecart est plu grand que seuil, False while continuer:
sinon a=float(input("a=?"))
if x>y: b=float(input("b=?"))
ecart=x-y m=moyenne(a,b) # appel de la fonction
else: print("Moyenne :", m)
ecart=y-x
if ecart_plus_grand_que(a,b,seuil): # appel de la
# ecart contient la valeur absolue de x-y
# on aurait pu faire: ecart=abs(x-y) fonction
if ecart>=seuil: continuer=False
return True else:
else: print("Ecart plus petit que", seuil)
return False print("Fin car l'écart était plus grand que", seuil)

Portée des variables Portée des variables
Portée des variables Variable locale: exemple

def moyenne(x,y):
Chaque fonction a son propre "lot" de variables auquel # renvoie la moyenne de x et y
elle a le droit d'accéder (cf Python Tutor). resultat=(x+y)/2
Une variable return resultat
• créée ou modifée dans le corps d'une fonction , if __name__=="__main__": # prog. principal

• ou qui contient un argument de la fonction a=5
b=6
est dite locale, et ne sera pas accessible depuis le
m=moyenne(a,b)
programme principal, ni depuis une autre fonction. print(m) # affiche 5.5
print(resultat) # provoque une erreur
è NameError: name 'resultat' is not defined

Portée des variables Portée des variables: exemple

def moyenne(x,y):
Une variable (de type int, float, bool ou str) définie dans # renvoie la moyenne de x et y
le programme principal ne peut pas être modifiée par resultat=(x+y)/2
une instruction qui se trouve à l'intérieur d'une test=resultat # crée une nouvelle variable test
fonction*. return resultat
if __name__=="__main__": # prog. principal

Cela ne provoque pas d'erreur mais cela crée une a=5
nouvelle variable locale portant le même identificateur b=6
(nom) que l'autre variable. test=0
m=moyenne(a,b)
print("m =", m) # affiche "m=5.5"
*1. Sauf si le mot-clé global est utilisé, mais nous ne le ferons pas.
print("test =",test) # affiche "test=0"
2. Il y aura des subtilités lorsque nous verrons les listes.
# car test n'est pas modifié par l'appel de fonction
Portée des variables À ne pas faire: exemple

def decalage(s):
Les variables définies dans le programme principal sont # renvoie la chaine s préfixee de n tirets
accessibles en lecture seule depuis l'intérieur d'une espaces="-" * n
fonction mais ce comportement est dangereux car très resultat=espaces+s Il vaut mieux passer n en argument
subtil. return resultat
On ne l'utilisera donc pas (sauf éventuellement pour des variables if __name__=="__main__": # prog. principal
"constantes", initialisées une fois au début du programme et jamais modifiées
ensuite.) n=5
test=decalage("toto")
On préférera passer en arguments toutes les valeurs print(test)
nécessaires. n=10
test=decalage("maison")
print(test)

Correction de l'exemple Portée des variables

def decalage(s, n):
# renvoie la chaine s préfixee de n tirets
Résumé :
espaces="-" * n • Une variable créée ou modifiée dans une fonction est
n est maintenant un argument
resultat=espaces+s locale (= elle n'existe que dans la fonction).
return resultat (donc une variable locale)
• Une variable (de type int, float, str ou bool) du
if __name__=="__main__": # prog. principal programme principal ne peut pas être modifiée à
n=5 l'intérieur d'une fonction.
test=decalage("toto", n)
• On passera en argument de la fonction toutes les
print(test)
n=10
valeurs nécessaires.
test=decalage("maison", n)
print(test)

Introduction
Notions de la semaine :
compléments sur les fonctions
INF204 – Semaine 5 • Plusieurs valeurs de retours

• Docstring
• Arguments optionnels
• Le mot-clé None
2019-2020
2016-2017 INF204 Semaine 1 1 / 27
INF204 Semmaine 5 1 INF204 Semmaine 5 2

Plusieurs valeurs de retour Plusieurs valeurs de retour
Plusieurs valeurs de retour:

Plusieurs valeurs de retour
Un exemple
def division(a,b) : Syntaxe (dans le corps de la fonction):
# renvoie le quotient et le reste return valeur1, valeur2, … , valeurN
# de la division de a par b
quotient=a//b Pour récupérer toutes les valeurs de retour lors d'un appel:
reste= a%b
var1, var2,…, varN = nom_fonction(arguments)
return quotient, reste
# programme principal
q,r = division(22,5)
print("q=", q, "et r=", r)

Docstring Docstring
Docstring: Un exemple Docstring

def division(a,b) :
Une docstring est une chaîne de caractères (encadrée par des
""" Renvoie le quotient et le reste triple guillemets) placée au tout début d'une fonction, qui
de la division de a par b """ permet de décrire la fonction.
quotient=a//b def nom_fonction(argument1, argument2, …):
reste= a%b """ docstring
return quotient, reste
"""
Dans l'interpréteur (ou dans un programme): instructions de la fonction
>>> help(division)
Help on function division in module __main__: On peut l'afficher grâce à help(nom_fonction):
Help on function nom_fonction in module:
division(a, b) nom_fonction(argument1, argument2, …)
Renvoie le quotient et le reste docstring de la fonction affichée ici
de la division de a par b
/!\ Pas de parenthèses après nom_fonction dans help(…)
Docstring Arguments optionnels
Définir une fonction avec des

Docstring sur une fonction existante
arguments optionnels: exemple
>>> import random La carte de MisterPizza comporte de multiples saveurs de pizzas, chacune pouvant
être commandée en taille normale au prix de 9€, ou en taille maxi au prix de 12€. La
>>> help(random.randint) très grande majorité des clients choisit des pizzas de taille normale.
Help on method randint in module random:
def affiche_pizza(saveur, taille="normale"):
""" Affiche saveur, taille et prix de la pizza
randint(a, b) method of random.Random instance """
Return random integer in range [a, b], print("Pizza", saveur, "taille:", taille)
including both end points. if taille=="normale":
prix=9
elif taille=="maxi":
prix=12
print("Prix", prix, "euros.")
ètaille est un argument optionnel ayant comme valeur par
défaut "normale".
Arguments optionnels Arguments optionnels
Appeler une fonction avec des Définir une fonction avec des
arguments optionnels arguments optionnels
>>> affiche_pizza("4 fromages") Pour rendre un argument optionnel lors de la définition d'une fonction,
il faut ajouter après le nom de l'argument le signe = suivi de la valeur
Pizza 4 fromages taille: normale
par défaut.
Prix 9 euros.
>>> affiche_pizza("4 fromages", "maxi") def nom_fonc(arg1, arg_opt=valeur_par_defaut):
Pizza 4 fromages taille: maxi instructions
Prix 12 euros.
>>> affiche_pizza("Reine", "normale") èarg_opt est un argument optionnel de la fonction
Pizza Reine taille: normale Mais arg1 n'est pas un argument optionnel de la fonction
Prix 9 euros.

Help et Docstring Plusieurs arguments optionnels

sur une fonction avec arguments optionnels
MisterPizza souhaite parfois afficher le prix en Francs (lorsque
le client est âgé, mais il s'agit d'une situation peu fréquente).
>>> help(affiche_pizza) def affiche_pizza(saveur, taille="normale", afficheF=False):

Help on function affiche_pizza in module __main__: """ Affiche saveur, taille et prix de la pizza
"""
print("Pizza", saveur, ", taille: ", taille)
affiche_pizza(saveur, taille='normale') if taille=="normale":
Affiche saveur, taille et prix de la pizza prix=9
elif taille=="maxi":
prix=12
if afficheF:
prixFrancs=round(prix*6.55957, 2)
print("Prix", prix, "euros (", prixFrancs, " F).")
else:
print("Prix", prix, "euros.")
Appel avec plusieurs arguments optionnels Arguments nommés

>>> affiche_pizza("4 fromages") Lors d'un appel de fonction, on peut préciser le nom de l'argument
Pizza 4 fromages taille: normale concerné :
Prix 9 euros.
>>> affiche_pizza("4 fromages", afficheF=True)
>>> affiche_pizza("4 fromages", "maxi")
Pizza 4 fromages taille: maxi
Prix 12 euros.
>>> affiche_pizza("Reine", "maxi", True) Argument non-nommé Argument
Pizza Reine , taille: maxi (argument positionnel) nommé
Prix 12 euros ( 78.71 francs).
>>> affiche_pizza("4 saisons", True) Les arguments non-nommés doivent toujours être tous avant les
Erreur car True est pris pour la taille (2eme arg.) arguments nommés dans l'appel.
Comment faire pour préciser le 3ème argument mais pas le 2ème? L'ordre des arguments nommés peut être fait selon votre préférence.

Appel de fonction Arguments optionnels de print

Arguments non-nommés puis Arguments nommés
En fait, nous avions déjà rencontré une fonction avec des arguments
>>> affiche_pizza("4 fromages", afficheF=True) optionnels: print
Pizza 4 fromages , taille: normale
>>> print("Mon age est", 18)
>>> affiche_pizza("4 fromages", taille="maxi", afficheF=True) >>> print("Mon age est", 18, sep="égal à")
Pizza 4 fromages , taille: maxi
Prix 12 euros ( 78.71 francs). >>> print("Mon age est", 18, end=".")
>>> print("Mon age est", 18, sep=":", end=".")
>>> affiche_pizza("Chorizo", taille="maxi", True)
Erreur: il y a un argument non-nommé après un argument nommé
sep et end sont des arguments optionnels de print. Par défaut,
>>> affiche_pizza("Reine", afficheF=True, taille="maxi") sep vaut " " (espace) et end vaut "\n" (retour à la ligne).
Pizza Reine , taille: maxi
>>> affiche_pizza("Chorizo", True, taille="maxi")

Note: sep et end doivent toujours être nommés car la fonction
Erreur car taille est définie deux fois (True est pris pour print a un nombre variable d'arguments.
taille car 2eme argument non-nommé)

None None
Le mot-clé None Le mot-clé None

Il existe une valeur constante en Python qui s'appelle None. Cela Le mot-clé None peut aussi servir à initialiser une variable lorsque l'on ne
correspond à "rien", "aucune". sait pas encore précisément quelle valeur on souhaite lui attribuer.
Lorsqu'une fonction n'a pas d'instruction return, elle renvoie la
valeur None. reponse=None # on n'a pas encore de reponse
while reponse!="non":
def dit_bonjour(): x=float(input("Veuillez entrer un nombre:"))
print("Bonjour!") print("Le carré de ce nombre est:", x*x)
print("Bienvenue") reponse=input("Voulez-vous recommencer?")
# pas de return Affichage lorsque l'on lance le
print("Terminé")
module:
# prog. Principal Bonjour!
Bienvenue. /!\ None n'est pas une chaîne de caractères en
test=dit_bonjour()
Test vaut None Python, donc il ne faut pas de guillemets.
print("Test vaut", test)

Types simples et types complexes
>>> a = 6 • Types simples
>>> type(a)
<class 'int'>
• Une seule valeur
INF204 – Semaine 6 >>> type(3.5)
<class 'float'> • Besoin de manipuler des
>>> type(True)
<class 'bool‘>
« structures de données »
Université Grenoble Alpes plus complexes
– Liste
2019-2020 – Ensemble
2016-2017 INF204 Semaine 1 1 / 27 – Tableaux multi-dimensions
Notion du jour : listes
– …
Type Python « Liste » Type Python « Liste » (suite)

• Ensemble ordonné d’éléments (objets) >>> weekend
• Associée à un identificateur ['Samedi', 'Dimanche']
• Peut grandir (ou se réduire) dynamiquement >>> multiple3
• Les éléments peuvent être de types différents [3, 6, 9, 12]
• Exemples: >>> fourreTout
weekend =["Samedi","Dimanche"] ['Un', 2, 3.0, 4]
multiple3 = [3, 6, 9, 12] >>> romain
romain = [[1,'I'],[2,'II'], [3,'III'],[4,'IV']]
iv = 4 [[1, 'I'], [2, 'II'], [3, 'III'], [4, 'IV']]
fourreTout = ["Un", 2, 3.0,iv]
vide = []
Des opérateurs sur les listes (1) Exercice : remplir les trous :
• liste[index]
>> multiple3 = [3, 6, 9, 15, 21]
obtenir l’élément à l’index i
Les éléments sont indexés à partir de 0 >> multiple3[2]
• liste.append(element)
________________________
ajout d’un seul élément à la fin de la liste
>> multiple3[____]
>> multiple3 = [3, 6, 9]
>> multiple3[0] 21
3
>> multiple3.append(21) >> multiple3.____________________
>> multiple3
[3, 6, 9, 21] >> multiple3
>> multiple3[3] = 12
>> multiple3 [3, 6, 9, 15, 21, 24]
[3, 6, 9, 12]

Des opérateurs sur les listes (2) Afficher une liste
• Version 1 : avec un print
• len(liste)
Pour avoir la taille d’une liste >>> l1=[1,2,3] # crée une liste
>>> print(l1)
[1,2,3]
>> multiple3 = [3, 6, 9, 15, 21, 24, 27]
>> len(multiple3)
• Version 2 : élément par élément
7 l1=[1,2,3] # crée une liste
>> rom = [[1,"I"],[2,"II"], [3,"III"], [4,"IV"]] i=0
>> len(rom) while i < len(l1) :
4 print("element d’indice",i,":",l1[i])
i = i+1
Listes et itérations Tester si un élement est dans une liste:

mot-clé in
• Pour manipuler des listes, on utilise très souvent des
boucles : pour les initialiser, pour les afficher… def cherche(elem, l):
if elem in l:
• Si on a seulement besoin de parcourir les éléments, return True
on peut utiliser une boucle for (on en reparlera en else:
détails la semaine prochaine) return False
• Exemple : # prog. principal

l1=[1,2,3] # crée une liste ma_liste=[2,5,8,12,17,25]
trouve=cherche(12,ma_liste)
for elem in l1 : print(trouve) # affiche True
print(elem) trouve=cherche(6, ma_liste)
print(trouve) # affiche False
• liste.insert(index,element)
Ajout d’un seul élément à l’index index >> multiple3 = [3, 6, 9, 15, 21, 24, 27]
• liste.extend(liste2)
Ajout d’une liste à la fin de la liste >> multiple3.insert( ___, 12)
>> multiple3 = [3, 6, 9, 21] >> multiple3.insert( ___, 18)
>> multiple3.insert(3,15) >> multiple3
>> multiple3
[3, 6, 9, 15, 21]
[3, 6, 9, 12, 15, 18, 21, 24, 27]
>> multiple3.insert(100,24) >> multiple3.___________([30,33])
>> multiple3 >> multiple3
[3, 6, 9, 15, 21, 24]
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33]
>> multiple3[3]
15 >> multiple3.__________________
>> multiple3.extend([27,30]) >> multiple3
>> multiple3
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36]
[3, 6, 9, 15, 21, 24, 27, 30]
• liste.pop(index)
retire l’élément présent à la position index et le renvoie
• liste.remove(element)
retire l’élément donné en argument (le premier trouvé) >> EhEh = ["tra", "la", "la", "la", "lère"]
>> multiple3 = [3, 6, 9, 15, 21, 24, 27, 24, 24] >> EhEh.__________
>> a = multiple3.pop(0)
>> a >> EhEh
3
>> multiple3 ["tra", "la", "la", "la"]
[6, 9, 15, 21, 24, 27, 24, 24]
>> a = multiple3.pop(8) >> EhEh.__________
IndexError: pop index out of range
>> multiple3.remove(24) >> EhEh
>> multiple3
[6, 9, 15, 21, 27, 24, 24] ["tra", "la", "la"]
>> multiple3.remove(4)
ValueError: list.remove(x) : x not in list
Opérateurs sur les listes Opérateurs sur les listes
L'opérateur = sur les listes Copie de listes

liste1=[1,2,3] • Pour copier une liste, on peut utiliser la fonction
liste2=liste1
liste2.append("bip")
list()
liste1=[1,2,3]
L’égalité permet de donner 2 noms liste3=list(liste1)
à la même liste ! liste3.append("bip")
Les modifications apportées à une des listes après la Les modifications apportées à une des listes après la
copie s'appliquent également à l'autre liste. copie n'affectent pas l'autre liste.
(nous verrons aussi plus tard l’opérateur générique
copy.deepcopy() du module copy)
Effets de bord sur les listes Effets de bord sur les listes
Effets de bord qui modifient une liste Effets de bord qui modifient une liste
Une fonction peut modifier une liste passée en argument,
indépendamment de sa valeur de retour.
C'est une nouvelle forme d'effet de bord (jusqu'ici: print, input,
turtle).
Arguments: Aucune valeur

Une liste l et Ajoute_deb_fin de retour
deux éléments
e_deb et e_fin
Les modifications apportées à la liste dans la fonction
sont conservées après la sortie de la fonction.
Effets de bords:
Insère e_deb au début de l et e_fin à la fin de l

Attention aux effets de bord non désirés! Exemple avec oubli de la copie
Il faut bien penser à copier la liste passée en argument La liste argument l est modifiée dans la fonction.
si on ne souhaite pas qu'elle soit modifiée par la
fonction.
Exemple avec oubli de la copie:
import random
def ajoute_random(l):
""" Renvoie une liste obtenue a partir de l en
ajoutant un entier aleatoire entre 5 et 10"""
x=random.randint(5,10)
l.append(x)
return l
Sans effets de bord non désirés

Exemple (suite)
Exemple corrigé: copie de la liste avec list(…)
import random
ma_liste=list(l)
La liste l1 a été modifiée alors que l'on ne le souhaitait pas.
ma_liste.append(x)
return ma_liste

Sans effets de bord non désirés Erreur classique

Erreur à ne pas commettre:
import random
ma_liste=l
ma_liste.append(x)
return ma_liste
Le symbole = n'a pas créé une copie de l'argument l donc la liste

l2 est créée correctement et l1 n'est pas modifiée. l1 est modifiée involontairement.

Notions de la semaine :
INF204 – Semaine 7 • for

• range
• fractionnement de listes
2019-2020
2016-2017 INF204 Semaine 1 1 / 27

For et range For et range
Itération La boucle for

• Boucle while : la condition détermine le • On a déjà utilisé la boucle for pour parcourir des
nombre de fois que la boucle est exécutée structures : liste, chaîne de caractères…
boucle conditionnelle
for e in [1, 4, 5, 0, 9, 1] :
• Si on connaît ce nombre à l’avance, print(e)
on peut utiliser le for… for e in ["a", "e", "i", "o", "u", "y"]:
boucle inconditionnelle print(e)
for e in "python":
print(e) e prend successivement comme valeur
les éléments de la liste parcourue ou
les caractères de la chaîne parcourue
For et range For et range
for i in range(1,6) :
print (i,end=",") 1, 2, 3, 4, 5, A noter
• range(deb, fin, pas) • En cas d’incohérence, la boucle est ignorée et l'on passe
– Fonction qui prend des arguments entiers aux instructions suivantes :
for k in range(200, 210, -2) : ignorée
– génère une séquence d’entiers entre [deb, fin[ avec le pas print(k)
choisi. for k in range(110,100,-2) :
• Les paramètres deb et pas sont optionnels print(k)
range(a) : séquence des entiers dans [0, a[ , c'est-à-dire dans [0, a-1]
range(b,c) : séquence des valeurs [b, c[, c'est-à-dire dans [b, c-1] • Quoi qu’il arrive dans le corps de la boucle,
range(e, f, g) : séquence des valeurs [e, f[ avec un pas de g la variable du compteur prend la valeur suivante du
range ou de la liste à chaque nouvelle étape de la boucle
• for var in range(deb, fin, pas) : for i in range(1, 5) :
instructions print(i)
i = i*2
For et range
Exercice Fractionnement d’une liste

• Pour les cas suivants, indiquer les valeurs successives affichées
sur la console
for i in range(4) : # la liste en arg. doit ne contenir que des nb

print(i) def somme_des_positifs(liste) :
s=0
for j in range(2,5): for e in liste:
print(j) if e>0:
s=s+e
for k in range(3,12,3): return s
print(k)
# prog. principal
for l in range(12, 3): ma_liste = [2,-4,6,0,-5,1]
print(l) for e in ma_liste:
print(e+1)
for m in range(12,3,-2): t=somme_des_positifs(ma_liste)
print(m) print(t)
Fractionnement d’une liste Fractionnement d’une liste

>>> l1 = [1,2,3,4,5,6] Pour une liste donnée li :
>>> m3 = l1[3:5]
>>> m3 • li[i:] : liste des éléments de li à partir de
[4,5] l’indice i (inclus)
>>> m4 = l1[-3:] • li[:j] : liste des élements de li jusqu’à
>>> m4 l’indice j (exclu)
[4,5,6]
>>> m5 = l1[:-3] • li[i:j] : liste des éléments de li de
>>> m5 l’indice i inclus à l’indice j exclus
[1,2,3]

Dictionnaires et fichiers
Dictionnaire
INF204 – Semaine 8
• Tout comme une liste, un dictionnaire permet
Université Grenoble Alpes de sauvegarder en mémoire plusieurs valeurs
2019-2020 de types quelconques.
• Contrairement à une liste, les valeurs d’un

Notions de la semaine : dictionnaire ne sont pas stockées dans un
ordre particulier.
• Dictionnaires
2016-2017
• Lecture/écriture d’un fichier texte
INF204 Semaine 1 1 / 27

Dictionnaires et fichiers Dictionnaires et fichiers
Création et utilisation d’un dictionnaire Création et utilisation d’un dictionnaire

• L’accès à une valeur du dictionnaire se fait non pas
par sa position (indice), mais grâce à sa clé.
• Déclarer un dictionnaire d : Exemple:
d = { cle1: valeur1, cle2: valeur2, …, cleN: valeurN } >>> notes = {‘nathan’: 12.0, ‘quentin’: 15.5}
• Exemple: >>> notes[‘quentin’]
>>> notes = { ‘quentin’: 15.5, ‘nathan’: 12.0} 15.5
– La variable notes est un dictionnaire contenant les notes de – Ici, la chaine de caractères ‘quentin’ est la clé,
deux étudiants. et la valeur qui y est associée dans le
dictionnaire notes est 15.5
– Les chaines de caractères ‘nathan’ et ‘quentin’ sont les
clés du dictionnaire. 12.0 et 15.5 sont les valeurs du • Les dictionnaires sont aussi appelés « listes
dictionnaire. associatives », car ils permettent d’associer à
chaque clé une valeur de type quelconque.
– Les éléments du dictionnaire ne sont pas ordonnés:
• L’opérateur len permet de connaître le nombre de clés
>>> notes
d’un dictionnaire. Pour l’exemple précédent :
{'nathan': 12.0, 'quentin': 15.5}
>>> len(notes)
2
Ajouter une nouvelle entrée dans un Supprimer une entrée d’un

dictionnaire dictionnaire
• Pour rajouter une nouvelle entrée (clé+valeur) • L’opérateur del permet de supprimer une
dans un dictionnaire existant, il suffit d’utiliser
l’opérateur = en spécifiant la clé comme suit: association d’un dictionnaire:
>>> d = {} # crée un dictionnaire vide >>> d = {‘a’: 1, ‘b’: 2, ‘c’: 3}
>>> d >>> del d[‘a’]
{} >>> d
>>> d[‘a’] = 1 # ajout de la nouvelle entrée {‘b’: 2, ‘c’: 3}
>>> d
{‘a’: 1}
• Si la clé existe déjà, elle prend la nouvelle valeur:
>>> d[‘a’] = 3
>>> d
{‘a’: 3}

Vérifier l’existence d’une entrée dans

KeyError: Clé introuvable
un dictionnaire
• Pour vérifier s’il existe une valeur associée à une • Si on tente d’accéder à une entrée qui n’existe pas dans le
dictionnaire, le programme renvoie une erreur de clé (KeyError),
clé donnée, on utilise l’opérateur in comme dans exemple:
le cas des listes: >>> lettres = {‘a’: 103, ‘b’: 8, ‘e’: 150}
>>> prix = {‘asus’: 450, ‘alienware’: 1200, ‘lenovo’: >>> lettres[‘k’]
680} KeyError: 'k‘
>>> ‘asus’ in prix >>> lettres[‘u’] = lettres[‘u’] + 1
True KeyError: ‘u‘
>>> ‘toshiba’ in prix >>> del lettres[‘j’]
KeyError: ‘j‘
False
ATTENTION ! L’opérateur in vérifie l’existence d’une clé, et non pas • Avant d’accéder à une valeur, on prendra l’habitude de toujours
vérifier l’existence de la clé:
d’une valeur. Exemple:
if ‘u’ in lettres:
>>> 1200 in prix lettres[‘u’] = lettres[‘u’] + 1
False else:
lettres[‘u’]=1

Parcourir un dictionnaire Quels types pour les clés et valeurs ?

• La boucle for peut être utilisée pour parcourir toutes les clés d’un • Comme dans le cas des listes, les valeurs dans un dictionnaire
dictionnaire: peuvent être de n’importe quel type, y compris le type dictionnaire.
for key in D: >>> mon_pc = {
print(‘La clé’, key, ‘a pour valeur: ‘, D[key]) ‘ram’: 16,
• Exemple: ‘cpu’: 3.5,
dates_naissance= ‘portable’: False,
{‘ingrid’:[12,6,1995],‘marc’:[27,8,1996],‘brice’:[11,10,1995]} ‘os’: ‘windows’,
for nom in dates_naissance : ‘ports’: [‘usb3.0’, ‘jack’, ‘ethernet’, ‘hdmi’],
date = dates_naissance[nom] ‘carte_graphique’: {
print(nom, ‘fetera son anniversaire le ‘, ‘vram’: 4,
date[0], ‘/’, date[1], ‘/2017’) ‘nom’: ‘gtx970’,
‘bus’: 256
à Affiche:
}
ingrid fetera son anniversaire le 12 / 6 /2017 }
marc fetera son anniversaire le 27 / 8 /2017
brice fetera son anniversaire le 11 / 10 /2017
• En revanche, seuls certains types peuvent être utilisés comme clés.
Dans ce cours on se limitera aux entiers et aux chaines de
caractères.

Copie de dictionnaires Introduction aux fichiers

• Comme dans le cas des listes, l’affectation d’un dictionnaire vers • Jusqu’à présent, nous avons utilisé input() et print()
une variable ne fait que référencer le même dictionnaire, exemple:
>>> D = {1: 10, 2: 20, 3: 30} pour lire les entrées du programme, et afficher les
>>>
>>>
E = D
E[5] = 50
résultats obtenus.
>>> E • Parfois, les données d’entrée sont stockées dans un
{1: 10, 2: 20, 3: 30, 5: 50}
>>> D fichier et on aimerait pouvoir y accéder directement,
{1: 10, 2: 20, 3: 30, 5: 50} sans les saisir manuellement au clavier.
• Pour créer une copie d’un dictionnaire, on utilise dict():
>>> F = dict(D) • Il est aussi souvent utile de sauvegarder nos résultats
>>>
>>>
F[6] = 60
F
dans des fichiers afin de pouvoir y accéder plus tard.
{1: 10, 2: 20, 3: 30, 5: 50, 6: 60} Exemple: Sauvegarde d’une partie dans un jeu vidéo.
>>> D
{1: 10, 2: 20, 3: 30, 5: 50} • En python, il est très facile de lire et d’écrire des
données dans des fichiers.

Accès à un fichier texte Lecture d’un fichier texte

• Avant de commencer la lecture d’un fichier, il faut d’abord l’ouvrir. Ouvrir
un fichier veut simplement dire que l’on crée une variable qui permet de le • Une fois notre fichier texte ouvert, il existe plusieurs
manipuler.
• La fonction open() est utilisée pour ouvrir un fichier. Par exemple, pour manières de lire son contenu:
ouvrir le fichier appelé « data.txt », il suffit de faire: – Lire en une fois tout le contenu dans une chaine de
>>> f=open(‘data.txt') caractères:
• Par défaut, open() ouvre un fichier en mode « lecture », c’est-à-dire qu’on texte = f.read() # la chaine texte contient tout le
ne peut pas modifier son contenu. texte du fichier
• Si on tente d’ouvrir un fichier inexistant en mode « lecture », on reçoit une – Lire en une fois toutes les lignes du fichier dans une liste de
erreur: chaines de caractères:
>>> f = open('toto') # le fichier ‘toto’ n’existe pas lignes = f.readlines() # lignes est une liste qui
Traceback (most recent call last): contient les lignes du fichier: lignes[0] contient la
File "<stdin>", line 1, in <module> première ligne, etc.
IOError: [Errno 2] No such file or directory: 'toto’ – Lire le fichier ligne par ligne dans une boucle for:
for ligne in f:
print(ligne) # affiche une ligne du fichier
Remarque : pour que le fichier puisse être ouvert, il faut qu’il soit dans le même
répertoire que le programme (sinon il faut spécifier un chemin d’accès)

Écriture dans un fichier texte Fin de la manipulation

• Pour pouvoir écrire dans un fichier, il faut l’ouvrir en mode écriture: • Une fois la lecture/écriture terminée, il faut
f = open(‘fichier.txt’, ‘w’)
• Si le fichier ouvert en mode « écriture » n’existe pas, il sera créé fermer le fichier en utilisant la fonction close().
(dans le répertoire courant). S’il existe déjà, tout son contenu sera f = open(‘fichier.txt’)
effacé. for ligne in f:
print(‘une ligne lue :’, ligne)
• La fonction permettant d’écrire dans un fichier texte est write().
f.close()
f.write(‘ce texte sera écrit dans le fichier’)
• Contrairement à print(), la fonction write() ne saute pas de ligne
automatiquement. Pour sauter de ligne dans le fichier, il faut écrire
un saut de ligne manuellement:
f.write(‘\n’) # ceci permet de sauter la ligne
• L’argument passé à write() doit obligatoirement être une chaine de
caractères. Pour écrire un entier ou un autre type, il faut le convertir
en chaine de caractères en utilisant str().
Exemple de lecture Exemple d’écriture

• Soit le fichier « nombres.txt » ci-contre • On veut sauvegarder les 10
qui contient des entiers (un par ligne). nombres.txt puis.txt
premières puissances de 2 dans un
• On veut calculer la somme de ces 15 1
entiers: 18 fichier « puis.txt »: 2
30 4
55 fichier = open(‘puis.txt’, ‘w’) 8
fichier = open(‘nombres.txt’)
somme = 0 16 for i in range(0,10): 16
3 # ne pas oublier de convertir en chaine 32
for nombre in fichier:
12 64
# nombre est une chaine, ne pas # de caractères et de sauter de ligne!
13 128
# oublier de la convertir en entier ! fichier.write(str(2 ** i) + ‘\n’) 256
somme = somme + int(nombre) fichier.close() 512
print(somme)
fichier.close()

Chapitre 2
Exercices de TD
2.1 Premiers programmes, variables, instructions conditionnelles
Exercice 1 : Echange des valeurs de deux variables

On considère le programme ci-dessous :
print("Entrez deux reels :")

x = float(input())
y = float(input())
print("Vous avez saisi",x,"et", y)

x = y
y = x
print("Apres echange des variables :",x , "et",y)
Dire ce qui s’affiche quand on exécute ce programme en donnant 1.23 et -17.5 en entrée. Ce programme fait-il bien
ce qu’il est censé faire et sinon comment le corriger ?
Exercice 2 : Comparaison de deux programmes

Les deux programmes suivants sont-ils semblables ? Justifier votre réponse.
rep = input("Etes-vous fumeur : ") rep = input("Etes-vous fumeur : ")
if rep == "oui" or rep == "OUI" : if rep == "oui" or rep == "OUI" :

print("Vous devriez arreter") print("Vous devriez arreter")
else : else :
print("Continuez ainsi") print("Continuez ainsi")
print("Merci de votre participation") print("Merci de votre participation")
Exercice 3 : Comparaison de deux programmes (bis)

Les deux programmes suivants sont-ils semblables ? Justifier votre réponse.
n = int(input("Entrez n : ")) n = int(input("Entrez n : "))
if n%2 == 1 : if n%2 == 1 :
n = 3*n+1 n = 3*n+1
else : if n%2 == 0 :
n = n//2 n = n//2
print(n) print(n)
33
34 CHAPITRE 2. EXERCICES DE TD
Exercice 4 : Maximum de trois nombres

Ecrire un programme qui demande trois nombres entiers et qui affiche le plus grand des trois.
Exercice 5 : Année bissextile

Ecrire un programme qui détermine si une année saisie par l’utilisateur est bissextile ou non en affichant “Cette
année est bissextile” ou “Cette année n’est pas bissextile” selon le cas. On rappelle ci-dessous les règles qui déterminent
si une année est bissextile.
Une année est dite bissextile si c’est un multiple de 4, sauf si c’est un multiple de 100. Toutefois, elle est considérée
comme bissextile si c’est un multiple de 400.
Exercice 6 : Jours, heures, minutes, secondes

Ecrire un programme en Python qui lit un nombre de secondes (entier) au clavier et puis affiche cette durée en
jours, heures, minutes et secondes au format de l’exemple suivant :
Donner un nombre de secondes : 93901
La duree saisie se decompose en : 1 jour(s), 2 heure(s), 5 minute(s), 1 seconde(s)
Exercice 7 : Quizz
Ecrire un programme qui demande trois entiers a, b, c à l’utilisateur, puis lui pose successivement les questions
suivantes :
- a < b < c?
- un seul nombre impair parmi a, b, c ?
- a, b, c distincts deux à deux ?
Pour chaque question, le programme doit contrôler la réponse, et doit afficher "réponse correcte, Bravo" ou "réponse
incorrecte" selon le cas ; il doit aussi compter le nombre de bonnes réponses et, à la fin, afficher le score sous la forme :
"x bonnes réponses sur 3". Exemple d’exécution du programme (conformez vous strictement à ce modèle) :
Donner trois entiers :

a=? 1 (Entrée)
b=? 4 (Entrée)
c=? 3 (Entrée)
Jeu du "Vrai ou Faux ?" (répondez en tapant V ou F)
Question 1.
1 < 4 < 3 ?
V (Entrée)
réponse incorrecte
Question 2.
y a-t-il un seul nombre impair parmi 1, 4, 3 ?
F (Entrée)
réponse correcte, Bravo
Question 3.
1, 4, 3 sont-ils distincts deux à deux ?
V (Entrée)
réponse correcte, Bravo
2 bonnes réponses sur 3

Le jeu est terminé : Au revoir !
2.2. BOUCLES WHILE 35
2.2 Boucles while
Exercice 8 : Compteurs
Combien de ‘*’ les programmes suivants affichent-ils ?
(a) (b) (c)

i = 0 i = 0 i = 20
while i <= 15 : while i > 10 : while i < 100 :
print(‘*’) print(‘*’) if i % 2 != 0 :
i = i + 1 i = i + 1 print(‘*’)
i = i + 1
(d) (e)
i = 0 i = 0
while i < 100 : while i < 100 :
if i % 2 == 0 : if i%2 == 0 :
print(‘*’) print(‘*’)
i = i + 1 i = i + 1
Exercice 9 : Voyelle
Écrire un programme qui demande à l’utilisateur de saisir une lettre minuscule et qui continue jusqu’à ce que
l’utilisateur saisisse une voyelle.
Exercice 10 : Mot de passe

Écrire un programme qui demande à l’utilisateur de saisir un mot de passe que vous aurez défini (ex. mdp = ‘abcdef’)
et qui lui demande de réessayer jusqu’à ce qu’il rentre le bon mot de passe. L’utilisateur a le droit à seulement 5 essais.
Si l’utilisateur trouve le bon mot de passe, afficher le message ‘Acces autorise’ et arrêter le programme, sinon le
programme se termine avec le message ’Acces refuse’.
Exercice 11 : Factorielle
Écrire un programme qui lit un entier n saisi par l’utilisateur, et qui affiche n ! (factorielle de n).
Rappel : n ! = 1 x 2 x 3 x 4 x . . . x n
Indice : Attention à la valeur initiale.
Exercice 12 : Syracuse
Soit la suite récursive donnée par u0 = A et par la relation de récurrence :
si un est pair

un /2
un+1 =
3 ∗ un + 1 si un est impair
Écrire un programme qui demande la saisie d’un entier strictement positif et détermine le premier indice n pour lequel
on a : un = 1.
NB : la grande question est de savoir si, pour toute valeur initiale A, cette suite contient l’élément 1. Les mathé-
maticiens n’ayant pas résolu ce problème, on dit que ce problème est ouvert. On dit aussi que “cette suite passe par 1
quel que soit le point de départ” est la conjecture de Syracuse.
Exercice 13 : Moyenne, minimum, maximum

Écrire un programme qui demande à l’utilisateur de saisir des nombres réels (float) correspondant à ses notes
d’examen. L’utilisateur donnera une note invalide (non comprise entre 0 et 20) pour indiquer la fin de la saisie. Le
programme doit afficher la moyenne, la meilleure note, et la pire note de l’utilisateur.
Attention au cas spécial où aucune note valide n’est saisie.
Exercice 14 : Séquence croissante
1. Écrire un programme qui lit une suite d’entiers au clavier jusqu’à ce que l’utilisateur saisisse un nombre strictement
négatif. Le programme affichera alors ’Croissante’ si la suite d’entiers était croissante, et ’Non croissante’ sinon.
2. Écrire un programme qui lit une suite d’entiers au clavier jusqu’à ce que l’utilisateur saisisse un nombre strictement
négatif. Le programme affichera alors ’Croissante’ si la suite d’entiers était croissante, ’Décroissante’ si la suite
était décroissante, ’constante’ si tous les entiers étaient égaux, et ’Ni croissante ni décroissante’ si la suite n’est
ni croissante ni décroissante. Indice : utiliser des drapeaux.
Exercice 15 : Nombres premiers

Écrire un programme qui demande à l’utilisateur de saisir un entier positif n et qui vérifie si n est premier.
Rappel : Un nombre premier est un entier naturel qui admet exactement 2 diviseurs entiers et positifs distincts (1
et lui même).
Exercice 16 : Moyenne de classe

On veut calculer la moyenne d’un groupe de 30 étudiants. Pour ce faire, on veut écrire un programme qui, pour
chaque étudiant du groupe, demande à l’utilisateur de saisir 10 notes. A la fin de la saisie de ces 10 notes, le programme
doit afficher la moyenne de l’étudiant. A la fin du programme, la moyenne de tout le groupe doit être affichée.
Bonus : afficher aussi la moyenne et le numéro de l’étudiant qui a la meilleure moyenne.
Exercice 17 : Somme des chiffres

Écrire un programme qui demande un entier à l’utilisateur et affiche la somme de tous ses chiffres. Par exemple, si
l’utilisateur saisit 37 251, le programme affichera : "La somme des chiffres de 37 251 vaut 18".
Indice : utiliser l’opérateur modulo
Exercice 18 : Escaliers
Écrire un programme qui demande un entier nblig à l’utilisateur, et qui affiche la forme suivante, constituée de
nblig lignes (ci-dessous exemple avec nblig = 5) :
a. 12345 b. 1 c. 1 d. 12345 e. 12345 f. 1 g. *
12345 12 12 1234 1234 121 * *
12345 123 123 123 123 12321 * *
12345 1234 1234 12 12 1234321 * *
12345 12345 12345 1 1 123454321 * *
2.3 Fonctions
Exercice 19 : Comprendre les fonctions déjà connues
Pour chacun des appels de fonction ci-dessous :
1. Quel est le nom de la fonction ?
2. Combien y a-t-il d’arguments ?
3. Pour chaque argument (s’il y en a), donnez son type et sa valeur.
4. Y a-t-il une valeur de retour, et si oui laquelle (valeur et type) ?
5. Y a-t-il des "effets de bord" (interactions entrées/sorties, dessin turtle...) provoqués par l’appel ?
# on suppose que les bibliothèques math, random

# et turtle ont été importées.
print("Nombre aleatoire: ", x)
2.3. FONCTIONS 37
text=input("Quel est votre nom?")

print(text)
turtle.up()
turtle.forward(100)
turtle.down()
turtle.circle(50.5)
z=math.sqrt(5.5)
print("La racine de 5.5 est", z)
Exercice 20 : Lecture
Prédire le fonctionnement des trois programmes suivants.
Programme 1
def f(x,y):
c=x**2+y**2
return c
if __name__=="__main__": # prog principal

a=3
b=4
d=f(a,b)
print("d=", d)
d=f(4,5)
print("d=", d)
Programme 2
def est_voyelle(l):
if l=="a" or l=="e" or l=="i" or l=="o" or l=="u" or l=="y":
return True
else:
return False
def demande_voyelle():
reponse=""
while not(est_voyelle(reponse)):
reponse=input("Choisissez une lettre : ")
if not(est_voyelle(reponse)):
print("Ceci n’est pas une voyelle.")
return reponse

l=demande_voyelle()
print("La voyelle que vous avez choisi est:", l)
demande_voyelle()
Programme 3
def somme_premiers_entiers(n, modeAffichage):

i=1
somme=0
while i<=n:
somme=somme+i
if modeAffichage: # pareil que if modeAffichage==True
print("0+ ... +", i, "=", somme)
i=i+1
return somme
if __name__=="__main__":
s=somme_premiers_entiers(5,False)
print("s=", s)
modeAffichage=True
s=somme_premiers_entiers(5,modeAffichage)
print("s=", s)
Exercice 21 : Maximum
1. Écrire une fonction maximum qui prend en arguments deux nombres et qui renvoie le plus grand des deux.
2. Écrire un programme principal qui demande deux entiers à l’utilisateur, puis qui affiche Le plus grand des
deux est: .... Vous ferez un appel à votre fonction maximum.
3. Écrire une fonction maximum3 qui prend en arguments trois nombres et qui renvoie le plus grand des trois. Vous
ferez appel à votre fonction maximum.
4. Écrire une fonction maximum3_input qui ne prend pas d’arguments, qui demande trois nombres à l’utilisateur
puis qui renvoie le maximum des 3 nombres. Vous ferez appel à votre fonction maximum3.
5. Écrire un programme principal utilisant maximum3_input, qui demande trois nombres à l’utilisateur puis qui
affiche le plus grand des trois.
Note : Il existe déjà une fonction Python pour calculer le maximum, elle s’appelle max. Cependant, dans cet exercice,
nous vous demandons de ne pas l’utiliser.
Exercice 22 : Moyenne pondérée
1. Écrire une fonction moyenne_ponderee qui prend en arguments quatre nombres que l’on appellera note1, note2,
coeff1 et coeff2 et qui calcule et renvoie la moyenne pondérée de note1 et note2, ayant pour coefficients
respectifs coeff1 et coeff2.
2. Écrire un programme principal qui demande deux notes puis deux coefficients à l’utilisateur, puis qui affiche la
moyenne pondérée. Vous ferez un appel à votre fonction moyenne_ponderee.
Exercice 23 : Ajoutez des lettres
1. Écrire une fonction ajoute_suffixe qui prend en argument deux chaînes de caractères chaine et suffixe, et un
entier nb_fois et qui renvoie la chaîne de caractères obtenue à partir de chaine en ajoutant nb_fois fois la chaîne
suffixe à la fin. Par exemple, l’appel ajoute_suffixe("hello", "you", 3) doit renvoyer "helloyouyouyou".
2. Écrire une fonction ajoute_b qui prend en argument une chaîne de caractères chaine et un entier nb_fois
et qui renvoie la chaîne de caractères obtenue à partir de chaine en ajoutant nb_fois fois la lettre b à la
fin. Par exemple, ajoute_b("bonjour", 5) doit renvoyer "bonjourbbbbb". Vous pouvez utiliser votre fonction
précédente.
3. Écrire un programme principal qui demande à l’utilisateur un mot, un entier et un suffixe, puis qui teste chacune
des deux fonctions avec les bons arguments, puis qui affiche le résultat. Par exemple :
Donnez un mot: merci
Donnez un nombre: 3
La fonction "ajoute_b" appelée avec ces arguments renvoie : mercibbb
Donnez un suffixe: la
La fonction "ajoute_suffixe" appelée avec ces arguments renvoie : mercilalala
Exercice 24 : Dé
1. Écrire une fonction qui prend un argument un entier et qui teste si la valeur donnée est celle d’un dé (entre 1 et
6). Si oui, la fonction affiche Valeur correcte et renvoie True, sinon la fonction affiche Valeur incorrecte et
renvoie False.
2.4. FONCTIONS (CONSOLIDATION) 39
2. Écrire un programme principal qui demande à l’utilisateur une première valeur de dé puis qui teste si la valeur est
correcte grâce à la fonction précédente (avec l’affichage correspondant) ; puis, si la première valeur était correcte,
le programme doit demander une deuxième valeur de dé et la vérifier (avec l’affichage correspondant) ; enfin, si
les deux valeurs étaient correctes, le programme doit afficher la somme des deux dés.
3. On décide finalement de ne pas afficher Valeur correcte si la valeur du dé testée est effectivement correcte
(mais on garde l’affichage si la valeur est incorrecte). Quelle partie de votre code doit être modifiée ?
Exercice 25 : Factorielle qui dépasse

Rappel : n! = 1 × 2 × 3 × · · · × n
Écrire une fonction depasse qui prend en argument un entier A et qui renvoie le plus petit entier n tel que n! soit
supérieur ou égal à A, i.e. le plus petit entier n dont la factorielle atteint ou dépasse A.
2.4 Fonctions (consolidation)
Exercice 26 : Triangle de Pascal
1. Écrire une fonction factorielle qui prend en argument un entier naturel n et qui renvoie la valeur de n! =
1 × 2 × · · · × n.
2. Écrire une fonction coeff_binomial qui prend en argument deux entiers naturels n et k (avec k ≤ n) et qui
renvoie la valeur du coefficient binomial correspondant, donnée par la formule ci-dessous :

n n!
=
k (n − k)! k!
3. Écrire une fonction triangle_pascal qui prend en argument un entier nb_lignes et qui affiche le triangle de
Pascal (voir définition ci-dessous) en s’arrêtant au bout du nombre de lignes indiqué par l’argument. Voici un
exemple du triangle de Pascal avec 6 lignes :
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
En numérotant les lignes et lescolonnes à partir de zéro, le nombre sur la ligne numéro n et la colonne numéro
k est le coefficient binomial nk (c-à-d le nombre de combinaisons de k éléments parmi n). Par exemple, pour
la colonne numéro 0, on a toujours n0 = 1 (un seul choix, l’ensemble vide), et pour la colonne 1 on a toujours
n n
1 = n (n choix : tous les singletons différents). De même, lorsque k = n, on a n = 1 (un seul choix : l’ensemble
complet), donc chaque ligne se termine par un 1.
4. Bonus : Comment faire pour éviter le décalage causé par les nombres à plusieurs chiffres ?
Exercice 27 : Les moustiques

Depuis le début de l’année 2017, deux scientifiques Marc et Alice étudient l’évolution d’une population de moustiques
sur l’île Chépaou. Ils ont réussi à obtenir l’estimation suivante sur l’évolution de la population : si la population contient
x moustiques au cours d’une année, alors il y a aura 1.09x − 200 moustiques l’année suivante. Par contre, ils ne sont
pour l’instant pas d’accord sur l’estimation de la population en 2017 : ils s’accordent seulement sur le fait que ce
nombre est compris entre 8 000 et 12 000. Il faudra donc considérer cette donnée comme une variable. Remarque :
dans cet exercice, les estimations sur le nombre de moustiques seront des nombres réels.
1. Écrire une fonction f qui prend en argument le nombre x de moustiques à une certaine année et qui renvoie le
nombre de moustiques l’année suivante.
2. Écrire une fonction nb_moustiques qui prend en arguments nb_debut, le nombre estimé de moustiques en 2017,
et un entier annee_voulue. La fonction doit renvoyer le nombre de moustiques qu’il y aura en annee_voulue. Si
l’annee_voulue est antérieure à 2017, la fonction renvoit None.
3. Écrire une fonction annee_atteindra qui prend en argument un entier seuil et un entier nb_debut (qui cor-
respondra au nombre de moustiques en 2017) et qui renvoie l’année à partir de laquelle le nombre de moustiques
sera supérieur ou égal à seuil. Si seuil est strictement inférieur à nb_debut, la fonction renvoie None.
4. Écrire un programme principal qui demande à Marc son estimation du nombre de moustiques actuellement, puis à
Alice la sienne. Votre programme demandera ensuite une année et affichera le nombre de moustiques qu’il y aura
cette année-là, selon l’estimation initiale de Marc puis selon celle d’Alice. Enfin, votre programme demandera un
seuil et affichera en quelle année on atteindrait ce seuil, en fonction de chacune des deux estimations initiales.
5. Marc et Alice se rendent compte que leur formule pour l’évolution de la population de moustiques n’était pas
correcte. Ils souhaitent la remplacer par 1.05x − 150. Quelle partie de votre programme doit être modifiée ?
Exercice 28 : Géométrie
1. En 2D
(a) Écrire une fonction coord_centre_cercle qui prend en arguments les coordonnées x1 , y1 , x2 , y2 de deux
points diamétralement opposés sur un cercle (par exemple, comme sur la figure (2.1a)), et qui renvoie les
coordonnées x, y du centre du cercle.
(b) Écrire une fonction coord_bas_losange qui prend en arguments les coordonnées x1 , y1 , x2 , y2 de deux points
placés sur un losange vertical comme à la figure (2.1b) (le premier sur le sommet gauche, le second sur le
sommet supérieur) et qui renvoie les coordonnées x, y du sommet inférieur du losange.
(c) Écrire un programme principal qui demande les coordonnées des points A, B, C de la figure (2.1c), puis qui
calcule et affiche les coordonnées des points D, E, F .
2. En 3D
(a) Écrire une fonction volume_sphere qui prend en argument le rayon r de la sphere (qui vaudra 1 par défaut)
et qui renvoie son volume : V = 4πr3 /3.
(b) Écrire une fonction volume_cone qui prend en argument la hauteur h ainsi que le rayon r de la base d’un
cône de révolution (r vaudra 1 par défaut) et qui renvoie le volume du cône : V = πr2 h/3.
(c) Écrire un programme principal qui permet de calculer le volume total de la figure (2.1d). Votre programme
doit demander le rayon de la sphère de gauche, puis le rayon de la sphère du milieu (qui est le même que
celui du cône au-dessus), puis le rayon de la sphère de droite, puis le rayon et la hauteur du cône de devant,
et enfin la hauteur du cône au-dessus de la sphère. Votre programme affichera le volume total de la figure.
B
(x2 , y2 )
D
(x1 , y1 ) A
(x2 , y2 )
(x, y)
E
F
(x, y)
C
(x1 , y1 )
(a) (b) (c) (d)
Exercice 29 : Le menu
Un restaurant possède trois menus : le Basique à 9e, le Gourmand à 15e et le Complet à 19e. Pour chacun des
menus, le client peut choisir de rajouter une boisson à 4e. De plus, le client peut choisir un supplément fromage et/ou
un supplément café, chaque supplément coûtant 1,50e.
1. Écrire une fonction prix_menu qui prend comme argument le nom du menu, puis deux arguments optionnels :
un booléen avecBoisson dont la valeur par défaut est False, et un entier nb_supplement qui doit valoir 0 par
2.5. LISTES ET RÉVISION DES FONCTIONS 41
défaut. La fonction doit renvoyer le prix du menu correspondant. La fonction renvoie None si le nom du menu
est inconnu ou si le nombre de suppléments n’est pas entre 0 et 2.
2. Écrire un programme principal qui calcule puis affiche le prix total de l’addition pour la table suivante :
• Jacqueline a choisi seulement un menu Basique,
• Michel a pris un menu Gourmand avec boisson,
• Johanna a choisi un menu Basique avec suppléments fromage et café,
• et Antoine a choisi un menu Basique avec boisson et supplément café.
2.5 Listes et révision des fonctions

Exercice 30 : Tableau périodique des éléments
Chaque élément chimique a un numéro atomique et des propriétés qui lui sont propres. Par exemple, l’hélium (num.
atomique 2) et le néon (num. atomique 10) sont des gaz nobles. On construit un programme dans lequel on indique
par des listes, les éléments correspondant respectivement à des gaz nobles, à des halogènes et à des éléments "autres
non métaux".
1. On souhaite afficher les numéros atomiques des gaz nobles. Compléter le programme principal, après le commen-
taire "# question 1", pour afficher toutes les valeurs de la liste gaz_noble à l’aide d’une itération. Les valeurs
affichées seront séparées par un espace.
2. Compléter le code de la fonction imprimeFamille qui prend en argument list_elem une liste d’éléments et
qui affiche le contenu de la liste sur la console à l’aide d’une itération. Les éléments affichés seront séparés par
un espace. Comment modifier le code pour afficher les éléments en les séparant par des points-virgules (sans
point-virgule à la fin) ?
3. Après le commentaire "# question 3", utiliser la fonction imprimeFamille pour afficher les numéros atomiques
des halogènes (séparés par un espace).
4. Après le commentaire "# question 4", le programme principal demande à l’utilisateur de donner un numéro
atomique et inscrit sur la console la propriété de l’élément, si celle-ci est connue. Pour fonctionner, ce programme
utilise la fonction isIn, que vous avez à définir.
####### Code Python #########

# question 2 : parcours simple et définition d’une fonction
def imprimeFamille
...
# question 4 : recherche dans une liste
def isIn
...
gaz_noble = [2,10,18,36,54,86]
halogene = [9,17,35,53]
autres_non_metaux = [1,6,7,8,15,16,34]
# question 1 : parcours simple d’une liste
# question 3 : utilisation d’une fonction
# question 4
num = int(input("Entrer le numéro d’un élément chimique : "))
if (num < 1 or num > 103):
print(num, "n’est pas un numéro atomique")
else:
if isIn(num,gaz_noble):
print(num,"est un gaz noble")
elif isIn(num,halogene):
print(num,"est un halogène")
elif isIn(num,autres_non_metaux):
print(num,"est un non métaux")
else :
print("Pas encore traité")
Exercice 31 : Lire une liste d’entiers au clavier
1. Ecrire une fonction lireListeEntiers sans argument qui permet de lire des entiers positifs ou nuls saisis au
clavier. La saisie s’arrête lorsque l’on entre un nombre négatif. La fonction retourne la liste des entiers saisis.
2. Ecrire le programme principal qui permet d’appeler la fonction et d’afficher ensuite la liste obtenue avec la
fonction print.
3. Proposer une fonction lireListeReelsBornes avec deux arguments facultatifs bmin et bmax qui permet de lire
des réels saisis au clavier. La saisie s’arrête lorsque l’utilisateur saisit une valeur en dehors de l’intervalle [bmin
; bmax]. On suppose que bmin < bmax. Par défaut, les valeurs de bmin et bmax sont fixées respectivement à 0
et 100. La fonction doit retourner une liste.
4. Définir une fonction minMaxSomListe qui prend en argument une liste (supposée non vide) et qui retourne le
minimum, le maximum et la somme de la liste (on interdit d’utiliser les fonctions min, max et sum qui existe déjà
en Python).
5. Dans le programme principal, utiliser lireListeReelsBornes pour saisir au clavier une liste de réels compris
entre 0 et 20 et minMaxSomListe pour obtenir le minimum, le maximum et la somme des valeurs saisies. Afficher
les 3 valeurs obtenues à la console.
Exercice 32 : Codage et décodage
1. Soit la fonction next_elem qui prend en argument un élément elm et une liste d’au moins deux éléments liste.
La fonction renvoie l’élément suivant elm dans la liste liste, ou le premier élément de la liste si elm est le dernier
de liste. Elle renvoie None si elm n’est pas dans liste (exemple ci-après). On supposera que la liste liste ne
contient pas de doublon.
>print(next_elem(’a’,[’a’,’b’,’c’]))
b
>print(next_elem(’c’,[’a’,’b’,’c’])
a
>print(next_elem(’d’,[’a’,’b’,’c’])
None
2. On souhaite faire un programme qui crypte un texte en utilisant le principe de "codage par décalage de lettres".
Pour cela, on utilise la fonction next_elem pour transformer tous les éléments d’une liste. Ci-après un extrait
du programme à compléter. On prévoit 2 codages différents (code1 et code2). On remarquera qu’une chaîne de
caractères se transforme en liste, grâce à la fonction list. Une fois la liste résultat obtenue, on l’affichera à l’aide
d’un print.

code1 = list("abcdefghijklmnopqrstuvwxyz ,;:!?.")
code2 = list("az.erty,uiop:qs dfg!hjklm;wxcv?bn")
texte_avant_codage = input("entrer un texte en minuscule sans accents: ")
... # partie à compléter
print(texte_apres_codage)
Exercice 33 : Jouons avec des listes triées
1. Soit la fonction insererDans ayant deux arguments elm et liste_triee. liste_triee est une liste de nombres
2.6. BOUCLES FOR - QUELQUES EXERCICES COMPLÉMENTAIRES 43
classée par ordre croissant. La fonction ne doit pas la modifier. insererDans(elm, liste_triee) retourne une
liste dans laquelle l’élément elm est placé à la bonne position dans liste_triee.
>print(insererDans(1,[]))
[1]
>print(insererDans(4,[1,3,5])
[1,3,4,5]
Indice : il faut d’abord cloner la liste liste_triee dans une variable locale, la parcourir pour identifier la position
où l’élément doit être inséré, et utiliser la fonction insert. Attention au cas où liste_triee est vide.
2. Soit la fonction fusionListesT ayant deux listes ordonnées en argument. La fonction retourne une liste ordonnée
qui correspond à la fusion des deux listes : aucun élément n’est perdu. La taille de la liste retournée est égale à
la somme des deux listes fournies en argument. Proposer une solution utilisant la fonction insererDans.
>print(fusionListesT([],[]))
[]
>print(fusionListesT([1,3,4],[2,2,7,9])
[1,2,2,3,4,7,9]
3. Proposer une nouvelle solution pour la fonction de la question précédente, sans utiliser la fonction insererDans.
On parcourra simultanément les deux listes passées en argument.
4. Ecrire une fonction supprimeDoublons ayant une liste ordonnée en argument. Cette fonction retourne une liste
ordonnée dans laquelle tous les doublons ont été éliminés.
>print(supprimeDoublons[1,2,3])
[1,2,3]
>print(supprimeDoublons([1,1,1])
[1]
2.6 Boucles for - quelques exercices complémentaires
Exercice 34 : Somme d’entiers

Pour chaque question, écrire une fonction qui prend en argument un entier n et qui :
1. renvoie la somme des n premiers entiers (en partant de 1) → fonction somme

2. renvoie la somme des n premiers entiers impairs → fonction somme_impairs
3. renvoie la somme des n premiers carrés (en partant de 1) → fonction somme_carres
Exercice 35 : Suite croissante
1. Ecrire une fonction est_croissante qui reçoit une liste d’entiers et qui renvoie un booléen indiquant si les
éléments de cette liste sont dans l’ordre croissant (non strict).
2. On suppose qu’on a une fonction similaire qui détermine si une liste reçue en paramètre est en ordre décroissant
(non strict). Ecrire une fonction qui détermine si une liste reçue en paramètre est dans le désordre (ni en ordre
croissant, ni en ordre décroissant).
Exercice 36 : Palindromes
Ecrire une fonction est_palindrome qui reçoit un mot (une chaîne de caractères), qui détermine si ce mot est un
palindrome, et qui renvoie le résultat (un booléen). Un palindrome est un mot qui se lit de la même manière de la
gauche vers la droite ou de la droite vers la gauche, comme "kayak" ou "elle".
Exercice 37 : Diviseurs propres et nombres parfaits
1. Ecrire une fonction qui reçoit un entier naturel n, et calcule et renvoie la somme de ses diviseurs propres (ses
diviseurs autres que lui-même). Par exemple :
>>> sommeDivPropre(0)
0
0
3
6
2. Un entier naturel est dit parfait s’il est égal à la somme de tous ses diviseurs propres. Ecrire une fonction qui
teste si un entier naturel reçu en paramètre est parfait (en utilisant la fonction précédente). Par exemple :
>>> estParfait(6)
True
>>> estParfait(10)
False
3. Ecrire une fonction qui reçoit deux entiers binf et bsup (optionnels, valeurs par défaut respectivement 2 et 100),
et affiche tous les nombres parfaits de l’intervalle [binf,bsup], sur une seule ligne, séparés par un espace. Par
exemple :
>> parfaits_entre()
Nombres parfaits de [2,100]
6 28
>> parfaits_entre(binf=7)
Nombres parfaits de [7,100]
28
2.7 Dictionnaires et fichiers

Exercice 38 : Révision des bases
Soit le dictionnaire suivant :
d = {
1: [1, 2, 3],
2: [1, 4, 9],
’autres’: {
3: None,
4: [1, 16],
5: [1, 32]
}
}
1. Que valent les expressions suivantes ?
a) d[1] b) d[2][-1] c) d[d[1][1]] d) d[len(d[’autres’][4])]
2. On veut supprimer l’élément qui vaut None, donner l’instruction qui permet de le faire.
3. On veut rajouter l’entier 81 à la liste associée à la clé 4. Quelle instruction permet de le faire ?
2.7. DICTIONNAIRES ET FICHIERS 45
4. On veut mettre les éléments qui sont dans le dictionnaire d[0 autres0 ] dans le dictionnaire d, puis supprimer
d[0 autres0 ]. Donner le code qui permet de le faire sans utiliser f or, puis en utilisant f or.
Exercice 39 : Personnaliser ses pokémons

Dans un jeu vidéo Pokémon, on souhaite donner des noms personnalisés à certains types de pokémons. Pour ce
faire, on définit une fonction noms_perso(pokemons, noms), qui prend en argument une liste de pokémons attrapés,
et un dictionnaire faisant correspondre des noms de pokémons originaux à leurs nouveaux noms. La fonction renvoie
une nouvelle liste de pokémons, avec les noms modifiés. Les noms qui n’apparaissement pas dans le dictionnaire restent
inchangés. Exemple :
>>> mes_pokemons = ["pikachu", "bulbizarre", "roucarnage", "lippoutou"]

>>> mes_noms = {"bulbizarre": "jean-jacques", "roucarnage": "gros pigeon"}
>>> noms_perso(mes_pokemons, mes_noms)
["pikachu", "jean-jacques", "gros pigeon", "lippoutou"]
Exercice 40 : Analyse de texte

On veut connaître les lettres de l’alphabet qui sont les plus utilisées dans la langue française. Pour ce faire, on
regroupe dans un fichier texte un grand nombre de romans écrits en français (en minuscule) et on souhaite écrire
un programme qui permet de compter la fréquence d’apparition de chaque lettre, en ignorant la ponctuation et les
caractères spéciaux.
1. Ecrire une fonction lire_fichier(nom_fichier), qui prend le nom du fichier contenant le texte en argument, et
retourne une chaine de caractères contenant l’intégralité du texte.
2. Ecrire une fonction compter_lettres(texte, exceptions) qui prend un texte en argument et retourne un dictionnaire
qui associe à chaque lettre sa fréquence d’apparition dans le texte (le nombre de fois où elle apparaît). L’argument
exceptions est une liste contenant les caractères spéciaux à ignorer.
3. Ecrire une fonction lettre_rare(frequences) qui prend le dictionnaire construit dans la question précédente en
argument, et retourne la lettre de l’alphabet la plus rare (celle qui apparait le moins souvent).
4. Ecrire un programme principal qui lit le texte contenu dans le fichier "FablesLaFontaine.txt" et affiche la lettre
la moins utilisée dans le texte. Pour la liste des exceptions, on supposera qu’on l’a défini à la première ligne du
programme principal, dans la variable liste_exc, par exemple :
liste_exc=["’", "«", "»", " ", ",", ".", ":", ";", "-", "!", "?", "\n", "_"]
Exercice 41 : Polynomes
Dans cet exercice on veut travailler avec des polynomes de degrés quelconques. On peut représenter chaque polynome
avec un dictionnaire, dont les clés correspondent aux puissances de x, et les valeurs aux coefficients. Par exemple, pour
représenter le polynome x6 + 3x2 , on peut utiliser le dictionnaire :
{ 6: 1, 2: 3 }
On interdit d’avoir des monômes “inutiles”, c’est-à-dire avec un coefficient à zéro. Le polynôme nul sera modélisé par
un dictionnaire vide {}.
1. Ecrire une fonction evaluer(p, x) qui prend un polynome p et un nombre x en arguments, et renvoie la valeur du
polynome au point x.
2. Ecrire une fonction somme_polynomes(p1, p2) qui prend deux polynomes (dictionnaires) en arguments et qui
renvoie un nouveau dictionnaire représentant la somme des deux polynomes p1 et p2.
3. Ecrire une fonction produit_polynomes(p1, p2) qui prend deux polynomes en argument et renvoie le produit des
deux polynomes dans un nouveau dictionnaire.
Exemple d’exécution:
>>> evaluer({3:1, 1: 2, 0: -1}, 2)
11
>>> somme_polynomes({3:1, 2:1, 0:1}, {4:2, 2:3})

{0: 1, 2: 4, 3: 1, 4: 2}
>>> produit_polynomes({3:1, 2:1, 0:1}, {4:2, 2:3})
{2: 3, 4: 5, 5: 3, 6: 2, 7: 2}
>>> somme_polynomes({2:1, 1:1, 0:1}, {2:1, 1:-1, 0:1})
{0: 2, 2: 2}
Exercice 42 : Gestion des notes

On veut gérer les notes d’examens des étudiants d’un groupe. Tous les étudiants du groupe ne suivent pas forcément
les mêmes cours, ni le même nombre de cours. Les notes sont organisées dans une liste, dont chaque élément est un
dictionnaire contenant le nom de l’étudiant et ses notes dans les matières qu’il a choisies. Exemple :
notes_groupe=[
{’nom’: ’lambert’, ’notes’: {’physique’: 12, ’info’: 11}},
{’nom’: ’meng’, ’notes’: {’maths’: 13.5, ’info’: 18, ’sport’: 17}},
...]
1. Ecrire une fonction moyenne_etudiant(etudiant) qui prend en argument un élément de la liste décrite précédem-
ment et qui retourne la moyenne de l’étudiant.
2. Ecrire une fonction meilleur(notes_groupe) qui prend la liste du groupe en argument et retourne la meilleure
moyenne du groupe ainsi que le nom de l’étudiant qui l’a obtenue.
3. (Difficile) Ecrire une fonction matiere_difficile(notes_groupe) qui retourne le nom de la matière la plus difficile
(celle qui a la pire moyenne de groupe).
Exercice 43 : Etudiants stagiaires

On s’intéresse, en fin de L2, aux stages réalisés par les étudiants sur les années de L1 et de L2. On suppose qu’on
dispose de 3 fichiers :
• un fichier contenant la liste de tous les étudiants de L2
• un fichier contenant la liste de tous les étudiants de L2 qui ont fait un stage en 1ère année
• un fichier contenant la liste de tous les étudiants de L2 qui ont fait un stage en 2ème année
Dans chaque fichier, on a une ligne par étudiant : le nom de famille suivi du prénom (on suppose qu’il n’y a pas 2
étudiants qui ont le même nom et le même prénom). Le nom et le prénom sont séparés par un espace.
On souhaite déterminer l’ensemble des étudiants qui n’ont pas fait de stage et l’ensemble des étudiants qui ont fait
deux stages (un par an), et créer des fichiers contenant ces données.
1. Ecrire une fonction lire_liste_etu(nom_fichier) qui prend en argument un nom de fichier contenant une liste
d’étudiants et qui renvoie la liste des étudiants correspondant. Chaque étudiant sera modélisé par un dictionnaire
dont les clés seront ‘nom’ et ‘prenom ‘. Exemple de liste retournée :
[{’nom’ : ’Javel’, ’prenom’ : ’Aude’}, {’nom’ : ’Croche’:, ’prenom’ : ’Sarah’},
{’nom’ : ’Provist’:, ’prenom’ : ’Alain’}, {’nom’ : ’Dort’:, ’prenom’ : ’Louis’}]
2. Ecrire une fonction etu_2_stages(etu_1A, etu_2A) qui prend en argument deux listes d’étudiants correspon-
dant respectivement aux étudiants ayant fait des stages en 1ere et 2eme année et qui renvoie la liste des étudiants
ayant fait un stage les deux années (liste de dictionnaires comme l’exemple précédent).
3. Ecrire une fonction etu_sans_stage(etu_tous, etu_1A, etu_2A) qui prend en argument la liste de tous les
étudiants, les listes des étudiants ayant fait un stage en L1 (resp : en L2) et qui renvoie la liste de tous les
étudiants qui n’ont fait aucun stage (liste de dictionnaires comme l’exemple précédent).
4. Ecrire une fonction ecrire_resultat(liste_etu, nom_fichier) qui écrit dans le fichier de nom désigné par
nom_fichier la liste des noms et prénoms des étudiants contenus dans liste_etu (selon le format des fichiers
décrit en introduction de l’exercice).
5. On dispose des listes d’étudiants dans les fichiers "stageL1.txt", "stageL2.txt", "etu_tous.txt". Ecrire un
programme principal permettant :
2.8. RÉVISIONS 47
• d’écrire dans la fichier "etu_sans_stage.txt" les noms et prénoms des étudiants n’ayant pas du tout fait
de stage
• d’écrire dans la fichier "etu_double_stage.txt" les noms et prénoms des étudiants ayant fait un stage en
L1 et en L2.
2.8 Révisions
Exercice 44 : Cartes bancaires et formule de Luhn
Pour protéger les numéros de cartes bancaires contre les erreurs aléatoires (faute de frappe par exemple), ceux-
ci sont générés de façon à respecter la formule de Luhn. Il s’agit d’une somme de controle, c’est-à-dire une série
d’opérations arithmétiques, dont le résultat doit être un multiple de 10 pour que le numéro soit valide. On modélise
un numéro par la liste de ses chiffres de gauche à droite. Voici la description de l’algorithme faite par wikipedia
(https://fr.wikipedia.org/wiki/Formule_de_Luhn) :
L’algorithme de vérification procède en trois étapes :
• L’algorithme multiplie par deux un chiffre sur deux, en commençant par l’avant dernier et en se déplaçant de
droite à gauche. Si un chiffre qui est multiplié par deux est plus grand que neuf (comme c’est le cas par exemple
pour 8 qui devient 16), alors il faut le ramener à un chiffre entre 1 et 9. Pour cela, il y a 2 manières de faire (pour
un résultat identique) :
– Soit les chiffres composant le doublement sont additionnés (pour le chiffre 8 : on obtient d’abord 16 en le
multipliant par 2 puis 7 en sommant les chiffres composant le résultat : 1+6).
– Soit on lui soustrait 9 (pour le chiffre 8 : on obtient 16 en le multipliant par 2 puis 7 en soustrayant 9 au
résultat).
• La somme de tous les chiffres obtenus - ceux qui ont changé et ceux qui n’ont pas changé - est effectuée.
• Le résultat est divisé par 10. Si le reste de la division est égal à zéro, alors le nombre original est valide.
1. Ecrire une fonction somme_Luhn qui prend en argument un numéro représenté par la liste de ses chiffres, et qui
renvoie la somme obtenue en appliquant les deux premières étapes de l’algorithme ci-dessus.
2. Ecrire une fonction verifie_Luhn(numero) qui prend en argument un numéro représenté par la liste de ses chiffres,
et qui renvoie un booléen indiquant s’il vérifie la formule de Luhn.
3. Pour générer un numéro valide, il suffit d’ajouter à la fin (à droite) d’un numéro quelconque un chiffre de contrôle.
Pour déterminer ce chiffre, on applique la formule de Luhn sur le numéro auquel on a ajouté un chiffre de contrôle
égal à zéro. Si le résultat s est un multiple de 10 il n’y a rien à changer. Sinon, on remplace le chiffre de contrôle
par 10 − (s % 10). Ecrire une fonction ajoute_chiffre_controle(numero) qui prend en argument une liste de
chiffres et qui lui rajoute un chiffre de contrôle pour la rendre valide.
4. Ecrire une fonction genere_numero(n) qui prend un entier positif en argument et qui renvoie un numéro de n
chiffres valide généré aléatoirement. On utilisera la fonction randint du module random.
Exercice 45 : Insertion par recherche dichotomique

Etant donnée une liste d’entiers triée dans l’ordre croissant, on souhaite insérer un nouvel élément à la bonne
position pour garder la liste triée.
1. Ecrire une fonction insert_intuitif(liste_triee, e) qui prend en argument une liste d’entiers supposée déjà triée et
un entier, et qui insère le nouvel élément par la méthode qui vous semble la plus intuitive. Attention la fonction
ne renvoie rien mais modifie la liste qui lui est passée en argument.
2. Si on note n la longueur de la liste, quel est le nombre maximum d’itérations utilisées dans insert_intuitif pour
réaliser l’insertion ?
On voudrait utiliser une méthode dichotomique pour insérer un entier e dans une liste triée. L’idée est de comparer
e avec un élément de la liste qu’on appelle le pivot, idéalement situé au milieu. Si e est plus grand que le pivot alors il
doit être inséré après, sinon il doit être inséré avant. On recommence ensuite la même opération avec la moitié de liste
concernée.
3. Ecrire une fonction insert_dicho(liste_triee, e) qui implémente cette méthode.
4. Supposons que la longueur de la liste est une puissance de 2, notée n = 2k . Quel est le nombre d’itérations
utilisées dans insert_dicho pour réaliser l’insertion ? Quelle est la méthode la plus rapide ?
Exercice 46 : Transformer un dictionnaire en liste triée

En utilisant l’une des deux fonctions de l’exercice précédent, écrivez une fonction qui prend en argument un
dictionnaire dont les clés sont des entiers, et qui renvoie la liste des valeurs de ce dictionnaire, triée selon l’ordre
croissant de leur clé.
Exercice 47 :
1. Ecrire une fonction taille(liste) qui prend en argument une liste des chaînes de caractères et renvoie la taille
de chaque élément de la liste ainsi que la moyenne de leurs tailles. La fonction retourne donc une liste de taille
et un réel correspondant à la moyenne des valeurs de cette liste.
2. Ecrire un programme principal qui lit 100 mots et les stocke dans une liste de chaînes de caractères, puis affiche
pour chacun d’eux leur taille (nombre de caractères) et ensuite affiche la moyenne de leurs tailles. Un exemple
d’exécution (avec seulement 5 mots au lieu de 100) :
Tapez un mot : train

Tapez un mot : cheval
Tapez un mot : voiture
Tapez un mot : avion
Tapez un mot : accordeon
Taille du mot train : 5

Taille du mot cheval: 6
Taille du mot voiture: 7
Taille du mot avion: 5
Taille du mot accordeon: 9
Taille moyenne: 6.4
3. Modifier ce programme afin que, au lieu d’afficher la taille des mots, il lise encore un caractère et affiche les mots
contenant ce caractère ainsi que le nombre total de fois où cette lettre apparait dans la liste. Si ce caractère n’est
présent dans aucun mot, un message d’erreur apparait. Deux exemples d’exécution (avec seulement 5 mots au
lieu de 100) :
Tapez un mot : train
Tapez un mot : cheval
Tapez un mot : voiture Tapez un mot : train
Tapez un mot : avion Tapez un mot : cheval
Tapez un mot : accordeon Tapez un mot : voiture
Tapez un mot : avion
Taille moyenne : 6.4 Tapez un mot : accordeon
Tapez un caractere : o Taille moyenne : 6.4

Mots contenant ce caractère :
voiture Tapez un caractère : w
avion Erreur la lettre w n’est présente
accordeon dans aucun des mots
ce caractere apparait 4 fois.
2.8. RÉVISIONS 49
Exercice 48 :
1. Écrivez une fonction ajoute(mot1, mot2, d) qui prend en argument un mot en français mot1, sa traduction en
anglais mot2 et ajoute ces deux mots dans le dictionnaire d uniquement si mot1 n’est pas une clé du dictionnaire.
L’argument d est un dictionnaire dont les clés sont des mots en français, et la valeur associée à une clé est la
traduction de ce mot en anglais.
2. Écrivez une fonction affiche(d) qui prend en argument un dictionnaire et affiche à l’écran toutes les valeurs
correspondant à ses clés. Exemple d’exécution :
Liste de traductions (francais/anglais) :

chien : dog
chat : cat
tortue : turtle
python : python
3. Écrivez une fonction supprime(car, d) qui prend en argument un caractère car et un dictionnaire d et renvoie
un nouveau dictionnaire ne contenant pas les entrées du dictionnaire d correspondant à des clés qui commencent
par la lettre car.
4. Écrivez un programme principal qui demande à l’utilisateur un dictionnaire dont les clés sont 5 mots de la langue
française et les valeurs correspondent à la traduction en anglais de chacun de ces mots. Testez les différentes
fonctions prédéfinies sur le dictionnaire créé.
Exercice 49 : Nombre de Armstrong

Un nombre est dit de Armstrong si c’est un entier naturel non nul égal à la somme des cubes de ses chiffres. Par
exemple : 1 = 13 , 153 = 13 + 5+ 33 , 370 = 33 + 7+ 03 ...
1. Ecrire une fonction est_Armstrong(nombre) qui prend en argument un entier naturel et renvoie True si le
nombre est de Armstrong, False sinon.
2. Ecrire une fonction qui prend en argument une borne max et renvoie la liste des nombres de Armstrong inférieurs
à cette borne.
3. Ecrire un programme principal qui génère et affiche la liste des nombres de Armstrong inférieurs à 1000.
Exercice 50 : Savoir recevoir

Harmonie a décidé d’inviter ses amis autour d’une seule grande table ronde. Pour que tout soit parfait, elle veut
qu’un homme ait au moins une femme à ses côtés et qu’une femme ait au moins un homme à ses côtes. Harmonie a
beaucoup d’amis, ils viennent pour la plupart accompagnés. Pour ne pas se torturer l’esprit, elle choisit la méthode
informatique pour vérifier que sa table respecte bien ses conditions.
1. Ecrire une fonction read_file(nom) qui prend en argument le nom d’un fichier texte et renvoie une liste des
lignes du fichier.
2. Utiliser cette fonction pour récupérer les fichiers :
• les prénoms masculins (homme.txt)

• les prénoms féminins (femme.txt)
• la configuration de la table (table.txt)
On suppose que dans les fichiers, on a un prénom par ligne. Le fichier homme.txt contient la liste des invités
hommes, le fichier femme.txt contient la liste des invités femmes et le fichier table correspond à une proposition
de placement sur la table circulaire : l’individu de la ligne i est entre ceux des lignes i − 1 et i + 1. Attention :
comme la table est ronde, l’individu qui figure en première ligne est assis entre celui de la dernière ligne et celui de
la deuxième ligne. On suppouse qu’on n’a aucun prénom en commun entre les fichiers homme.txt et femme.txt.
3. On veut écrire une fonction genre(prenom, femmes, hommes) qui prend en argument un prénom , une liste des
femmes et une liste des hommes. Cette fonction vérifie si le prénom est masculin ou féminin à l’aide des listes en
entrée femmes et hommes. La fonction retourne True si le prénom est féminin, False si c’est un prénom masculin.
4. Ecrire une fonction contrainte(table, femmes, hommes) qui prend en argument la liste des memebres de la
table et vérifie si la table de Harmonie suit les contraintes qu’elle s’est imposée ou non (un homme a au moins
une femme à ses côtés et une femme a au moins un homme à ses côtes, et bien sûr tous les convives ont une
place).
Chapitre 3
Sujets de TP
3.1 TP1 : prise en main des outils

L’objectif de ce TP est d’acquérir la maîtrise des outils qui sont à votre disposition ; pour bien comprendre ce qui est
en jeu, faites tous les essais qui vous paraîtront nécessaires.
3.1.1 Première prise en main de Idle

Idle est un environnement de développement - c’est-à-dire un outil permettant de faciliter la programmation - en
Python.
Lancer le programme Idle. Idle lance une fenêtre contenant plusieurs menus. Cette fenêtre est un interpréteur de
commandes pour Python, vous pouvez y taper directement des lignes en Python. Cela se présente plus ou moins ainsi :
Dans la suite des TP, nous allons écrire nos programmes dans des fichiers et non directement dans cette fenêtre. Mais
cette fenêtre reste utilisable directement à tout moment, par exemple pour tester certaines instructions. C’est pratique
car nous obtenons directement le résultat (cela peut aussi vous servir de calculatrice puissante). Vous pouvez par exemple
taper les lignes suivantes :
>>> 3 + 5
>>> "bon" + "jour"
>>> "3" + "5"
>>> 3 + "5"
>>> 3 + int("5")
>>> a = 3
>>> print(a)
>>> type(a)
>>> a = a + 17
>>> b = a * 2
>>> print("a =", a, "et b =", b)
>>> a == b
>>> type(a == b)
51
52 CHAPITRE 3. SUJETS DE TP
>>> type(a = b)
>>> 17 // 5
>>> 17 / 5
>>> 17 % 5
>>> 17.0 / 5
>>> type(3.3)
Une ou plusieurs de ces lignes provoquent des erreurs, c’est normal. Surlignez-les. Avez-vous pris le temps de lire et de
comprendre les messages d’erreur affichés ?
3.1.2 Ecriture et exécution d’un programme sous Idle

• Dans le menu File (comme fichier) choisir New File. Idle ouvre une fenêtre nommée "Untitled" dans laquelle on
va pouvoir écrire le texte source du programme ; cela permet aussi de garder une trace de son travail. Commencez
par enregistrer le fichier (File > Save) sous le nom TP1_exo1.py.
Attention ! veillez à toujours sauver vos fichiers sur votre répertoire personnel (home). Il est conseillé d’y créer un
dossier nommé INF204 pour y ranger tous les TP de l’UE. Vous pouvez aussi copier votre travail sur une clé usb
si vous en avez une.
• Ecrire maintenant le texte du programme suivant :
print("Premier programme")
nom = input("Donnez votre nom : ")
print("Bonjour", nom)
Sauvegardez votre travail. Vous allez maintenant exécuter ce programme : pour cela allez dans le menu Run et
choisissez Run Module (vous pouvez aussi appuyer directement sur la touche F5 ).
Le programme s’exécute alors dans la première fenêtre, celle de l’interpréteur Python (qui est nommée Python 3.5.1
Shell).
• Essayez maintenant d’introduire une erreur, c’est-à-dire modifiez le texte de façon à ne pas respecter les conventions
du Python ; ensuite sauvegarder, puis demander l’exécution. Que se passe-t-il ?
• Ensuite, modifiez le texte du programme de façon que s’affiche à l’exécution :
Premier programme, deuxieme version

Donnez votre nom en majuscules :
PAUL
Bonjour, PAUL , comment vas-tu ?
Faites des essais en modifiant le texte du programme jusqu’à obtention de l’affichage requis.
3.1.3 Découverte de Python Tutor

Python Tutor est un outil en ligne qui permet de mieux comprendre ce qui se passe quand l’ordinateur exécute un
programme (en Python mais aussi en d’autres langages de programmation). Cela deviendra particulièrement utile au fil
des semaines quand nous aborderons des notions de plus en plus complexes.
• Pour utiliser Python Tutor, allez sur le site http ://pythontutor.com/ (ajouter ce site à vos marque-pages pour y
revenir plus rapidement aux prochaines séances).
• Cliquez sur “Start visualizing code”
• Sélectionnez bien le langage Python 3.6 dans le menu déroulant
• Recopiez le code ci-dessous :

3.1. TP1 : PRISE EN MAIN DES OUTILS 53
# programme pour échanger les valeurs de deux variables

print("Entrez deux reels :")
x = float(input())
y = float(input())
print("Vous avez saisi ", x, " et ", y)

x = y
y = x
print("Apres echange des variables : ", x, " et ", y)
• Cliquez sur “Visualize Execution” puis avancez ligne par ligne dans l’exécution du programme (une zone de saisie
apparaît sous la zone où vous avez tapé votre programme quand une saisie est attendue). A droite, vous pouvez
voir l’affichage produit par votre programme et surtout une visualisation de ce qui se passe dans la mémoire de
l’ordinateur, c’est-à-dire ici les variables existantes et leur valeur.
Appuyez sur Forward (resp. Back ) pour avancer (resp. reculer) d’une ligne dans le programme.
• Corrigez maintenant le programme pour qu’il fasse réellement l’échange entre les deux valeurs des variables (avec
une variable temporaire dans un premier temps).
3.1.4 Découverte de Caseine

Allez sur le site https ://caseine.org/, dans le cours INF204 (si tout s’est passé comme prévu, vous y êtes inscrit). Pour
vous connecter, cliquez en haut à droite sur "Connexion", puis ensuite sur "Connexion Grenoble" pour vous connecter avec
vos identifiants agalan. Commencez par aller dans la partie "Pour commencer" et inscrivez-vous dans le groupe Caseine
correspondant à votre groupe de TD. les groupes ainsi créés sur Caseine seront utilisés par les enseignants pour vous
contacter pour toute information concernant le cours. Il est donc important que vous vous inscriviez.
Sur cette plateforme pédagogique, il y aura chaque semaine des exercices à faire. Pour ces exercices, vous pouvez tester
votre code et vous évaluer en ligne. En cas de difficulté vous pouvez solliciter l’aide de votre enseignant. L’idéal est de faire
ces exercices régulièrement, au fur et à mesure que les notions seront vues en cours. Pour découvrir le fonctionnement de
la plateforme, allez dans la partie "Pour commencer" et faites l’activité qui s’appelle "Exemple : Bonjour". Etapes pour
une activité :
• cliquer sur l’activité et lisez l’énoncé
• en haut, cliquer sur Edit pour pouvoir écrire votre programme
• à tout moment, vous pouvez revoir l’énoncé sans quitter le mode d’édition en cliquant sur description (entre les
onglets et la fenêtre d’édition)
• saisissez votre programme et sauver
• vous pouvez tester en faisant Run (bouton avec dessin de fusée) et évaluer votre programme en faisant Evaluate
X).
(bouton avec
• vous obtenez une note (sur 100 en général), si ce n’est pas tout juste, vous pouvez réessayer autant de fois que vous
voulez.
Pour demander de l’aide à votre enseignant si vous avez du mal à faire l’exercice, le plus simple est de lui envoyer
un "Message personnel" via Caseine. A titre d’exercice (et pour pouvoir ensuite lui écrire plus facilement), vous allez lui
envoyer un message. Voici la procédure à suivre :
• cliquez sur la petite bulle en haut à droite, à côté de votre nom,
• dans la zone de recherche, saisissez le nom de votre enseignant,
• quand vous l’avez trouvé, cliquez sur son nom puis envoyez-lui un message.
Maintenant, procédez de même pour ajouter votre binôme à vos contacts (en cliquant sur les "..." à côté de son nom puis
en sélectionnant "ajouter aux contacts"), et envoyez-lui un message personnel via Caseine.
3.1.5 Exercice de lecture

Inspiré d’un exercice du partiel 2016 Pour cet exercice, on travaillera sur Python Tutor, mais on va analyser le code
proposé avant de le tester.
On considère le programme ci-dessous, censé déterminer la valeur absolue de la différence de deux entiers saisis au
clavier. (Rappel : la valeur absolue de -4 est 4, celle de 7 est 7, celle de -2.5 est 2.5, etc...)
# Programme valeur absolue
text = input(’Donner un entier : ’)

x = int(text)
text = input(’Donner un entier : ’)
y = int(text)
z = x - y
if z < 0
resultat = -z
else :
z = resultat
print ’valeur absolue :’, resultat
1. trouver les erreurs présentes dans ce programme, et corriger chaque ligne fausse
2. que se passe-t-il si vous enlevez les int(...) autour des text ?
3. écrire ce programme sous Python Tutor et observer son exécution.
3.1.6 Quelques exercices

On travaille à nouveau sous Idle, et ce pour toute la suite du TP.
Un peu d’arithmétique
1. Copier et faire exécuter ce programme (le sauver dans un fichier) :
print("Calcul de la somme de 2 nombres entiers")

a = int(input("Donner un nombre : "))
b = int(input("Donner un autre nombre : "))
c = a + b
print("\nLa somme est : ", c, "\n")
3.1. TP1 : PRISE EN MAIN DES OUTILS 55
Modifiez le programme précédent pour qu’il demande deux nombres, et affiche la somme, la différence et le produit
de ces deux nombres.
2. Ecrire un programme qui demande deux nombres entiers et affiche un message pour dire si les nombres sont égaux
ou différents :
(si l’on a tapé 3 et 5)

les deux nombres sont differents
(ou bien, si l’on a tapé 4 et 4)

les deux nombres sont egaux
3. Ecrire un programme qui demande deux nombres, et affiche le quotient entier du premier par le deuxième lorsque le
deuxième n’est pas nul, ainsi que le reste, précédés du message :
Le quotient de (ici le nombre) par (l’autre nombre) est : (le quotient). Le reste est (le reste).
Lorsque le deuxième nombre est nul, le programme doit afficher le texte : Erreur, division par zéro impossible.
(Rappel : comme 14 = 4 × 3 + 2, alors le quotient de 14 par 4 est 3, et le reste est 2.)
Jeux de dés
1. Ecrire un programme DeuxDes.py qui lit deux entiers, qui vérifie que ces entiers sont compris entre 1 et 6 (valeurs
d’un dé à jouer), et qui , dans le cas de valeurs correctes, affiche les valeurs des deux dés dans l’ordre décroissant (le
plus grand d’abord).
Voici un exemple d’affichage du programme :
Donner la valeur du premier dé : 4

La valeur du premier de est correcte
Donner la valeur du deuxieme de : 6
La valeur du deuxieme de est correcte
Les des classes en ordre decroissant sont : 6 4
Voici un autre exemple d’affichage du programme :
Donner la valeur du premier dé : 17

La valeur du premier de est incorrecte.
2. Ecrire un programme TroisDes.py :

• qui lit trois entiers
• vérifie que ceux-ci sont compris entre 1 et 6
• qui dans le cas de valeurs correctes, affiche les trois dés dans l’ordre décroissant
• qui, en plus, dans le cas des trois valeurs 4, 2 et 1, affiche "Gagne !", et dans les autres cas corrects, affiche
"Perdu !".
Attention : comme dans l’exercice précédent, on veut que le programme s’arrête dès qu’une valeur saisie pour un
dé est incorrecte.
Calcul de la moyenne et de la mention d’un étudiant

1. Ecrire un programme qui calcule la moyenne d’un module qui comporte quatre disciplines :
• Chimie
• Physique
• Mathématiques
• Informatique
Le programme demandé
• lit les quatre notes de l’étudiant

• calcule la moyenne des notes et l’affiche
Si une note n’est pas comprise entre 0 et 20, le programme affiche "INCORRECT" au lieu d’afficher la moyenne.
2. Ecrire un programme qui calcule la moyenne pondérée d’un module comportant quatre disciplines avec les coefficients
suivants :
Chimie 3
Physique 4
Mathématiques 2
Informatique 2
Le programme demandé lit les quatre notes de l’étudiant, calcule la moyenne pondérée des notes et l’affiche. Si une
note n’est pas comprise entre 0 et 20, le programme affiche "INCORRECT".
3. Ecrire un programme qui calcule la moyenne pondérée d’un module comme précédemment et affiche en plus la
mention de l’étudiant.
Les mentions sont :

moyenne < 10 : AJOURNE
10 ≤ moyenne < 12 : PASSABLE
12 ≤ moyenne < 14 : ASSEZ BIEN
14 ≤ moyenne < 16 : BIEN
16 ≤ moyenne : TRES BIEN
Bravo ! Vous avez fini le TP, faites maintenant l’exercice 7 à la page 34.
3.2. TP2 : MODULES, BOUCLE WHILE 57
3.2 TP2 : modules, boucle while

Dans ce TP, vous apprendrez à :
• Utiliser des modules Python
• Manipuler des nombres aléatoires
• Utiliser la boucle ’while’
3.2.1 Les modules Python

Beaucoup de problèmes en informatique ont déja été résolus. Par exemple, comment calculer le logarithme d’un nombre
réel, ou, comment établir une connexion internet avec un ordinateur distant ? Un programmeur qui souhaite résoudre
un nouveau problème qui utilise ces fonctionalités ne devrait pas avoir à tout reprogrammer. C’est pourquoi, comme
beaucoup d’autres langages de programmation, Python regroupe les fonctions courament utilisées dans ce que l’on appelle
des modules.
Chaque module en python contient des fonctions permettant de résoudre des problèmes spécifiques à thème donné.
Par exemple, le module ’math’ contient des fonctions telles que le cosinus, le sinus, la racine carrée, etc. Le module
’email’ contient des fonctions permettant de créer, d’envoyer et de recevoir des emails. Comparée à d’autres langages de
programmation tels que C, Python a une bibliothèque de modules très riche. Dans ce TP, nous allons apprendre à utiliser
deux de ces modules : math et random.
Le module math
Ouvrez IDLE et tapez la commande suivante :
>>> import math
Cette directive permet d’accéder à toutes les fonctions du module ’math’. Essayez d’exécuter les instructions suivantes
et vérifiez qu’elles donnent le résultat attendu :
>>> math.cos(0)
...
>>> math.sin(math.pi / 2)
...
>>> math.tan(math.pi / 4)
...
>>> math.tan(math.pi / 3)
...
>>> math.sqrt(16)
...
>>> math.log(10)
...
>>> math.exp(math.log(89))
...
Pour accéder au contenu du module math (fonctions et constantes telles que π), on a donc besoin de rajouter ’math.’
avant la fonction ou la constante à chaque fois. Il est toutefois possible d’importer directement les fonctions qui nous
intéressent sans passer par le nom du module :
>>> from math import cos, pi, exp, log

>>> cos(pi)
...
>>> x = exp(log(2))
>>> print(x)
...
Dans ce cas, seuls ’cos’, ’pi’, ’exp’ et ’log’ sont importés, et peuvent être référencés directement. On peut également
importer tout le contenu du module en utilisant le caractère spécial ’*’, qui veut dire ’tout’.
>>> from math import *

>>> x = log(2) + sqrt(exp(1)) * tan(pi/8)
>>> print(x)
...
Cependant, on évitera cette méthode d’importation car certains modules peuvent contenir des noms identiques aux noms
des variables de notre programme, ce qui risque de créer des conflits.
1) Ecrire un programme qui demande à l’utilisateur 2 nombres h et a, correspondant à l’hypoténuse et à l’un des deux
angles non-droits (en radians) d’un triangle rectangle. Le programme doit afficher la longueur des deux côtés restants du
triangle.
Exemple d’exécution :
Entrez la longueur de l’hypothénuse: 2

Entrez la valeur d’un angle: 1.0472
Les deux côtés sont: 0.9999957585450914 , 1.7320532563670865
2) Ecrire un script qui demande à l’utilisateur 3 nombres : a, b et c en boucle jusqu’à ce que la valeur delta = b2 − 4ac
soit supérieure ou égale à 0. Le programme affichera alors les racines du polynôme ax2 + bx + c.
Le module random
Certains types de programme nécessitent l’introduction d’un comportement aléatoire. Par exemple, dans le cas d’un
jeu, on veut que le joueur ait une expérience différente à chaque exécution du programme. Le module ’random’ de Python
permet de générer des nombres aléatoires. En particulier, on s’intéressera à la fonction randint de ce module.
1) Importer le module random.
2) Exécuter les instructions suivantes plusieurs fois de suite, qu’observez-vous ?
>>> x = random.randint(1, 4)
>>> print(x)
3) Ecrire un script qui lit deux entiers a et b en vérifiant que a < b et qui affiche un nombre aléatoire compris entre a
et b inclus.
3.2.2 Prix du gros lot

Vous allez à présent développer un petit jeu dont les règles sont les suivantes :
• Le programme tire un nombre au hasard compris entre 0 et 100 inclus et ne l’affiche pas à l’écran.
• Le joueur doit deviner la valeur de ce nombre en saisissant sa proposition au clavier.
• Le programme affiche selon le cas :
– "Gagné" si le joueur a deviné le bon nombre. Le programme se termine aussitôt.
– "Trop grand" si le joueur a saisi un nombre plus grand que le bon prix.
– "Trop petit" si le joueur a saisi un nombre plus petit que le bon prix.
Des exemples d’exécution sont fournis sur la page suivante.
1. Ecrire le programme décrit ci-dessus. Le joueur peut continuer à essayer jusqu’à ce qu’il devine le bon nombre.
2. Modifier le programme pour que le joueur n’ait que 5 essais avant que le programme ne se termine en affichant le
message ’Perdu !’. Si le joueur gagne après X essais, le programme doit afficher "Gagné au bout de X essais !".
3. Modifier le programme pour qu’à la fin de chaque partie, le message "Voulez-vous recommencer ? (o/n)" soit affiché.
Si l’utilisateur tape ’o’, une nouvelle partie du jeu commence, s’il tape ’n’, le programme se termine en affichant
combien d’essais il a fallu au joueur en moyenne (sur l’ensemble des parties jouées) pour trouver la bonne réponse.
4. Intelligence artificielle : Proposez un programme qui sait trouver la solution du jeu du prix du gros lot de manière
efficace. Cette fois-ci, les rôles sont inversés : c’est vous qui choisissez un nombre au hasard, et c’est à votre programme
de le deviner. Vous devez lui écrire ’g’ si le nombre qu’il a deviné est trop grand, ’p’ si le nombre est trop petit et
’b’ s’il a deviné le bon nombre. Le nombre d’essais n’est pas limité. Le programme devrait toujours être capable de
deviner le bon nombre assez vite !
3.2. TP2 : MODULES, BOUCLE WHILE 59
5. Reprendre la question précédente en utilisant une autre stratégie pour l’intelligence artificielle. Comparez les résultats
expérimentaux des deux stratégies en calculant le minimum, le maximum et la moyenne du nombre d’essais sur
plusieurs parties.
Exemples d’exécution :
Pour le 1 :
Devinez le nombre mystere ! 50
Trop petit ! Pour le 4 :
Reessayez : 75
Trop grand ! Pensez à un nombre et j’essaierai de le deviner !
Reessayez : 62 Prêt ? Appuyez sur Entrée...
Gagné ! Le nombre mystere etait bien 62 . Hmm.. Est-ce 15 ? p
Hmm.. Est-ce 35 ? g
Hmm.. Est-ce 31 ? g
Pour le 2 : Hmm.. Est-ce 24 ? g
Hmm.. Est-ce 20 ? g
Devinez le nombre mystere ! 50
Hmm.. Est-ce 19 ? g
Trop grand ! Hmm.. Est-ce 17 ? p
Reessayez : 0 Hmm.. Est-ce 18 ? b
Trop petit ! J’ai gagné !
Reessayez : 40
Trop grand !
Pensez à un nombre et j’essaierai de le deviner !
Reessayez : 30
Prêt ? Appuyez sur Entrée...
Reessayez : 23 Hmm.. Est-ce 69 ? g
Perdu ! Le nombre mystere etait 14 .
Hmm.. Est-ce 49 ? g
Hmm.. Est-ce 7 ? p
Pour le 3 : Hmm.. Est-ce 19 ? p
Hmm.. Est-ce 38 ? g
Devinez le nombre mystere ! 50 Hmm.. Est-ce 25 ? g
Trop petit ! Hmm.. Est-ce 20 ? b
Reessayez : 75 J’ai gagné !
Trop petit!
Reessayez : 82 Pensez à un nombre et j’essaierai de le deviner !
Trop grand ! Prêt ? Appuyez sur Entrée...
Gagné au bout de 4 essais ! Hmm.. Est-ce 15 ? p
Le nombre mystere etait bien 78 . Hmm.. Est-ce 37 ? lol
Voulez-vous recommencer ? (o/n) o Pardon ? rien
Devinez le nombre mystere ! 50 Pardon ? p
Trop grand ! Hmm.. Est-ce 42 ? b
Reessayez : 12 J’ai gagné !
Gagné au bout de 3 essais !
Le nombre mystere etait bien 12 .
Voulez-vous recommencer ? (o/n) n
Terminé. Nb d’essais moyens: 3.5
3.3 TP3 : boucles, dessin avec turtle

Dans ce TP, vous allez :
• découvrir comment faire des dessins avec le module turtle,
• consolider votre pratique des boucles while imbriquées,
• vous initier à la notion de fonction.
Partie A Marchons au pas de turtle

Rappel : pour utiliser les fonctions d’un module, il faut utiliser le mot clé import suivi du nom du module.
Le module turtle est un module graphique, inspiré de la programmation Logo 1 , qui permet de déplacer une tortue
sur l’écran. Quand la tortue se déplace et que le crayon est baissé, sa trajectoire se trace à l’écran. Nous allons l’utiliser
pour dessiner des figures.
Quand on utilise une fonction du module turtle, cela ouvre une fenêtre graphique, et le curseur est initialement placé
au point de coordonnées (0,0) qui est au milieu de la fenêtre. L’orientation des axes (abscisses et ordonnées) est identique
à celle conventionnellement utilisée en mathématiques. Sur la figure ci-dessous, le coin inférieur gauche du carré a pour
coordonnées (0,0) et son coin supérieur droit (100,100). La taille de la fenêtre peut varier d’un ordinateur à l’autre mais
elle peut être changée en utilisant la fonction setup(x,y).
Voici une liste non exhaustive des fonction disponibles dans cette bi-
bliothèque :
• reset() : efface l’écran, recentre la tortue et remet les variables à
zéro
• forward(distance) : avance d’une distance donnée (en pixels)
• backward(distance) : recule d’une distance donnée (en pixels)
• left(angle) : pivote vers la gauche d’un angle donné en degrés
• right(angle) : pivote vers la droite d’un angle donné en degrés
• up() : relève le crayon (pour pouvoir avancer sans dessiner)
• down() : abaisse le crayon (pour recommencer à dessiner)
• goto(x, y) : va à l’endroit de coordonnées (x, y) (attention à ne
pas oublier d’utiliser la fonction up() avant d’utiliser goto(x,y) car
sinon il tracera le parcours effectué
• circle(r) : trace un cercle de rayon r
• setup(x,y) : pour fixer les dimensions de la fenêtre graphique : x
est la largeur et y la hauteur.
Il existe d’autres fonctions : pour changer la couleur, ou la vitesse de tracé notamment. Pour connaître la liste de toutes
les fonctions disponibles dans le module turtle, ainsi que comment les utiliser, visitez la page de la documentation en
ligne du module :
https://docs.python.org/3/library/turtle.html
Nous allons travailler sous idle. Pour chaque exercice, vous écrirez votre programme dans un nouveau
fichier. Attention à ne pas nommer votre fichier turtle.py !
Exercice 1 : Carré
Ecrivez un programme permettant de tracer un carré de côté 100. A la fin du tracé, le curseur doit être au même
endroit et dans la même direction qu’au début du tracé.
1. Si vous voulez retrouver un dessin plus proche de l’original de la tortue Logo vous pouvez utiliser shape(’turtle’) pour changer le curseur
en tortue.
3.3. TP3 : BOUCLES, DESSIN AVEC TURTLE 61
Si vous n’avez pas utilisé de boucle, modifiez votre programme pour utiliser une boucle while. Vous ne devez utiliser
qu’une fois la fonction turtle.forward(...).
Exercice 2 : Carré bis

Modifiez le programme précédent pour dessiner un carré identique au précédent dont le coin supérieur gauche a
pour coordonnées le point (-200,100). A la fin du tracé, le curseur doit être au même endroit (-200,100) et dans la
même direction qu’au début du tracé.
Attention : à l’exécution de votre programme, seul le carré doit être tracé ! Si le point (-50,20) n’est pas le coin
supérieur gauche mais plutôt le coin inférieur gauche de votre carré, essayez de tourner dans l’autre sens.
Exercice 3 : Triangle équilatéral

Ecrivez un programme permettant de tracer un triangle équilatéral de côté 100 avec la pointe dirigée vers le bas.
A la fin du tracé, le curseur doit être au même endroit et dans la même direction qu’au début du tracé.
Si vous n’avez pas utilisé de boucle, modifiez votre programme pour utiliser une boucle while. Vous ne devez utiliser
qu’une fois la fonction turtle.forward(...).
Exercice 4 : Ligne de carrés

On souhaite maintenant obtenir une ligne de 8 carrés comme sur la figure suivante. Les carrés ont une dimension
de 50. La distance entre deux carrés successifs est de 10. Pour l’instant, on ne se soucie pas vraiment de la position du
curseur au début ou à la fin du tracé.
Vous devez avoir deux boucles while imbriquées, et seuls les carrés doivent être tracés, sans être reliés par des traits.
Savez-vous comment modifier votre programme pour que le coin supérieur gauche du premier carré (le plus à
gauche) ait pour coordonnées (-200,200) ? Faites-le.
Exercice 5 : Ligne de carrés et triangles alternés

On souhaite maintenant dessiner une figure très similaire à la précédente mais en alternant carrés et triangles
comme ci-dessous. Voici les caractéristiques imposées du dessin :
• on commence par un carré
• les carrés et les triangles ont tous des côtés de 50
• sur la ligne du haut, l’écart entre deux figures consécutives est toujours de 10
• le coin supérieur gauche du premier carré a pour coordonnées (-200,200)
Modifiez maintenant votre programme pour laisser l’utilisateur choisir (avec un input()) combien de figures il
souhaite tracer en tout. Par exemple, le tracé ci-dessus s’obtient maintenant en demandant 8 figures et celui ci-dessous
en demandant 7 figures :
Partie B A la découverte des fonctions à travers le dessin
Exercice 6 : Programme mystère

import turtle
Ecrivez le programme ci à droite dans un nouveau fichier.
i = 0
Exécutez ce programme. Quel résultat obtient-t-on ? Ajoutez
while i < 360 :
l’instruction turtle.circle(115) à la fin de votre programme
turtle.forward(2)
et exécutez.
turtle.left(1)
i=i+1
Nous avons trouvé comment tracer une figure proche d’un cercle avec le module turtle mais pour tracer des cercles,
nous n’utilisons pas ce programme car la fonction circle(r) existe déjà dans le module turtle et que c’est beaucoup plus
pratique à utiliser. De la même façon, dans les exercices précédents, il aurait été pratique de disposer d’une fonction pour
tracer un carré ou un triangle équilatéral, en spécifiant sa taille. Justement, en programmation, il est possible de définir
ses propres fonctions. Une fonction est un ensemble d’instructions regroupées sous un nom et s’exécutant à la demande.
Cela a plusieurs avantages :
• cela évite de répéter du code,
• cela permet de limiter les erreurs notamment de copier/coller : une fois qu’on a écrit et testé notre fonction carre,
on sait que cela marchera à chaque fois qu’on en aura besoin,
• cela permet d’améliorer la lisibilité d’un programme (on comprend plus vite ce que fait le programme quand on voit
écrit carre).
Exercice 7 : une première fonction

Vous allez maintenant écrire votre première fonction import turtle
en Python. Recopiez la première partie du programme
à droite (au dessus de la ligne horizontale). def carre() :
Que se passe-t-il quand vous exécutez ce programme ? # trace un carre de taille 100
i = 1 # compteur du nb de cotes
En fait, ici, vous avez défini comment tracer un while i <= 4 :
carré, mais vous ne demandez pas à ce qu’un carré turtle.forward(100)
soit tracé. Une fonction est une sorte de “sous- turtle.right(90)
programme” qui donne la méthode pour effectuer i = i + 1
une tâche, mais ensuite il faut faire appel à cette
méthode quand on veut que la tâche soit effectuée. # programme principal, avec appel de fonction
Pour cela, on fait suivre notre définition de fonction carre()
par un programme principal, écrit à la suite dans turtle.up()
le même fichier. Complétez donc le programme turtle.forward(130)
précédent en lui ajoutant les lignes à droite, puis turtle.down()
exécutez le programme. carre()
En pratique, nous nous trouvons vite limités avec la fonction carre que nous venons de définir. Si nous voulons tracer
des carres de taille 50, et que pour cela il faut modifier la fonction ou en écrire une autre, cela perd beaucoup de son
intérêt. Il serait intéressant de pouvoir spécifier une taille au moment de tracer un carré, de la même façon que quand on
3.3. TP3 : BOUCLES, DESSIN AVEC TURTLE 63
utilise la fonction circle de turtle en spécifiant un rayon. Pour cela il faut définir un paramètre à la fonction.
Exercice 8 : fonction carre avec paramètre
import turtle
Écrivez maintenant le code ci à droite et
complétez-le avec une programme principal de def carre(cote) :
façon à appeler la fonction pour tracer plusieurs # trace un carre de taille determinee : cote
carres de tailles différentes. Attention, pour i = 1 # compteur du nb de cotes
appeler cette fonction il faudra spécifier entre while i <= 4 :
les parenthèses la valeur qu’on souhaite donner turtle.forward(cote)
au paramètre cote. turtle.right(90)
i = i + 1
En fait, une fonction peut aussi avoir plusieurs paramètres, ainsi, on aurait pu définir une fonction carre(x,y,cote)
où (x,y) désigneraient les coordonnées du coin supérieur gauche du carré et cote sa taille. Dans ce cas, l’appel se fera
avec 3 nombres entre parenthèses, le premier corespondant au x souhaité, le deuxième au y et le troisième au cote. Ainsi,
l’instruction carre(-50, 20, 100) permettrait de tracer le carré demandé dans l’exercice Carré bis. Essayez de faire
cette modification. Pour la suite, vous choisirez la version de la fonction paramétrée qui vous est la plus pratique.
Exercice 9 : fonction pour tracer un triangle équilatéral
En vous inspirant de la fonction pour tracer un carré, écrivez une fonction triangle(cote) qui trace un triangle
équilatéral de côté cote avec la pointe orientée vers le bas. Par la suite, vous pourrez modifier cette fonction pour y
ajouter des paramètres (x,y) correspondant aux coordonnées du sommet en haut à gauche.
Exercice 10 : ligne de carrés et triangles avec fonctions

Dans un même fichier, vous allez définir la fonc- import turtle
tion carre, la fonction triangle et les utiliser
dans un programme principal pour dessiner la def carre(cote) :
même ligne de carrés et triangles alternés qu’à ...
l’exercice 5 (version avec 8 carrés). Voici à droite
la structure de l’ensemble. def triangle(cote) :
...
# programme principal : trace ligne carres

# et triangles
...
Partie C Pour aller plus loin
Si vous avez fini l’ensemble de ce qui précède, vous pouvez essayer de réaliser les figures des exercices suivants.
Exercice 11 : Ligne de carrés et triangles alternés
Tracer une ligne de carrés et triangles alternés pour laquelle le premier carré a un côté de 40. La taille augmente
de 15 à chaque nouvelle figure tracée.
Exercice 12 : Rosace et pavage de rosaces
1. Définir une fonction rosace(x, y, nb, r) qui trace une rosace de centre le point de coordonnées (x,y), com-
posée de nb cercles chacun de rayon r. Attention : le centre de la rosace est l’endroit où on voit le curseur sur la
figure ci-dessous pour une rosace à 8 cercles :
2. Utilisez cette fonction rosace pour tracer un pavage de rosace comme ci-dessous :
Indications : pour réaliser ce dessin, vous devez avoir deux boucles while imbriquées dans votre programme
principal, et un seul appel à la fonction rosace.
Si vous n’arrivez pas à définir la fonction, vous pouvez quand même essayer de faire un pavage de rosaces sans
utiliser de fonction (et vous aurez alors trois boucles while imbriquées).
3.4. TP4 ET TP5 : FONCTIONS 65
3.4 TP4 et TP5 : fonctions
Dans ce TP, vous apprendrez à créer et manipuler des fonctions. Il y a des fichiers à aller télécharger sur CaseInE. En
fait, vous allez télécharger un seul fichier d’archive (format .zip). Une fois ce fichier dans votre répertoire de travail, il
faudra le "dézipper" pour pouvoir travailler sur les fichiers qu’il contient. Pour cela, vous pouvez faire un clic droit sur le
fichier d’archive et sélectionner "Extraire ici" ou "Extraire tout" ou passer par 7-zip.
Rappel : La ligne if __name__=="__main__": (+ indentation) est facultative en TD et TP. Par contre, elle est
obligatoire dans Caseine.
3.4.1 Exercices d’observation (fichiers à télécharger)
Exercice 1 : Décrire les appels de fonctions

Lancez les programmes suivants dans Python Tutor et comptez combien de fois chacune des fonctions est appelée.
Pour chaque appel, décrire quelles sont les valeurs des arguments et la valeur de retour.
# Programme 2
def distance(xA,yA,xB,yB):
# renvoie la distance entre (xA,yA) et (xB,yB)
# Programme 1
d=(xB-xA)**2+(yB-yA)**2
def est_solution(x,a,b,c):
d=d**(1/2)
# Renvoie True si x est solution de
return d
# ax^2+bx+c=0
y=a*x**2+b*x+c
def appartient_cercle(xA,yA,rayon):
if y==0:
# teste si le point (xA,yA) appartient
rep=True
# au cercle de rayon r centré à l’origine
else:
if distance(0,0,xA,yA)==rayon:
rep=False
return True
return rep
else:
return False
# prog. principal
rep=est_solution(1,1,-2,1)
# prog. principal
print(rep)
d=distance(1,2,2,1)
print(est_solution(5, 2, -20, 50))
print(d)
print(est_solution(2.5, 1, 2, 3))
rep=appartient_cercle(1,1,2)
print(rep)
print(appartient_cercle(1,0,1))
Exercice 2 : Reconnaître les variables locales

Copiez le programme suivant dans Python Tutor et observez son fonctionnement. Quelles sont les variables locales
de la fonction est_premier ?
def est_premier(n):
if n <= 1 :
return False
else : # prog. principal
i=2 if __name__=="__main__":
a_diviseur=False rep=est_premier(9)
while i<n and (not a_diviseur): print("9 est premier ?", rep)
if n%i==0: print("5 est premier ?", est_premier(5))
a_diviseur=True
i=i+1
return not a_diviseur
Exercice 3 : locals()
Testez le programme suivant dans IDLE ou sur Python Tutor et observez attentivement ce qui s’affiche. Que
renvoie l’appel à la fonction locals() ?
# prog. principal
def pente(xA, yA, xB, yB):
p1=pente(1,1,2,2)
p=(yB-yA)/(xB-xA)
print("Pente 1: ", p1)
print("Variables locales de pente :", locals())
p2=pente(0,2,1,4.5)
return p
print("Pente 2: ", p2)
Exercice 4 : Incrémentation
Prédire le fonctionnement des deux programmes suivants, et vérifier votre réponse en les lançant dans Python
Tutor pas à pas.
# Programme 1
# Programme 2
def incremente (a):
def incremente2(a):
a = a+1
return a+1
# prog. principal
# prog. principal
b=3
b=1
incremente(b)
b = incremente2(b)
print (b)
print(b)
a=5
a=incremente2(b)
incremente(a)
print(a)
print (a)
Maintenant, rajoutez l’instruction a=incremente(a) à la fin du programme 1 et re-testez dans Python Tutor. Que
vaut a à la fin du programme ? Traduisez en français et chercher une explication. Nous expliquerons plus en détails ce
que cela veut dire en cours la semaine prochaine.
3.4.2 Des petites fonctions

On se place maintenant dans Idle, dans un nouveau fichier. Vous prendrez bien soin de tester vos fonctions au fur et
à mesure, soit en faisant des appels dans votre programme principal, soit directement dans l’interpréteur après avoir fait
"Run Module" (testez chacune des deux solutions au moins une fois).
Exercice 5 : Avec des nombres
1. Écrire une fonction valeur_abs qui prend en argument un nombre x et qui renvoie sa valeur absolue.
2. Écrire une fonction signe_different qui prend en arguments deux nombres x et y et qui renvoie True si x et
y ont des signes différents, False sinon (si x ou y est égal à 0, la fonction doit renvoyer False).
3. Soit f la fonction mathématique définie sur R par f (x) = 3x2 + 2x + 3. Écrire une fonction Python f qui prend
en argument un réel x et qui renvoie la valeur de f (x).
4. Écrire une fonction nb_racines qui prend en argument trois réels a, b, c (on supposera a 6= 0) et qui renvoie le
nombre de racines réelles du polynôme ax2 + bx + c. On rappelle la formule du discriminant : ∆ = b2 − 4ac.
Exercice 6 : Avec des chaînes de caractères

M. Bizarre est rédacteur-en-chef d’un journal, et a souvent des idées farfelues. Suivant les jours de la semaine, il
souhaite que les articles de son journal suivent des règles qu’il a inventées.
1. Chaque lundi, il souhaite que les mots soient répétés deux fois, séparés par un espace. Écrivez une fonction
lundi qui prend en argument un mot et qui retourne le mot transformé selon la règle du lundi. Par exemple,
lundi("bonjour") doit valoir "bonjour bonjour".
2. Chaque mardi, il faut que les mots de longueur paire soit répétés 6 fois, en séparant par un tiret, alors que les
mots de longueur impaire doivent être répétés 3 fois, en séparant par des virgules. Écrire la fonction mardi qui
prend en argument un mot et qui renvoie la chaîne de caractères suivant la règle du mardi. Rappel : la longueur
d’une chaîne de caractères est donnée par len(chaine).
3. Chaque mercredi, il faut que les mots de longueur impaire soit remplacés par le mot "impair". Les mots pairs
doivent rester tels qu’ils sont. Écrire la fonction mercredi (qui prend en argument un mot et qui renvoie la bonne
chaîne de caractères).
4. Chaque jeudi, il faut que les mots soient répétés autant de fois que leur longueur modulo 3 (à la suite, sans
espace). Écrire la fonction jeudi. Par exemple, jeudi("merci") vaut "mercimerci", jeudi("bonbon") vaut
"", jeudi("comment") vaut "comment".
5. Le vendredi, il faut que les mots soient écrits normalement. Et heureusement, il n’y a pas de journal le week-end.
6. Écrire une fonction transforme(mot, num_jour) qui prend en argument un mot et le numéro du jour (1 pour
lundi, 2 pour mardi, etc....) et qui renvoie le mot transformé selon la règle du jour correspondant.
3.4.3 Turtle
Dans cette partie, nous allons utiliser la bibliothèque graphique Turtle. N’oubliez pas de l’importer. Vous testerez bien
toutes vos fonctions au fur et à mesure, et vous garderez le même fichier pour tous les exercices de cette partie (les exercices
sont dépendants les uns des autres, dans l’ordre).
Note : À partir de maintenant, nous utilisons l’expression
"Écrire une fonction nom_fonction(argument1,argument2, ....)"
pour dire "Écrire une fonction nom_fonction qui prend comme arguments argument1, argument2, .... ".
Exercice 7 : Carrés imbriqués
1. Écrire une fonction carre(cote) qui trace un carré dont la longueur du côté est
cote, et dont le point de départ et d’arrivée est le coin supérieur gauche (comme
la semaine dernière).
2. Écrire une fonction carres_imbriques(cote_debut, nb_carres) qui trace des

carrés imbriqués comme sur la figure ci-contre : le plus grand carré a pour côté
cote_debut, la taille du carré est multipliée par 2/3 à chaque étape, et le nombre
de carrés tracés est nb_carres.
carres_imbriques(100,5)
Exercice 8 : Se déplacer
1. Écrire une fonction aller_sans_tracer(x,y) qui déplace le curseur au point de coordonnées x,y sans tracer.
2. Écrire une fonction descendre_sans_tracer(longueur) qui descend de longueur par rapport à la position
actuelle, sans tracer. On supposera qu’au moment de l’appel, le curseur est dirigé vers la droite, et on prendra
soin de le remettre dans la même position à la fin.
Exercice 9 : Polygone
1. Écrire une fonction polygone(nb_cotes,cote) qui trace un polygone régulier à
nb_cotes côtés (triangle, carré, pentagone, hexagone....) et dont la longueur d’un
côté est cote. Le premier côté tracé doit être horizontal et vous devez tourner dans
le sens des aiguilles d’une montre (voir figure ci-contre).
2. Écrire une fonction diametre_polygone(nb_cotes, cote) qui renvoie le diamètre
d’un polygone régulier à nb_cotes de longueur cote. Ce diamètre est donné par la
formule suivante, avec n de nombre de cotés et c la longueur du côté (n’oubliez pas
d’importer le module math) :
c polygone(6,50)
sin (π/n)
Exercice 10 : Pavage de polygones
1. Écrire une fonction colonne_polygone(nb_poly, cote) qui trace nb_poly polygones

sur la même colonne, en commençant par un triangle et en augmentant le nombre de
côtés de 1 à chaque fois. La longueur du côté des polygones doit toujours être égale à
cote. Vous vous servirez des fonctions descendre_sans_tracer et diametre_polygone
pour décaler votre curseur de d + 5 vers le bas entre deux polygones successifs, où d
désigne le diamètre du polygone qui vient d’être tracé.
2. Écrire une fonction pavage(nb_poly, nb_col, cote) qui dessine un pavage de poly-
gones comme sur la figure ci-contre, en commençant au point de coordonnées (-270,
330). Le nombre de polygones par colonne doit être réglé par nb_poly et le nombre de
colonnes par nb_col. De plus, le côté des polygones doit être de cote pour la première pavage(6,4,20)
colonne puis augmenter de 10 lorsque l’on change de colonne. Les points de départ de
chaque colonne doivent avoir la même ordonnée (les triangles du haut sont alignés), et
leurs abscisses doivent être écartées de d + 10 (vers la droite), où d est le diamètre du
dernier polygone tracé. Pensez à utiliser les fonctions créées précédemment. Si vous avez
du mal à écrire cette fonction, vous pouvez commencer à écrire une fonction pavage5()
qui ne prend aucun argument, et qui dessine un pavage avec 5 lignes et 5 colonnes, en
commençant avec un côté égal à 20.
3. Écrire un programme principal qui dessine la figure ci-contre, contenant un pavage à

3 colonnes avec 3 polygones par colonne, commençant avec un coté de 20 ; puis qui
dessine 5 carrés imbriqués, dont le premier a pour longueur 100. prog. principal
3.4.4 Retour aux fonctions numériques
Exercice 11 : La banque
Aline envisage d’ouvrir un compte à la banque Argento, mais elle veut d’abord savoir si cela sera rentable. Sur un
tel compte, les intérêts sont de 5% par an, et la banque prélève un coût fixe annuel de 11 euros. Le capital de l’année
n + 1 est donc obtenu par la formule un+1 = un × 1.05 − 11, où un désigne le capital à l’année n.
1. Écrire une fonction capital(nb_annees, capital_debut) qui renvoie le capital en euros qu’Aline aurait sur
un tel compte au bout de nb_annees en plaçant initialement un capital égal à capital_debut (en euros). Par
exemple, capital(3,1000) renvoie 1122.9475.
2. Écrire une fonction gagne_argent(nb_annees, capital_debut) qui renvoie True si le capital au bout de
nb_annees sur un tel compte est supérieur ou égal au capital de début. Par exemple, gagne_argent(20,200)
renvoie False.
3. Écrire une fonction capital_debut_min(nb_annees) qui renvoie le capital minimal qu’il faut mettre initialement
sur le compte pour qu’après nb_annees il soit supérieur ou égal au capital de début. On supposera ici que le
capital de début est toujours un entier. Par exemple, capital_debut_min(7) renvoit 220.
Exercice 12 : Un peu d’arithmétique

Dans cet exercice, on ne considérera que des entiers strictement positifs.
1. Écrire une fonction plus_grand_diviseur_premier(n) qui renvoie le plus grand diviseur premier de l’entier n.
Il vous est conseillé de commencer par redéfinir la fonction est_premier(N) que l’on a déjà vue.
2. Écrire une fonction pgcd(a,b) qui renvoie le plus grand commun diviseur des entiers a et b. Note : il existe
principalement deux algorithmes pour calculer un pgcd, vous pouvez essayer les deux :
• L’algorithme "naïf" qui parcourt tous les entiers qui sont candidats à être pgcd.
• L’algorithme d’Euclide, qui est beaucoup plus rapide : voir schéma ci-dessous. Si a < b, l’algorithme com-
mence par échanger a et b puis fonctionne normalement suivant le schéma ; si a = b, l’algorithme renvoie
simplement a.
3. Écrire une fonction ppcm(a,b) qui renvoie le plus petit commun multiple de a et b.
4. Écrire une fonction irreductible(numerateur, denominateur) qui renvoie True si la fraction correspondante
numerateur/denominateur est irréductible, False sinon.
3.4.5 On travaille en ligne !

Quand vous aurez fini les exercices précédemment proposés, vous pouvez travailler en ligne sur le site du PLM :
https://plm.telecomnancy.univ-lorraine.fr/#/
PLM signifie en anglais "The Programmer’s Learning Machine", une plataforme en ligne avec des exercices de programa-
tion.
Pas 1 : Il faut d’abord choisir Python avant de commencer les exercices. Sur le coin haut à droite de votre écran, vous
allez sur Java et vous pouvez trouver l’option Python, cliquez.
Pas 2 : Cliquez sur le bouton en haut à gauche et vous aurez la liste de sujets proposés. Vous pouvez commencer par
les exercices correspondant à de "boucles tant que" (while) et "fonctions".
3.5 TP6 et TP7 : listes, boucles for
Dans ce TP, vous apprendrez à créer et manipuler des listes.
Rappel : La ligne if __name__=="__main__": (+ indentation) est facultative en TD et TP. Par contre, elle est obligatoire
dans Caseine.
3.5.1 Consultation de listes
Dans cette partie, nous allons d’abord nous concentrer sur l’utilisation de listes existantes. Nous verrons dans la
deuxième partie du TP comment créer ou modifier des listes existantes.
Note : Les codes python présentés ici sont dans une archive téléchargeable sur CaseInE.
Exercice 1 : Listes sous PythonTutor
Essayez de prévoir le comportement des deux exemples suivants puis testez-les pas à pas sur www.PythonTutor.com.
(Correspondent aux fichiers pythontutor1.py et pythontutor2.py de l’archive.)
maliste = [1, 3, 9, 6, 4] maliste = [1, 3, 9, 6, 4]
print(maliste) print(maliste)
a = maliste[2] i =0
b = maliste[0] while i < len(maliste):
c = maliste[4] element = maliste[i ]
d = maliste[−1] print ("indice", i , "␣contient:␣", element)
e = maliste[7] i = i+1
Regardez également le fichier nommé intro-listes.py. Vous devez être en mesure de comprendre tout ce qui y
est fait. Testez le sous Idle. Vous pouvez le modifier à votre guise pour vérifier votre compréhension.
liste_desord = [2, 12, 7, 9, 3, 4]

liste_croiss = [2, 3, 4, 5, 7, 9, 12]
def croissante ( liste ) :
cr = True
def parcours ( liste ) : i =1
i =0 while i < len(liste ) :
while i < len(liste ) : cr = cr and (liste [ i−1] <= liste[i ])
print ("Element␣a␣l’indice", i , ":", liste [ i ]) i = i+1
i = i+1 return cr
parcours(liste_desord)
print (liste_desord, "est␣croissante :", croissante (
def parcours_envers (liste) : liste_desord))
i = len(liste )−1 print ( liste_croiss , "est␣croissante :", croissante (
while i >= 0: liste_croiss ))
print ("Element␣a␣l’indice", i , "(envers)␣:", liste [
i ])
i = i−1
parcours_envers(liste_desord)
3.5. TP6 ET TP7 : LISTES, BOUCLES FOR 71
Exercice 2 : Recherche dans une liste

Dans cet exercice, vous allez devoir écrire plusieurs fonctions “de base” fonctionnant sur des listes d’entiers. Essayez
d’avoir un code propre définissant d’abord les fonctions, puis qui teste sur plusieurs exemples vos fonctions dans un
programme principal (“main”). Pour toutes les fonctions demandées, il ne faut qu’elles modifient la liste en argument.
1. Écrivez une fonction minimum(liste) qui renvoie l’élément le plus petit de liste (et None si la liste est vide) ;
2. Écrivez une fonction contient(liste, elem) qui renvoie True si liste contient elem et False sinon. Pensez à
tester les cas limites (par exemple, élément au début ou à la fin).
3. Écrivez une fonction minimum2(liste) qui renvoie le deuxième élément le plus petit de liste (et None si la liste
a moins de 2 éléments). Par exemple minimum2([-2, 4, 0, -3, 1]) renvoie -2 et minimum2([-2, 4, 0, -3,
1, -3]) renvoie -3 ;
Exercice 3 : Températures
Note : cet exercice est extrait du site CodinGame.
Dans cet exercice, vous devez analyser des enregistrements de température pour trouver la plus proche de zéro.
Dans l’exemple, -1 est la plus proche de 0.

Vous devez écrire une fonction proche_zero qui prend en argument une liste de températures (entiers) et renvoie
la plus proche de zéro. S’il n’y a aucune température, renvoyer 0. En cas d’égalité entre une température positive et
une négative, on considère que c’est la positive qui est la plus proche de zéro (par exemple, si les températures sont 5
et -5, il faut renvoyer 5).
Le fichier temperature.py contient un squelette de code prêt à tester votre fonction.
Exercice 4 : Duels de chevaux de course

Note : cet exercice est également extrait du site CodinGame. Il est plus complexe que tous les autres exercices vus
jusqu’à présent : il est donc nécessaire de prendre un moment pour bien comprendre le problème et réfléchir posément
à comment vous allez le résoudre.
À l’hippodrome de Casablanca, on organise des courses de chevaux d’un type particulier : les duels ! Durant un
duel, seuls deux chevaux participent à la course. Pour que la course soit intéressante, il faut sélectionner deux chevaux
de force similaire. On considère que l’on connait la “force” des chevaux, donnée par un entier.
Écrire une fonction plus_proches(liste) qui, étant donnée une liste des forces des chevaux, identifie les forces
les plus proches et renvoie la différence entre ces deux forces (un entier positif ou nul).
Le fichier course.py contient un squelette de code prêt à tester votre fonction. Vous êtes encouragés à écrire
d’autres fonctions auxiliaires si vous le jugez nécessaire.
3.5.2 Avec modifications !

Vous allez maintenant modifier des listes, soit directement des éléments (valeurs contenues dans la liste), soit par
ajout/suppression d’éléments.
Exercice 5 : Familiarisation
• Essayez vous à modifier les éléments d’une liste dans l’interpréteur Python : que fait maliste [5] = 12 ? Que se
passe-t’il si la liste n’existe pas ? Et si elle est de longueur trop petite ? etc.
• Écrivez un programme qui demande des nombres strictement positifs à l’utilisateur et les stocke dans une liste.
La saisie s’arrête dès que l’utilisateur entre “0” (zéro). Affichez ensuite la moyenne de cette liste.
• Écrivez un programme qui inverse l’ordre des éléments d’une liste. Par exemple [1, 3, 9, 6, 4] doit devenir
[4, 6, 9, 3, 1] .
Note : il y a plusieurs manières de résoudre ce problème. Vous êtes libres de garder une seule liste du début à la
fin, ou de créer des listes temporaires, d’ajouter, supprimer des valeurs, etc.
Exercice 6 : Les mutables : encore du PythonTutor !

Vous avez dû remarquer que l’archive contenait d’autres fichiers pour PythonTutor. Ces programmes permettent
d’illustrer le comportement “étrange” des listes par rapport aux variables que vous avez l’habitude de manipuler. Il est
essentiel à cette étape de bien comprendre la différence de comportement entre données “mutables” (notamment les
listes) et “non-mutables” (entiers, flottants, chaînes de caractères. . . ) en python.
C’est le moment d’ouvrir et de tester ces programmes sous PythonTutor (ils sont dans l’ordre croissant de difficulté).
Observez bien les “flèches” de PythonTutor qui montrent à quels objets les variables se réfèrent. Si vous
ne comprenez pas le comportement d’un des programmes, faites appel à votre chargé·e de TP.
pythontutor3.py pythontutor5.py
maliste = [1, 3, 9, 6, 4] maliste = [[1], [3], [9], [6], [4]]
autre = maliste print(maliste)
autre [2] = 42 i =0
while i < len(maliste):
print (maliste) element = maliste[i ]
print (autre) print ("indice", i , "␣contient:␣", element)
pythontutor4.py i = i+1
def incremente(i): print("Avant:", maliste)

i = i+1 maliste[3]=maliste [2]
maliste [2]. append(0)
print("Apres:", maliste)
def incr_liste ( liste ) :
i =0
while i < len(liste ) :
liste [ i ] = liste [ i ] + 1
i = i+1
x = 12
maliste = [1, 3, 9, 6, 4]
incremente(x)
incr_liste (maliste)
print(x)
print(maliste)
Exercice 7 : Recyclage et tri sélectif

Reprenez l’exercice 33 à la page 42 et écrivez une fonction tri_insertion qui trie une liste d’entiers par insertion
successive dans une liste triée. C’est le principe en général appliqué lorsqu’on trie sa “main” dans un jeu de cartes.
3.5. TP6 ET TP7 : LISTES, BOUCLES FOR 73
Source : http://staff.ustc.edu.cn/
Un autre façon possible de trier une liste est de prendre le minimum et de le mettre au début, puis de recommencer
avec le deuxième plus petit, etc.
Source : http://x- wei.github.io/
Écrivez une fonction tri_selection qui trie une liste d’entier par sélections successives du plus petit élément de
la partie non triée de la liste.
Exercice 8 : Le retour des courses (difficile)

Reprenez le même exercice que pour les duels de chevaux de courses. Cette fois, vous devez apparier les n chevaux
existants pour former n/2 courses intéressantes (on supposera que n est pair).
1. Faites une fonction qui étant donnée une liste des forces de chevaux, renvoie une liste des couples telle que la
différence des forces entre chaque couple soit la plus petite possible.
Indices : Encore une fois, cet exercice nécessite de bien comprendre et modéliser le problème avant de se lancer
dans l’écriture du code. Il est très difficile de le résoudre d’un seul bloc, il est donc fortement recommandé de
“découper” le problème en sous-tâches plus simple, et de faire autant de fonctions auxiliaires que nécessaire
2. (Vraiment difficile) Avez vous vu que l’ordre dans lequel les paires étaient faites était important ? On peut parfois
avoir des courses peu intéressantes dans un ordre alors qu’un autre serait meilleur. Par exemple, pour les 4 chevaux
suivants [12, 13, 11, 15] , si on commence par faire (12,13) , il nous reste (11,15) qui n’est pas très intéressante.
Alors que le mieux aurait été (11, 12) et (13, 15). Avez-vous des idées pour améliorer votre algorithme ?
3.6 TP8 : Fichiers, dictionnaires

3.6.1 Un peu de PythonTutor
Soit les programmes suivants extraits du fichier pythontutor.py, à télécharger sur CaseInE.
def ajouter_zero(dico, clef ) : def ajouter_zero_liste(dico, clef ) :
copie = dict(dico) copie = dict(dico)
copie [ clef ] = 0 copie [ clef ]. insert (0, 0)
return copie return copie
d = {’a’ : 12, ’b’ : 25} e = {’a’ : [1,2,3], ’b’ :[4,5,6]}

d_avec_zero = ajouter_zero(d, ’c’) e_avec_zero = ajouter_zero_liste(e, ’a’)
print("Avant:␣", d) print("Avant:␣", e)
print("Apres:␣", d_avec_zero) print("Apres:␣", e_avec_zero)
1. Avant d’exécuter les programmes, prédire ce qui sera affiché. Identifiez les différences entre les deux programmes et
leur influence sur le comportement attendu.
2. Copier le contenu du fichier pythontutor.py sur PythonTutor et observer son exécution pas à pas.
3. Les programmes se comportent-t-ils comme prévu ? Si non, que feriez-vous pour corriger ce problème ?
3.6.2 Chaînes de caractères - Compléments

Dans cette partie, nous allons voir des fonctions relatives aux chaines de caractères qui peuvent être particulièrement
utiles lorsque l’on travaille avec des fichiers. Pour cette partie, vous travaillerez sur la console d’IDLE.
Exécutez les instructions suivantes et observez le résultat :
>>> message1 = ’Hello world\n’ >>> ’HELLO’.lower()

>>> print(message1) >>> ’hello’.upper()
>>> message2 = ’Hello world\n\n’ >>> ’HeLLo’.lower()
>>> print(message2) >>> ’a b c’.split()
>>> print(message2.strip()) >>> ’a:b:c’.split(’:’)
>>> message4 = ’ hi ’ >>> ’,’.join([’a’,’b’,’c’])
>>> print(message4.strip()) >>> ’:’.join([’a’,’b’,’c’])
1. Question : À quoi sert chacune des fonctions suivantes : strip(), lower(), upper(), split() et join() ?
Pour en savoir plus, n’hésitez pas à consulter la documentation :
Section 4.7.1 String methods https://docs.python.org/3.6/library/stdtypes.html#string-methods
(vous pouvez aussi taper help(str) dans l’interpréteur Python)
2. Complétez les programmes ci-dessous :
>>> s1=’SaLuT’ >>> s1=’ ok \n’ >>> s1=[’yes’, ’no’, ’maybe’] >>> s1=’Albus.Severus.Potter’
>>> >>> >>> >>>
>>> s2 >>> s2 >>> s2 >>> s2
’salut’ ’ok’ ’yes-no-maybe’ [’Albus’, ’Severus’, ’Potter’]
3.6.3 Travailler avec des fichiers texte - Premiers pas

Nous allons maintenant apprendre à utiliser des fichiers dans nos programmes. Avant de commencer nous allons préparer
notre "espace de travail".
1. Créez un dossier appelé "TP8" dans le répertoire INF204 sur votre compte. Au long de ce TP, on appellera ce dossier
votre "répertoire de travail". Vous devez sauvegarder tous vos programmes, ainsi que les fichiers téléchargés, dans
ce même répertoire.
3.6. TP8 : FICHIERS, DICTIONNAIRES 75
Exercice 1 : Proverbe du jour

Le fichier proverbs.txt, à télécharger, contient un grand nombre de proverbes en anglais en une seule ligne, séparés
par des points ".", ce qui le rend assez difficile à lire. On veut tout d’abord reformatter ce fichier pour le rendre plus
lisible.
1. Téléchargez le fichier proverbs.txt vers votre répertoire de travail.
2. Ecrire un programme qui crée un nouveau fichier nommé proverbs_readable.txt qui contient les mêmes pro-
verbes que le fichier original mais avec un seul proverbe par ligne, chacun terminé par un point. Vérifiez que le
fichier a bien été créé dans votre répertoire de travail, et qu’il est bien au bon format.
3. Ecrire un programme qui lit l’un des deux fichiers, et affiche un message d’accueil, suivi d’un proverbe aléatoire
(utiliser le module random). Exemple :
Bonjour, voici votre proverbe du jour :

"Actions speak louder than words."
3.6.4 Champion de scrabble

Dans cette partie, nous allons utiliser les notions vues précédemment combinées avec les dictionnaires pour développer
un programme qui sait jouer au célèbre jeu du scrabble.
Exercice 2 : Anagrammes
Pour commencer, on veut créer une fonction qui permet de vérifier si un ensemble de lettres (chaîne de caractères)
est un anagramme d’un mot déja connu. A l’aide des dictionnaires, il est assez facile de faire cette vérification. En effet,
si on représente chaque mot par un dictionnaire associant à chaque lettre du mot le nombre de fois où elle apparaît
dans le mot, le dictionnaire généré pour un mot et celui généré pour un de ses anagrammes sont identiques.
1. En vous inspirant de l’exercice 40 de la page 45, écrivez une fonction mot_vers_dictionnaire(mot), qui prend
un mot (chaine de caractères) et renvoie le dictionnaire correspondant. Par exemple :
>>>mot_vers_dictionnaire("tasses")
{’a’: 1, ’s’: 3, ’e’: 1, ’t’: 1}
2. En utilisant la fonction mot_vers_dictionnaire, écrire une fonction est_anagramme(lettres, mot) qui envoie
True si la chaine de caractères lettres est un anagramme du mot mot, False sinon.
>>> est_anagramme("tusla", "salut")

True
>>> est_anagramme("salus", "salut")
False
Exercice 3 : Solution parfaite

En utilisant les fonctions précédemment définies, on peut déja construire une première version de notre programme.
Cette première version va prendre les lettres que l’utilisateur a tirées, et lui afficher les mots français qui peuvent être
formés en utilisant TOUS les jetons qu’il a en main.
Le fichier mots.txt à télécharger est un fichier texte contenant tous les mots français du petit Larousse. Il contient
un mot par ligne, sans accents, et en majuscule.
1. Téléchargez le fichier mots.txt vers votre répertoire de travail.

2. Ecrire un programme principal qui demande à l’utilisateur une chaine de caractères, et qui affiche tous les mots du
fichier mots.txt qui peuvent être formés à partir de ces lettres. (Utiliser la fonction est_anagramme). L’utilisateur
peut saisir des majuscules ou des minuscules. Utiliser les fonctions vues dans la première partie du TP pour que
le programme marche quelle que soit la casse.
Quelles lettres avez vous en main ? taslu

Voici les mots que vous pouvez jouer:

SALUT
TALUS
Exercice 4 : Solution exhaustive

Comme il n’est pas toujours possible de former un mot en utilisant toutes les lettres disponibles, on aimerait que
notre programme soit également capable de nous renvoyer tous les mots que l’ont peut former en utilisant seulement
une partie des jetons à notre disposition. Cela requiert une méthode un peu plus élaborée que celle des anagrammes.
Si on considère toujours la représentation d’un mot par un dictionnaire, pour vérifier qu’une chaine C permet
de former un mot M, il suffit de vérifier que chaque lettre du mot M apparait dans la chaine C au moins une fois.
Autrement dit, pour chaque lettre L du mot M, le nombre d’apparitions de L dans C doit être supérieur ou égal au
nombre d’apparitions de L dans M.
1. Ecrire une fonction peut_ecrire(lettres, mot) qui retourne True si le mot mot peut être écrit en utilisant des
lettres de la chaine de caractères lettres, False sinon.
>>> peut_ecrire("tatxslua", "salut")

True
>>> peut_ecrire("lasautaionna", "salutation") # pas assez de "t"
False
2. Ecrire maintenant le programme qui permet d’afficher tous les mots français pouvant être formés par les lettres
saisies par l’utilisateur. On n’affichera que les mots de longueur 3 ou plus.

ALU
AULT
LAS
LATS
LUT
SAL
SALUT
SAUT
TALUS
TAS
TAU
USA
3.6. TP8 : FICHIERS, DICTIONNAIRES 77
Exercice 5 : Solution optimale

Dans le jeu du scrabble, chaque lettre est associée à un nombre de points. Ce sont ces points qui permettent de
calculer le score de chaque joueur à la fin de la partie. On aimerait que notre programme soit capable de choisir, parmi
les mots qu’on peut jouer, celui qui a le plus grand total de points.
Pour ce faire, on stocke les points correspondant à chaque lettre dans un fichier texte appelé points.txt. Chaque
ligne de ce fichier contient une lettre et son nombre de points, séparés par des espaces.
1. Téléchargez le fichier points.txt vers votre répertoire de travail.
2. Ecrire une fonction lire_points() qui lit le fichier points.txt et renvoie un dictionnaire faisant correspondre
à chaque lettre son nombre de points (entier).
3. Ecrire une fonction score_mot(points, mot) qui prend en argument un dictionnaire faisant correspondre à
chaque lettre son nombre de points, et un mot, et qui renvoie le score.
4. Modifier le programme de l’exercice précédent pour qu’il n’affiche que le meilleur mot à jouer, ainsi que le score
correspondant.
Voici le meilleur mot que vous pouvez jouer:
SALUT pour un score de: 9
Exercice 6 : Avec Jokers

Dans le jeu du scrabble, il existe des jetons blancs appelés Jokers. Ces jetons peuvent être utilisés pour remplacer
n’importe quelle lettre de l’alphabet. Les jokers valent 0 points. Dans notre programme, le joker sera représenté par le
caractère ’_’.
1. Reprenez le programme défini dans l’exercice 4 en modifiant la fonction peut_ecrire afin qu’elle prenne en
compte les jokers dans la chaine saisie par l’utilisateur.
Quelles lettres avez vous en main ? r_sg

...
GARS
GPRS
GRAS
GRE
GRES
GRIS
GROS
...
2. Pouvez-vous modifier le programme de l’exercice 5 de sorte à ce que les jokers ne rentrent pas dans le calcul du
score ?
3.6.5 Annale examen 2018

Exercice 7 : Compétition de saut à skis
On s’intéresse aux scores d’une épreuve de saut à ski. Le score d’un athlète dépend de la distance et de la qualité
de son saut. La qualité du saut est évaluée par 5 juges, qui donnent chacun une note sur 20 points. Le maximum et le
minimum de ces 5 notes sont retirés et on obtient une note sur 60 points. La distance est convertie en un nombre de
points et donne une note sur 100 points. Les deux valeurs sont additionnées pour obtenir le score final sur 160 points.
1. Ecrivez une fonction total_style qui prend en argument la liste des 5 notes de style attribuées à un concurrent
et qui renvoie la note totale obtenue en retirant la note minimale et la note maximale et en faisant la somme
des autres notes. On pourra utiliser les fonctions min et max qui existent en Python et renvoient respective-
ment le minimum et le maximum d’une liste passée en argument (exemple d’utilisation pour la fonction min :
min([2,5,0,3,4]) renvoie 0). On interdit par contre d’utiliser la fonction sum.
Exemple : total_style([18.5, 19.5, 19.5, 19.0, 19.5]) renvoie 58 (c’est-à-dire le résultat obtenu en fai-
sant 19.5 + 19.5 + 19.0, c’est-à-dire la somme des 5 notes dont on a enlevé le minimum 18.5 et le maximum
19.5).
2. Ecrivez une fonction convertir_liste qui prend en argument une liste de chaînes de caractères représentant
des nombres réels, et renvoie la liste de réels correspondantes.
Exemple : convertir_liste([’1’, ’12.3’, ’4.12’]) renvoie [1, 12.3, 4.12]
3. En fait, à l’issue de la compétition, les scores sont stockées dans un fichier. Chaque ligne du fichier correspond
aux notes d’un concurrent. Sur chaque ligne, il y a : le nom du concurrent suivi de la note liée à la distance,
elle-même suivie des 5 notes de style. Voici ci-dessous, les 4 premières lignes d’un tel fichier dont on ne connaît
pas a priori le nombre de lignes :
Annabel 91.0 18.5 19.5 19.5 19.0 19.5

Balthazar 83.0 19.0 18.5 18.5 18.5 19.0
Capucine 91.0 17.5 17.5 17.5 18.5 19.0
Dalton 92.5 17.0 18.5 18.5 17.5 18.0
Ecrivez-une fonction importer_resultats qui prend en argument le nom du fichier qui contient les résultats
nom_fichier et le lit pour fabriquer la liste des résultats. Chaque élément de cette liste résultat est un dictionnaire
correspondant à un concurrent. Les clés de ce dictionnaire sont :
• ’nom’ à laquelle est associé le nom du concurrent

• ’note_dist’ à laquelle est associée la note obtenue par le concurrent pour la longueur de son saut
• ’notes_style’ à laquelle est associée la liste des 5 notes obtenues par le concurrent pour le style de son
saut.
Ainsi, si le fichier passé en argument est seulement constitué des 4 lignes données en exemple précédemment, la
fonction renverra :
[{’nom’: ’Annabel’, ’notes_style’: [18.5, 19.5, 19.5, 19.0, 19.5], ’note_dist’: 91.0},
{’nom’: ’Balthazar’, ’notes_style’: [19.0, 18.5, 18.5, 18.5, 19.0], ’note_dist’: 83.0},
{’nom’: ’Capucine’, ’notes_style’: [17.5, 17.5, 17.5, 18.5, 19.0], ’note_dist’: 91.0},
{’nom’: ’Dalton’, ’notes_style’: [17.0, 18.5, 18.5, 17.5, 18.0], ’note_dist’: 92.5}]
Attention : on rappelle que par défaut tout ce qui est lu dans un fichier est de type chaîne de caractères. Vous
pouvez utiliser la fonction écrite à la question précédente.
4. On souhaite maintenant pouvoir déterminer le nom du gagnant de la compétition. Ecrivez la fonction gagnant
qui prend en argument la liste des résultats telle qu’on l’obtient en lisant le fichier des résultats avec la fonction
importer_resultats. La fonction gagnant renvoie deux valeurs : le nom du vainqueur et la note totale qu’il a
obtenue. La note totale est obtenue en faisant le total de sa note de style (sur 60) et de la note obtenue pour la
longueur du saut (sur 100). Le vainqueur est celui qui a obtenu la meilleure note totale (sur 160). Vous utiliserez
la fonction total_style écrite précédemment.
Exemple : si liste_dicos vaut
[{’nom’: ’Annabel’, ’notes_style’: [18.5, 19.5, 19.5, 19.0, 19.5], ’note_dist’: 91.0},
{’nom’: ’Balthazar’, ’notes_style’: [19.0, 18.5, 18.5, 18.5, 19.0], ’note_dist’: 83.0},
{’nom’: ’Capucine’, ’notes_style’: [17.5, 17.5, 17.5, 18.5, 19.0], ’note_dist’: 91.0},
{’nom’: ’Dalton’, ’notes_style’: [17.0, 18.5, 18.5, 17.5, 18.0], ’note_dist’: 92.5}]
gagnant(liste_dicos) renverra ’Annabel’ et 149.0

5. Ecrivez un programme principal qui lit les résultats d’une compétition stockés dans un fichier nommé ’res_compet.txt’
(contenu dans le même dossier que le programme Python) et fabrique la liste des dictionnaires des résultats corres-
pondante. Le programme affiche ensuite un message pour désigner le vainqueur de la compétition, en respectant
le format d’affichage ci-dessous :
Annabel est médaille d’or avec un total de 149.0 points.
On utilisera le plus possible les fonctions écrites précédemment.
Chapitre 4
Annales et fiche mémo
79
80 CHAPITRE 4. ANNALES ET FICHE MÉMO
Université Grenoble Alpes DLST
UE INF204 Année 2018-19
INF204 - Contrôle Continu 2018-19
2h, sans documents, sans dispositifs électroniques
Le barème est indicatif.

Vous ne devez pas utiliser de listes.
un résumé de syntaxe Python 3 est fourni à la n du sujet.
Documents à rendre : La feuille de réponse synthétique (pour toutes les réponses)
1 Exercice 1. Questionnaire (5 Points)
1.1 A l'exécution du programme ci-dessous, le message 1.6 Que s'ache-t-il à l'exécution du programme suivant?
d'erreur suivant s'ache : "Syntax error : invalid def ajoute_suffixe(chaine,suffixe) :
syntax". Quelle est l'erreur? chres = chaine + suffixe
n = int(input("Entrez un nombre : ") return chres
print(n)
ajoute_suffixe("bon","jour")
1.2 Combien d'étoiles le programme suivant ache-t-il? print(chres)
i = 0 1.7 Que s'ache-t-il à l'exécution du programme ci-dessous?

while i <= 5 :
print('*') def f(n) :
i = 0
1.3 Combien d'étoiles le programme suivant ache-t-il? while i <= n :
return i
i = 10 i = i + 1
while i > 0 :
print('*') print(f(10))
i = i - 1
1.4 Que s'ache-t-il après l'exécution du code ci-dessous? 1.8 On dénit la fonction ci-dessous :
def calcul(val,taux=0.1,fraisDossier=True) :
n = 1 capital = val * (1 + taux)
i = 1 if fraisDossier :
while i <= 3 : capital = capital - 20
n = n + n return capital
i = i + 1 Indiquer le numéro des appels qui provoquent une erreur
print(n) dans la liste suivante :
1.5 On considère le programme suivant : 1. calcul(1000)
def plus_un(x) : 2. calcul(1000,0.05)
x = x + 1 3. calcul(1000,fraisDossier=False)
4. calcul(1000,fraisDossier=False,taux=0.05)
x = 8
res = plus_un(x) 5. calcul(1000,taux=0.05,True)
print(x) 6. calcul(1000,taux=0.05,fraisDossier=True)
print(res)
1.9 Que s'ache-t-il à l'exécution du programme suivant?
Que s'ache-t-il à l'exécution de : def som_prod(a,b) :
1.5.a) la ligne print(x) ? somme = a+b
1.5.b) la ligne print(res) ? produit = a*b
return somme, produit
x,y = som_prod(8,5)
print("x=", x, "et y =", y)
2 Exercice de lecture (4 Points)
Soit le code suivant :

1. from turtle import * 18. if __name__=="__main__" :
2. 19. i = 1
3. def deplacer(x,y) : 20. longueur = 40
4. up() 21. h = 40
5. goto(x,y) 22. x = -20
6. down() 23. y = 140
7. 24. while i <= 5 :
8. def tracer_figure(longueur,largeur) : 25. deplacer(x,y)
9. i=1 26. tracer_figure(longueur,h)
10. while i <= 4 : 27. y = y - 40
11. if i%2 == 0 : 28. longueur = longueur + 40
12. forward(largeur) 29. i = i + 1
13. else :
14. forward(longueur)
15.
16. right(90)
17. i = i+1
1. Quelles sont les variables locales de la fonction tracer_figure ?

2. Quelle est la gure géométrique tracée par la fonction tracer_figure ?
3. Ligne 26, avec quelles valeurs d'arguments est appelée la fonction tracer_figure ? (remplir le tableau avec le nom des
arguments et leur valeur, on précisera également les valeurs de i, x et y au moment de l'appel).
4. Sur la feuille de réponse, reproduire le dessin obtenu. Les carreaux sont de taille 20 * 20. Les lignes en pointillés sur la
feuille réponse correspondent à l'axe des abscisses et ordonnées.
3 Zigzag (exercice Caseine - 4 Points)
Ecrire un programme qui demande à l'utilisateur deux entiers qui correspondront à la numérotation de la première et de la
dernière ligne, puis un troisième entier qui correspondra au nombre de z avant "zigzag" (sans compter le premier "z" de zigzag),
puis enn qui ache un zigzag suivant le modèle suivant :
Exemple 1 : Exemple 2 :
Numero de début:* l'utilisateur tape 3 * Numero de début:* l'utilisateur tape -2 *

Numero de fin:* l'utilisateur tape 10 * Numero de fin:* l'utilisateur tape 4 *
Nombre de z: * l'utilisateur tape 5 * Nombre de z: * l'utilisateur tape 3 *
zzzzzzigzag 3 -2 zzzzigzag
4 zzzzzzigzag zzzzigzag -1
zzzzzzigzag 5 0 zzzzigzag
6 zzzzzzigzag zzzzigzag 1
8 zzzzzzigzag zzzzigzag 3
10 zzzzzzigzag
Exemple 3 :
Numero de début:* l'utilisateur tape 5 *

Numero de fin:* l'utilisateur tape 0 *
Nombre de z: * l'utilisateur tape 10 *
(Rien ne s'affiche car 5>0)
(les entiers pairs doivent être à gauche du zigzag, et les entiers impairs doivent être à droite).
4 Rencontre incertaine dans l'antiquité (7 points)
Achille et Patrocle ont rendez-vous au stade. Malheureusement, les téléphones portables n'ont pas encore été inventés, et les
montres non plus d'ailleurs. La lecture d'un cadran solaire étant relativement approximative, ils ne peuvent dénir un horaire
précis pour leur rendez-vous et décident de se retrouver entre 13h et 14h. Ils disposent toutefois d'un objet magique oert par
1
le dieu Héphaïstos : un sablier. Ils ont chacun un sablier de la même durée.
Le protocole est le suivant : en arrivant au stade, si l'autre ami n'est pas présent, alors celui qui vient d'arriver attend le
temps d'un sablier puis s'en va.
Dans cet exercice, on se demande quelles sont leurs chances de se retrouver. Cela dépend bien sûr de la durée de leur
sablier... On va tirer aléatoirement les horaires d'arrivée des deux amis et voir s'ils se rencontrent. On répétera plusieurs fois
cette expérience pour estimer les chances qu'ont Achille et Patrocle de se rencontrer.
1. Une heure durant 3 600 secondes, on représentera l'horaire d'arrivée de chacun des deux amis par un entier entre 1 et
3600 (bornes incluses). Ecrire une fonction horaires_arrivee qui :
ne prend aucun argument
renvoie les deux horaires d'arrivée (le premier pour Achille, le deuxième pour Patrocle), tirés au hasard de façon
équiprobable entre 1 et 3 600 (bornes incluses).
2. Ecrire une fonction rencontre qui :
prend en argument l'horaire d'arrivée d'Achille horA, l'horaire d'arrivée de Patrocle horP et la durée du sablier en
secondes attente. L'argument attente est optionnel, sa valeur par défaut est de 600 secondes (soit 10 minutes),
renvoie True si la rencontre a lieu et False si la rencontre n'a pas lieu.
Indications : pour que les amis se rencontrent, il faut que leurs horaires d'arrivée soient séparés de moins de la durée d'un
sablier.
3. Ecrire une fonction proba_rencontre qui :

prend en argument un entier nb_simul (le nombre de fois où il faut répéter l'expérience) et la durée du sablier en
secondes attente. L'argument attente est optionnel, sa valeur par défaut est de 600 secondes (soit 10 minutes),
fait nb_simul simulations de rencontre : à chaque fois, choisir aléatoirement les moments d'arrivée des deux amis et
voir s'ils se rencontrent,
calcule et renvoie la proportion de fois où la rencontre a eectivement lieu (un réel entre 0 et 1).
Par exemple, si sur un appel avec 1000 simulations, on trouve que les amis se retrouvent 254 fois sur 1000, la fonction
renverra 0.254 (c'est-à-dire 254 divisé par 1000) . Cette proportion estime la probabilité que les amis se rencontrent si leur
sablier dure attente secondes. Cette fonction utilisera obligatoirement les fonctions précédentes. Le nombre de
simulations nb_simul est supposé strictement positif.
4. Ecrire un programme principal qui :
demande à l'utilisateur le nombre de simulations n à réaliser pour l'estimation, et redemande jusqu'à ce que n soit
strictement positif,
pour chaque temps d'attente entier entre 5 minutes et 50 minutes en allant de 5 minutes en 5 minutes, ache la
proportion de fois où les amis se rencontrent sur n rencontres simulées.
Il faudra appeler la fonction précédente. On rappelle que dans les fonctions précédentes, le temps d'attente doit être en
secondes. On se conformera au modèle d'exécution suivant (bien sûr vos valeurs numériques changeraient un peu à chaque
exécution) :
Nombre de simulations : * l'utilisateur tape 0 *
Erreur, vous devez saisir un nombre positif !
Nombre de simulations : * l'utilisateur tape 1000 *
Avec 1000 simulations :
si attente de 5 minutes, proba : 0.171
1. à cette époque, un sablier est un objet magique très puissant, puisqu'il n'a pas encore été inventé
Nom et Parcours
prénom : et groupe :
Exercice 1 - Questionnaire
1.1 1.6
1.2 1.7
1.3
1.4 1.8
1.5.a)
1.5.b) 1.9
Exercice 2 - lecture de code
2.1 2.2
2.3
Valeur des arguments de tracer_figure (précisez les noms)
Noms : i x y __________ __________
1 appel
er
2 appel
eme
3 appel
eme
4 appel
eme
5 appel
eme
6 appel
eme
7 appel
eme
8 appel
eme
9 appel
eme
2.4
Les carreaux font 20*20. Le point (0,0) est à l'intersection des lignes en pointillés.
Initialement le curseur est en (0,0), orienté vers la droite.
3 4.3
4.4
4.1
4.2
Université Grenoble Alpes DLST
UE INF204 Année 2018-19
INF204 - Examen terminal 2018-19 (session 1)
2h, sans documents, sans dispositifs électroniques

— Le barème est indicatif
— Documents à rendre : La feuille de réponse synthétique (pour toutes les réponses) sur laquelle vous aurez reporté votre
numéro d’anonymat.
— Une fiche mémo recto-verso est fournie à la fin de ce sujet.
— Attention : quand une liste ou un dictionnaire est passé en argument d’une fonction, la fonction n’a pas le droit de
modifier cet argument sauf si c’est explicitement demandé.
1 Exercice : Questionnaire (2,5 points)

Question 1 : Lecture de code
s4 = ['ba','beu','bi']
d = ""
for a in range(1,10,-1) : for mot in s4 :
print(a) d = d + mot
1.1 Indiquer ce qui s’affiche à l’exécution du code print(d)
ci-dessus. 1.4 A l’exécution du code ci-dessus, quelle est la valeur
de d lorsque celle-ci est affichée ?
s2 = {'a' : [123,42,51],
'l' : [19,11,32], 1.5 On définit le dictionnaire s5 :
'u' : [8,12,33]}
s5 = {'bonjour': 'hello',
for b in s2 : 'chien' : 'doing',
print(b) 'chat' : 'cat'}
c = s2['l'][1] Ecrivez une suite d’instructions à exécuter pour modifier

A l’éxécution du code ci-dessus, indiquer : s5 de façon à obtenir (il est interdit d’écrire une instruc-
1.2 les valeurs successives de b. tion commençant par s5 = ) :
1.3 la valeur de c.
s5 = {'bonjour': 'hello',
'chien' : 'dog'
'grenouille' : 'frog'}
2 Exercice Turtle (3 points)

Question 2 : Escalier de cercles
B On suppose qu’on dispose d’une fonction
cercle(x,y,rayon) qui utilise le module turtle pour
tracer un cercle de centre (x,y) et de rayon rayon.
Sur la feuille de réponse, compléter le programme

principal pour lire deux entiers nb_lignes et r et
réaliser un escalier nb_lignes de cercles de rayon r
(voir exemple sur la figure ci-contre, obtenue quand
nb_lignes vaut 5 avec un rayon r égal à 50).
Si la valeur saisie pour r est incorrecte, le programme

redemande une saisie jusqu’à obtenir une valeur strictement
positive.
Si la valeur saisie pour nb_lignes est inférieure ou égale à
zéro, le programme ne doit rien tracer. Le cercle de la pre-
mière ligne a pour centre le point de coordonnées (-200,100).
INF204 - 2018/2019 1 Examen

3 Exercice Caseine : jeux de mots
(4.5 points)
— Dans cet exercice, vous pouvez avoir besoin de convertir un mot en liste de lettres. Pour cela, vous pouvez utiliser
list(...) comme dans l’exemple suivant : list(’oui’) vaut [’o’, ’u’, ’i’].
— On suppose que tous les mots considérés dans cet exercice ne contiennent que des lettres, sans accents et en minuscule
(pas de caractères spéciaux, tirets, espaces, etc...)
— On suppose aussi qu’on dispose d’une fonction est_voyelle qui prend en argument une lettre minuscule et qui renvoie
vrai si la lettre passée en argument est une voyelle et faux sinon.
Question 3 :
Ecrire une fonction commence_par prenant en argument une lettre et un mot et qui renvoie True si le mot commence
par la lettre donnée en argument, False sinon.
Exemple : commence_par(’h’,’hello’) vaut True mais commence_par(’e’,’roue’) vaut False.
Question 4 :
Ecrire une fonction contient_voyelle qui prend en argument un mot et qui renvoie True si le mot contient au moins
une voyelle, False sinon.
Question 5 :
Ecrire une fonction double_consonne qui prend en argument un mot et qui a deux valeurs de retour : un booléen
valant True si le mot contient une double consonne (deux fois la même consonne à la suite), et dans ce cas la deuxième
valeur de retour est la consonne qui est doublée ; s’il n’y a pas de consonne doublée, la fonction doit renvoyer False et
None. Pour information : pour simplifier l’exercice, on renverra la première double consonne (voir exemple ci-dessous
pour ’successeur’).
Exemples :
double_consonne(’arrivee’) vaut True,’r’
double_consonne(’bonbon’) vaut False,None
double_consonne(’reussite’) vaut True,’s’
double_consonne(’successeur’) vaut True,’c’
4 Problème : table des matières de recettes de cuisine (10 points)

On s’intéresse à la gestion d’une collection de recettes de cuisine. On suppose qu’on a stocké informatiquement des
informations sur plusieurs recettes de cuisine. Cet ensemble d’informations est stocké dans une liste. Dans cette liste, chaque
élément est un dictionnaire qui correspond à une recette donnée. Dans le dictionnaire d’une recette, on a 3 clés :
— "nom", à laquelle est associé le nom de la recette,
— "type", à laquelle est associé le type de plat (au choix parmi "aperitif", "entree", "plat principal" et "dessert",
— "ingredients", à laquelle est associée la liste des ingrédients principaux de la recette.
Voici un exemple de liste de 4 recettes selon ce format :
liste_recettes = [{'nom': 'roules aux saucisses', 'type': 'aperitif',

'ingredients': ['pate feuilletee', 'saucisses de strasbourg']},
{'nom': 'omelette', 'type': 'plat principal',
'ingredients': ['oeufs']},
{'nom': 'fondant au chocolat', 'type': 'dessert',
'ingredients': ['chocolat patissier', 'beurre', 'oeufs', 'farine', 'sucre']},
{'nom': 'quiche lorraine', 'type': 'plat principal',
'ingredients': ['pate brisee', 'oeufs', 'creme fraiche', 'lardons']}]
INF204 - 2018/2019 2 Examen

Question 6 :
Ecrire une fonction max_ingredients qui prend en argument une liste de recettes (selon le format de l’exemple
liste_recettes) et renvoie le nom de la recette qui utilise le plus d’ingrédients, ainsi que le nombre d’ingrédients cor-
respondant (en cas d’égalité, on choisira une recette parmi celles qui comptent le plus d’ingrédients). Si la liste passée en
argument est vide, la fonction renvoie None,None.
Exemple : max_ingredients appelée avec la liste liste_recettes de l’exemple renvoie ’fondant au chocolat’,5.
Question 7 :
On souhaite pouvoir mettre à jour notre liste de recettes en saisissant au clavier les informations d’une recette.
Ecrire une fonction ajouter_recette qui prend comme argument la liste des recettes lrecettes et qui demande à
l’utilisateur un nom de recette, un type de plat et la liste des ingrédients nécessaires. Pour finir la saisie des ingrédients,
l’utilisateur devra écrire ’stop’. La liste lrecettes en argument est modifiée pour lui ajouter la recette correspondante
(sans vérifier si elle y est déjà). On respectera le modèle de l’exemple ci-dessous :
Nom recette : * l’utilisateur tape riz au lait *
Type plat (1 : aperitif, 2 : entree, 3 : plat principal, 4 : dessert) : * l’utilisateur tape 12 *
Erreur ! Nombre entre 1 et 4 : * l’utilisateur tape 4 *
Ingredients : * l’utilisateur tape riz rond *
* l’utilisateur tape lait *
* l’utilisateur tape sucre *
* l’utilisateur tape vanille *
* l’utilisateur tape stop *
et le dictionnaire {’nom’ : ’riz au lait’, ’type’ : ’dessert’, ’ingredients’ : [’riz rond’, ’sucre’, ’lait’,
’vanille’]} est ajouté à la fin de la liste de recettes passée en argument.
Question 8 :
On souhaite pouvoir trouver toutes les recettes qui utilisent un ingrédient donné.
Ecrire une fonction recettes_avec_ingredient qui prend en argument une chaîne de caractères ingredient et une
liste de recettes lrecettes et qui affiche toutes les recettes de la liste utilisant l’ingrédient ingredient, ainsi que, pour
chacune de ces recettes, la liste de tous les autres ingrédients nécessaires. On respectera le format d’affichage de l’exemple
ci-dessous. Ainsi si lrecettes correspond à la liste donnée en exemple au début de l’exercice :
— l’appel recettes_avec_ingredient(’oeufs’,liste_recettes) affichera :
Voici les recettes utilisant : oeufs
- omelette. Autres ingredients : []
- fondant au chocolat. Autres ingredients : ['chocolat patissier', 'beurre', 'farine', 'sucre']
- quiche lorraine. Autres ingredients : ['pate brisee', 'creme fraiche', 'lardons']
— l’appel recettes_avec_ingredient(’cannelle’,liste_recettes) affichera :
Voici les recettes utilisant : cannelle
Aucune recette ne correspond.
Question 9 :
On souhaite pouvoir sauvegarder toutes les informations sur les recettes dans un fichier.
Ecrire une fonction sauver_recettes qui prend en argument une chaîne de caractères nom_fichier et une liste de
recettes lrecettes et qui écrit les informations concernant les recettes dans le fichier dont le nom est passé en argument.
Dans le fichier, on écrira une ligne par recette. Pour chaque recette, on écrit d’abord le nom de la recette, puis le type de
plat et enfin les différents ingrédients. Tous ces éléments seront séparés par des ’;’. Ainsi, pour la liste liste_recettes
donnée en exemple au début de l’exercice, on obtiendra dans le fichier :
roules aux saucisses;aperitif;pate feuilletee;saucisses de strasbourg
omelette;plat principal;oeufs
fondant au chocolat;dessert;chocolat patissier;beurre;oeufs;farine;sucre
quiche lorraine;plat principal;pate brisee;oeufs;creme fraiche;lardons
INF204 - 2018/2019 3 Examen

Question 10 :
Compléter le programme principal fourni. Votre programme devra demander à l’utilisateur la saisie d’une nouvelle
recette à ajouter à liste_recettes. Il affichera ensuite la recette qui contient le plus d’ingrédients ainsi que le nombre
d’ingrédients correspondant. Il demandera aussi un ingrédient à l’utilisateur et affichera toutes les recettes utilisant cet
ingrédient. Enfin, il sauvegardera toutes les informations de liste_recettes dans le fichier ’sauvegarde.txt’.
On utilisera le plus possible les fonctions écrites précédemment.
INF204 - 2018/2019 4 Examen

Feuille de réponse Numéro d’anonymat :
Exercice 1
1.1 1.4
1.2 1.5
1.3
__________ Exercice 2___________________________________________________________________________

from turtle import *
def cercle(x,y,rayon) :
""" trace cercle de centre (x,y) de rayon rayon."""
up()
goto(x,y-rayon)
down()
circle(rayon)
__________ Exercice 3___________________________________________________________________________

# Question 3
def commence_par(lettre, mot):
INF204 - 2018/2019 7 Feuille de réponse Examen 2018-19

# Question 4
def contient_voyelle(mot) :
# Question 5
def double_consonne(mot) :
__________ Problème 4___________________________________________________________________________

# Question 6
def max_ingredients(lrecettes) :

# Question 7
def ajouter_recette(lrecettes) :
# liste fournie pour faciliter la correspondance tye de plat / numéro (entre 1 et 4)

liste_types = ['aperitif', 'entree', 'plat principal', 'dessert']
# compléter à partir d'ici
# Question 8
def recettes_avec_ingredient(ingredient, lrecettes) :

# Question 9
def sauver_recettes(nom_fichier, lrecettes) :
# Question 10, prog principal

# charger toutes les recettes qu'on a deja
# (on suppose qu'on a une fonction pour ça)
liste_recettes = charger_recettes()
# compléter à partir d'ici

94 CHAPITRE 4. ANNALES ET FICHE MÉMO
Aide mémoire Python INF204
Opérations sur les types Définition d’une fonction
type() : pour connaître le type d’une variable
int() : permet la transformation en entier def nom_fonction(arg) :
float() : permet la transformation en réel instructions
return valeurs_ou_variables
str() : permet la transf. en chaîne de caractères
Instructions de lecture et écriture console Instructions conditionnelles
print(a1,a2,…, an, sep=xx, end = yy) if condition :

• Pour imprimer une suite d’arguments de a1 à an instructions
• sep : permet de définir le séparateur affiché entre
chaque argument (optionnel, par défaut : " ") if condition :
instructions
• end : permet de définir la chaîne qui sera affichée à
else :
la fin de la chaîne affichée par print (optionnel, par instructions
défaut : saut de ligne)
res = input(message)
• Pour lire une suite de caractères au clavier terminée if condition1 :
par <Enter> instructions
• La chaîne de caractères résultante est affectée (ici à elif condition2 :
la variable res). instructions
• l’argument est optionnel : c’est un message else :
explicatif destiné à l’utilisateur instructions
Opérateurs arithmétiques Turtle : instructions et fenêtre
Curseur initialement en (0,0), baissé et dirigé vers la droite.
+ : addition, - : soustraction Le point (0,0) est au milieu de la fenêtre turtle
* : multiplication, ** : puissance,
/ : division, // : division entière (quotient), reset() : efface tout
% : reste de la division entière goto(x, y) : place le crayon au point x, y
Opérateurs booléens forward(d) : avance de d
and : et logique or : ou logique not : négation backward(d) : recule de d
Opérateur de comparaison up() : relève le crayon
== égalité != différence down() : abaisse le crayon
< inférieur, <= inférieur ou égal left(a) : tourne à gauche de a°
> supérieur, >= supérieur ou égal right(a) : tourne à droite de a°
Opérateurs sur les chaînes de caractères
y
len(s) : renvoie la longueur de la chaîne s
s1 + s2 : concatène les chaînes s1 et s2 (-300,150)
s * n : pour construire la répétition de n fois s
x
exemple : "ta"* 3 donne "tatata"
(0,0)
Itération tant que
while condition :
instructions
Itération for, et range for var in range (deb, fin, pas) :
instructions
for e in list_chaine_ou_dico :
range(a) : séquence des valeurs [0, a[ (pas de 1)
instructions
range (b,c) : séquence des valeurs [b, c[ (pas de 1)
Itère les instructions avec e prenant chaque valeur dans la
range (b, c, g) : idem avec un pas de g
liste, chaîne ou dictionnaire.
range(b,c,-1) : valeurs de b(incl.) à c (excl.) , pas -1
Chaînes de caractères (compléments)
Pour toutes ces fonctions, la valeur de ch n’est pas modifiée.
ch.split(arg) où ch est une chaîne de carac. ch.upper() renvoie la chaîne ch convertie en majuscules
Retourne la liste des mots ici de ch, en coupant à chaque ch.lower() renvoie la chaîne ch convertie en minuscules
occurrence de arg (par défaut arg = " " (un espace) ) ch.strip() renvoie la chaîne ch en ayant enlevé tous les
espaces et retours à la ligne au début et à la fin.
arg.join(liste_ch)
Retourne la chaîne obtenue en concaténant tous les
éléments de liste_ch, en intercalant la chaîne arg
comme séparateur entre chaque paire d’éléments.
2019-2020
Aide mémoire Python INF204
Listes Dictionnaires
list_exple = [] dico_exple = {}
Création d’une liste vide Création d’un dictionnaire vide
list_exple =[e1,e2,e3] dico_exple = { c1:v1, c2:v2, c3:v3 }

Création d’une liste, ici à 3 éléments e1, e2, et e3 Création d’un dictionnaire, ici à 3 entrées
list_exple[i] e = dico_exple[c1]
obtenir l’élément à l’indice i (i>=0) Les valeurs du dictionnaire sont accessibles par leurs clés.
Les éléments sont indexés à partir de 0 Ici, e prendra la valeur v1.
Si i<0, les éléments sont accédés à partir de la fin de la Provoque une erreur si la clé n’existe pas.
liste. list_exple[-1] permet d’accéder au dernier
élément de list_exple dico_exple[c3] = v3
Pour ajouter une nouvelle valeur au dictionnaire (ici v3)
list_exple.append(element) avec une clé (ici c3). Si la clé existe déjà, la valeur associée
Ajout d’un seul élément à la fin de list_exple est modifiée.
list_exple.extend(liste2) del dico_exple[c3]

Ajout de tous les élem. de liste2 à la fin de list_exple Pour supprimer une association dans le dictionnaire. La clé doit
exister.
list_exple.insert(i,element)
Ajout d’un seul élément à l’indice i c in dico_exemple
Pour vérifier l’existence d’une clé dans le dictionnaire. Vaut
res = list_exple.pop(index) True ou False.
Retire l’élément présent à la position index et le
renvoie, ici dans la variable res. dic2 = dico_exple
ème
crée un synonyme (donne un 2 nom au dictionnaire)
list_exple.remove(element)
Retire l’élément donné (le premier trouvé) dic3 = dict(dico_exple)
Pour créer une copie ( = un clone )
len(list_exple)
Retourne le nombre d’éléments d’une liste ____________________________________________
Gestion des fichiers
l2_exple = list_exple
ème
Crée un synonyme (donne un 2 nom à la liste) f=open('data.txt')
Pour ouvrir un fichier en lecture seule
l3_exple = list(list_exmple) f=open('data.txt','w')
Crée une copie de list_exple ( = un clone ) Pour ouvrir un fichier en écriture
elem in list_exple texte = f.read()

Teste si un élément est dans une liste. Pour lire tout le fichier en une seule fois
Retourne True ou False.
lignes = f.readlines()
shuffle(list_exple) (module random) Pour lire en une fois toutes les lignes du fichier et les stocker
Mélange la liste (effet de bord). dans une liste (un élément = une ligne)
list_exple.index(elem) for ligne in f:

Renvoie l’indice de première occurrence de l’élément instructions
elem dans la liste list_exple (provoque une erreur si Pour lire le fichier ligne par ligne dans une boucle for
l’élément n’est pas dans la liste).
f.write(texte)
list_exple[n:m] Pour écrire dans un fichier (texte doit oblig. être un str).
Pour récupérer une sous-liste constituée des éléments Ne saute pas de ligne automatiquement à la fin du texte. ‘\n’
entre les indices n (inclus) et m (exclu). code un saut de ligne.
list_exple[:4] : les 4 premiers éléments
list_exple[4:] : les éléments de l’indice 4 à la fin f.close()
Pour fermer un fichier
2019-2020

polyINF204 2020

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

polyINF204 2020

Transféré par

Droits d'auteur :

Formats disponibles

INF204

Méthodes informatiques et techniques de programmation en Python

Polycopié créé conçu à partir de documents conçus par :

4 Annales et fiche mémo 79

INF204 Semaine 1 1 INF204 Semaine 1 2

Un outil de travail : CaseInE Notions de la semaine :

INF204 Semaine 1 3 INF204 Semaine 1 4

Compilation et interprétation Algorithme vs Programme

INF204 Semaine 1 5 INF204 Semaine 1 6

Exercice Programmes en Python

INF204 Semaine 1 7 INF204 Semaine 1 9

Variables Identificateurs en Python

INF204 Semaine 1 10 INF204 Semaine 1 11

INF204 Semaine 1 12 INF204 Semaine 1 13

Affectation vs Condition en Python Notion de typage

INF204 Semaine 1 14 INF204 Semaine 1 15

INF204 Semaine 1 16 INF204 Semaine 1 17

Quelques opérateurs Exercice

INF204 Semaine 1 18 INF204 Semaine 1 19

Entrées / Sorties Les entrées : fonction input()

INF204 Semaine 1 20 INF204 Semaine 1 21

Introduction Variables et expressions In/Out Si... sinon

Les entrées (1) Les entrées (2)

INF204 Semaine 1 22 INF204 Semaine 1 23

Les entrées (3) Les sorties : la fonction print()

INF204 Semaine 1 24 INF204 Semaine 1 25

Exemples de sorties Instructions conditionnelles : if

INF204 Semaine 1 26 INF204 Semaine 1 27

Instructions conditionnelles : if . . . else Exemple d’instruction conditionnelle

Attention : le else n’est pas suivi d’une condition

INF204 Semaine 1 28 INF204 Semaine 1 29

Instructions conditionnelles : avec elif Instructions conditionnelles : avec elif

On calcule le discriminant : D= b2 - 4 *a *c print("Une seule racine reelle")

D > 0 : 2 solutions else : # ici on a forcement d < 0

INF204 Semaine 1 30 INF204 Semaine 1 31

Université Grenoble Alpes

INF204 Semaine 2 1 INF204 Semaine 2 2

Fonctionnement et syntaxe Exemple: division de a par b

INF204 Semaine 2 3 INF204 Semaine 2 4

Attention aux boucles infinies! Compteur de boucle

Compteur de boucle: exemples Compteur de boucle: exemples

i = 0 # variable compteur i = 0 # variable compteur

Le pas = augmentation du compteur à chaque étape Ici le pas = 2

INF204 Semaine 2 7 INF204 Semaine 2 8

Compteur de boucle: exemples Variable "accumulateur"

INF204 Semaine 2 9 INF204 Semaine 2 10

Initialisation de « l’accumulateur » Variable « drapeau »

INF204 Semaine 2 11 INF204 Semaine 2 12

Autre programme possible Initialisation d’un « drapeau »

INF204 Semaine 2 13 INF204 Semaine 2 14

INF204 Semaine 3 1 INF204 Semaine 3 2

Boucles imbriquées Chaîne de caractères

Exemple d’application Précisions sur les chaînes de caractères

INF204 Semaine 3 4 INF204 Semaine 3 6

Chaînes de caractères Chaînes de caractères

Intérêt de ces syntaxes Exemples

INF204 Semaine 3 7 INF204 Semaine 3 8

Opérations sur les chaînes de Parcourir une chaîne de caractères

>>> "ta " * 4 print( n * (n * "*" + "\n" ))

INF204 Semaine 3 9 INF204 Semaine 3 10

Exemple d’application « ou » logique : or

INF204 Semaine 3 11 INF204 Semaine 3 13

Expressions booléennes Expressions booléennes

On calcule le discriminant : D= b2 - 4 a c print("Une seule racine reelle")

• créée ou modifée dans le corps d'une fonction , if name=="main": # prog. principal

if name=="main": # prog. principal