UNIVERSITÉ DE CAEN

BUT Réseaux et Télécoms R208

TP1 – programmes, sous-programmes et packages, exceptions

(2h)
On préférera faire ce TP sous Linux pour la simplicité des chemins d’écriture, mais il
est tout à fait réalisable sur Windows !

Exercice 1 Environnement - révisions

1. Ouvrir un interpréteur de commande Python et lancez les commandes :
>>> import s y s
>>> s y s . path

A quoi correspond cette variable ? Rappelez-vous de ce qu’on a vu en début d’année

en R108... Est-ce que le PATH Python est le même que le PATH bash ?
2. Créer un fichier /tmp/[Link] (bien respecter le chemin) Ce fichier python
doit contenir une fonction nommée hello() qui ne prends rien en argument mais
qui renvoie la valeur ”Hello World !” en chaı̂ne de caractères.
3. Se placer dans le répertoire /tmp et ouvrir un interpréteur de commandes Python :
comment faire pour importer le module helloWorld ? Faire en sorte de pouvoir
exécuter la fonction hello()
4. Se placer maintenant dans votre répertoire personnel, ouvrir un interpréteur de
commandes Python et essayer d’importer le module helloWorld : pourquoi cela
ne fonctionne-t-il pas ? Se référer à la première question... Faites en sorte de pouvoir
importer n’importe quel module du répertoire /tmp depuis n’importe quel autre
répertoire !

Exercice 2 Révisions Python et test de package existant

Dans un répertoire de votre choix de votre dossier personnel (home) créer un fichier
[Link] dans lequel vous créerez toutes les fonctions demandées dans les questions
suivantes :
1. Créer la fonction whatTime() :
— elle ne demande rien en argument
— elle utilise la fonction time de la bibliothèque time afin d’obtenir le ”temps”
actuel et renvoie cette valeur comme résultat
→ voir la doc [Link]
# exemple d ’ e x e c u t i o n
>>> whatTime ( )
1645454619.5490332

1
2. Créer la fonction randomNumber() :
— elle ne demande rien en argument
— elle utilise la fonction randint de la bibliothèque random afin d’obtenir un
nombre aléatoire entre 1 et 10 inclus
— elle renvoie ce nombre aléatoire comme résultat
# exemple d ’ e x e c u t i o n
>>> randomNumber ( )
3
>>> randomNumber ( )
5

3. Créer la fonction askUser() :

— elle ne demande rien en argument
— elle demande à l’utilisateur d’entrer une valeur (avec un input)
— enfin, elle renvoie la valeur de l’utilisateur convertie en entier
# exemple d ’ e x e c u t i o n
>>> a sk U se r ( )
Quel e s t v o t r e c h o i x ? 14
14

4. Créer la fonction guess(toFind) :

— elle prend en argument un entier (toFind)
— elle fait appel à la fonction askUser() afin de demander à l’utilisateur une
valeur et la stocke dans une variable
— elle compare la valeur entrée par l’utilisateur à celle donnée en argument (toFind)
— si les deux valeurs sont égales, la fonction renvoie True, sinon elle renvoie False
# exemple d ’ e x e c u t i o n
>>> g u e s s ( 6 )
Quel e s t v o t r e c h o i x ? 3
False
>>> g u e s s ( 6 )
Quel e s t v o t r e c h o i x ? 6
True

2
Exercice 3 Utilisation des outils dans un programme principal

Pour toutes les questions suivantes, le travail sera à faire dans un fichier [Link]

1. Importer dans ce fichier les fonctions du fichier [Link] (comme vu précédemment)

2. On souhaite créer un petit jeu qui tire un nombre aléatoire en 1 et 10, demande
à l’utilisateur une valeur et affiche si l’utilisateur a trouvé le bon nombre ou pas !
Créer une fonction randomGame() :
— elle ne prend rien en argument
— elle tire un nombre aléatoire avec la fonction randomNumber() du package tools
et le stocke dans une variable
— elle utilise la fonction guess(toFind) pour demander à l’utilisateur une valeur
— si cette fonction renvoie True, on affiche un message de victoire
— sinon, on affiche un message de défaite avec la valeur qu’il fallait trouver
# exemple d ’ e x e c u t i o n
>>> randomGame ( )
Quel e s t v o t r e c h o i x ? 2
Bravo , c e s t gagn é !
>>> randomGame ( )
Quel e s t v o t r e c h o i x ? 6
Perdu ! Le r é s u l t a t à t r o u v e r é t a i t : 5

3. Faire en sorte que la fonction précédente se lance automatiquement lorsqu’on charge

le fichier [Link] dans un interpréteur Python : pour cela il faut créer un ”main”
(voir le cours ou de la doc en ligne...)

Exercice 4 Exceptions de base

1. Fonction de division : gestion des erreurs

(a) Créer une fonction division() :
— elle ne prends rien en entrée
— elle demande deux nombres à l’utilisateur
— elle convertit ces nombres en entier
— enfin, elle retourne le résultat de la division flottante du premier par le
deuxième
# exemple d ’ e x e c u t i o n
>>> d i v i s i o n ( )
Premier nb ? 9
Deuxi ème nb ? 2
4.5

,→ je vous ai dit que ce n’était pas une bonne habitude de demander les variables
à l’utilisateur et qu’il fallait mieux les passer en paramètre, c’est juste pour l’exercice !

(b) Tester de ”planter” votre fonction à l’exécution : entrer une chaı̂ne de caractères
au lieu d’un entier, ou mettre zéro pour le deuxième nombre : que se passe-t-il ?

3
 (c) Ajouter un bloc try...except afin de générer toutes les exceptions possibles
dans la fonction. Il faut afficher le détail de l’exception quand cela arrive et
l’opération qui a posé problème.
# exemple d ’ e x e c u t i o n
>>> d i v i s i o n ( )
Premier nb ? 9
Deuxi ème nb ? ’ w h a t d o e s t h e f o x s a y ’
E x c e p t i o n s u r l e deuxieme nb : unsupported operand type ( s ) f o r / :
’ i n t ’ and ’ s t r ’

(d) Modifier la fonction précédente afin d’afficher un message spécifique en fonc-

tion de l’exception déclenchée. On veut au moins gérer le problème de type de
données entré et la division par zéro.
2. Fonction d’accès à un fichier : gestion des erreurs
(a) Créer une fonction readFile(filename) :
— elle prends en entrée un chemin de fichier (de préférence absolu)
— elle affiche un message de bienvenue, puis tout le contenu du fichier
# exemple d ’ e x e c u t i o n
>>> r e a d F i l e ( ’ /home/ l e n a i n / l i s t e D e C o u r s e . t x t ’ )
DEBUT DU FICHIER
= des t o r c h e s
= une p a i r e de c h a u s s e t t e
= un sandwich au p o u l e t
= une hache d u r a n d i l
FIN DU FICHIER

(b) Essayez maintenant de générer des exceptions à l’exécution de votre programme

en donnant en argument :
— un chemin de fichier qui n’existe pas
— un chemin de répertoire
— un chemin de fichier où on n’a pas le droit de lecture (par exemple /etc/shadow)
Pensez à relever le nom des exceptions à chaque fois.

(c) Modifiez le code de votre fonction readFile afin de gérer les 3 exceptions
relevées précédemment : on veut à chaque fois afficher un message d’erreur per-
tinent en fonction du cas de figure.

4
Exercice 5 Pour les plus rapides : complément de l’exercice 3

4. Créer une fonction randomGameScore(turns) :

— elle prends en entrée un entier turns qui représente le nombre de tours de jeux
que l’on va effectuer
— elle effectue les mêmes opérations que précédemment, sauf que l’on va faire
plusieurs fois des tours de jeux : à chaque fois on va incrémenter (ou non) une
variable indiquant le nombre de victoires
— à la fin, elle affiche le score de l’utilisateur
# exemple d ’ e x e c u t i o n
>>> randomGameScore ( 3 )
Tour numé r o : 1
Quel e s t v o t r e c h o i x ? 3
Perdu ! Le r é s u l t a t à t r o u v e r é t a i t : 10
Tour numé r o : 2
Quel e s t v o t r e c h o i x ? 1
Bravo , c e s t gagn é !
Tour numé r o : 3
Quel e s t v o t r e c h o i x ? 6
Perdu ! Le r é s u l t a t à t r o u v e r é t a i t : 4
Score f i n a l : 1 / 3

5. Créer une fonction randomGameScoreTime(turns) :

— elle stocke le temps en début de fonction avec la fonction whatTime()
— elle fonctionne comme précédemment avec le nombre de tours
— à la fin, elle affiche le score de l’utilisateur et le temps mis pour trouver les
réponses
# exemple d ’ e x e c u t i o n
>>> randomGameScoreTime ( 2 )
Tour numé r o : 1
Quel e s t v o t r e c h o i x ? 4
Perdu ! Le r é s u l t a t à t r o u v e r é t a i t : 8
Tour numé r o : 2
Quel e s t v o t r e c h o i x ? 6
Perdu ! Le r é s u l t a t à t r o u v e r é t a i t : 2
S c o r e f i n a l : 0 / 2 en 5 . 3 5 2 6 2 8 9 4 6 3 0 4 3 2 1 secondes !

6. Améliorer la fonction précédente pour afficher le temps arrondi au dixième. On

cherche de la doc et on se débrouille !