PYTHON : EXERCICES NIVEAU B
Les exercices proposés sur cette page nécessitent l'utilisation des outils
de la bibliothèque fournie avec la distribution standard du langage Python.
Cette bibliothèque intègre de nombreux outils extrêmement diversifiés, qui
permettent d'accélérer grandement le développement de programmes complexes.
Elle est organisée sous forme de "modules" dont il faut explicitement
importer les fonctionnalités souhaités.
Pour bien démarrer, il est fortement conseillé de s'inspirer de quelques
exemples de programmes. Deux sources de documentation sont disponibles :
- Les codes sources disponibles dans la rubrique "Exemples
Niveau B" fournissent des exemples d'utilisation pour les
fonctionnalités les plus courantes de la bibliothèque standard
- Mais pour disposer d'une documentation complète, il faut consulter la
Python Library Reference, qui figure parmi les
documents directement accessibles dans l'aide en ligne fournie avec
l'environnement Python (obtenue par un appui sur la touche F1). L'ensemble
de la bibliothèque y est décrite, module par module, en fournissant à chaque
fois la description complète des fonctionnalités, ainsi que des exemples de
mise en oeuvre.
Exercice B0
L'objectif de cet exercice d'introduction est de réaliser une série de
modifications simples sur les codes sources fournis dans la rubrique
"Exemples Niveau B" :
- Modifier le programme random (cf. exemple B1)
pour qu'il simule un tirage aléatoire à distribution uniforme sur le carré
unité [0,1]x[0,1] et affiche l'histogramme obtenu pour 100000 tirages. Même
question avec une distribution gaussienne sur [0,1]x[0,1].
- Modifier le programme csv (cf. exemple B4)
pour qu'il ne sélectionne que les valeurs impaires stockées dans le fichier
et qu'il les affiche en les triant par ordre décroissant.
- Modifier le programme os (cf. exemple B6) pour
inclure un exemple d'utilisation de la commande walk
disponible dans le module standard os (cf.
documentation sur ce module).
Exercice B1
Ecrire un programme count qui compte le nombre de
lignes, de mots et de caractères d'une liste de fichiers texte, dont les noms
sont entrés par l'utilisateur. L'existence et la protection en lecture de chaque
fichier doit être vérifiée et un message d'erreur affiché le cas échéant.
Exemple d'exécution :
────────────────────────────────────────────────────────────────────────────────
COUNT : print the number of lines, words and chars of a list of text files
User input : <filename> [filename ...]
App output : number of lines, words and chars for each provided file
Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> <filename> [filename ...]: toto.txt titi.txt
toto.txt : lines = 4, words = 23, chars = 112
titi.txt : cannot read file
<> <filename> [filename ...]:
Exercice B2
Ecrire un programme rilex qui calcule la richesse
lexicale d'un texte contenu dans un fichier dont le nom est entré par
l'utilisateur. La richesse lexicale d'un texte est définie comme le quotient entre le nombre de mots différents et le nombre total de
mots du texte. Dans cet exercice, on définit la notion de "mot" comme
toute séquence de taille supérieure ou égale à quatre, formée exclusivement de
caractères alphabétiques (on ne distinguera pas les majuscules des
minuscules). Pour l'implémentation, on utilisera la structure native de
dictionnaire fournie par le langage Python.
Exemple d'exécution :
────────────────────────────────────────────────────────────────────────────────
RILEX : print the lexical richness of a list of text files
User input : <filename> [filename ...]
App output : lexical richness of all provided files
Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> <filename> [filename ...]: toto.txt titi.txt
toto.txt : rilex = 0.67
titi.txt : cannot read file
<> <filename> [filename ...]:
Exercice B3
Ecrire un programme numlines qui affiche le contenu
d'une liste de fichiers texte, dont les noms sont entrés par l'utilisateur, en
numérotant les lignes.
Exemple d'exécution :
────────────────────────────────────────────────────────────────────────────────
NUMLINES : print a list of text files with line numbering
User input : <filename> [filename ...]
App output : content of all provided files with line numbering
Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> <filename> [filename ...]: toto.txt titi.txt
toto.txt :
────────────────────────────────────────────────────────────────────────────────
1 - Ceci est une ligne de texte
2 - Ceci est une ligne de texte
3 -
4 - Le fichier est composé de 4 lignes dont 1 ligne blanche
────────────────────────────────────────────────────────────────────────────────
titi.txt : cannot read file
<> <filename> [filename ...]:
Exercice B4
Ecrire un programme dice qui utilise un générateur
de nombres aléatoires pour simuler un lancer de n
dés à 6 faces, où la valeur de n est entrée par
l'utilisateur.
Exemple d'exécution :
────────────────────────────────────────────────────────────────────────────────
DICE : display a graphical representation for a list of random dice rolls
User input : <number of dice> (must be an integer between 1 and 8)
App output : graphical representation for the provided number of dice rolls
Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter number of dice: 7
┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐
│ │ │ ■ ■ │ │ ■ │ │ ■ ■ │ │ ■ ■ │ │ ■ │ │ ■ ■ │
│ ■ │ │ ■ │ │ │ │ ■ ■ │ │ ■ │ │ ■ │ │ │
│ │ │ ■ ■ │ │ ■ │ │ ■ ■ │ │ ■ ■ │ │ ■ │ │ ■ ■ │
└───────┘ └───────┘ └───────┘ └───────┘ └───────┘ └───────┘ └───────┘
<> Enter number of dice:
Exercice B5
Ecrire un programme fiboplus qui reprend le principe
du programme fibo (cf. exercice A2) mais
propose des options supplémentaires. Ainsi, au lieu de simplement fournir le
nombre de termes de la suite à calculer, l'utilisateur peut spécifier une
commande sous la forme :
n=15 u=1 v=2 file=fibo.txt
où n correspond au nombre de termes à calculer, u à la valeur du premier terme de la suite, v à la valeur du second terme de la suite, et
file au nom du fichier dans lequel stocker le résultat de l'affichage.
Tous ces éléments de la ligne de commande sont optionnels et peuvent être
entrés dans n'importe quel ordre. Si l'un des éléments est omis, le programme
utilisera sa valeur par défaut, en l'occurence : 10 pour n
, 0 pour u, 1 pour v
et "" (chaîne vide) pour file (ce qui signifie que
l'affichage se fait à l'écran et non dans un fichier).
Exemple d'exécution :
────────────────────────────────────────────────────────────────────────────────
FIBOPLUS : generate the Fibonacci sequence with several options
User input : ['n =' n] ['u =' u] ['v =' v] ['file =' filename]
- n:int = number of terms for the sequence (defaut = 10)
- u:int = value of the first term (default = 0)
- v:int = value of the second term (default = 1)
- filename:str = name of output file (default = output on screen)
App ouput : Fibonacci sequence defined by user arguments
Note: to use all default values, simply enter <SPACE> as command
Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter command line: n=5 v=2
fibo(0) = 0
fibo(1) = 2
fibo(2) = 2
fibo(3) = 4
fibo(4) = 6
fibo(5) = 10
<> Enter command line: n=1000 file=fibo.txt
Fibonacci sequence (1000 values) written in file 'fibo.txt'
<> Enter command line:
Exercice B6
Ecrire un programme matstat qui reprend le
fonctionnement du programme stat (cf. exercice A9)
mais cette fois-ci, les données numériques proviennent de matrices qui sont
stockées dans des fichiers au format CSV, dont les noms sont entrés par
l'utilisateur.
Exemple d'exécution :
────────────────────────────────────────────────────────────────────────────────
MATSTAT : perform statistical operations on a matrices stored in CSV files
User input : <filename> [filename ...]
where filename = text file containing a set of integer or float values
App output : The matrix stored in each provided CSV file is displayed with
additional rows showing the result of statistical operations
performed on each column: min, max, mean and deviation
Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter <filename> [filename ...]: mat.txt
────────────────────────────────────────────────────────────────────────────────
Content of 'mat.txt'
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│ 13 │ 10 │ 18 │ 5 │ 13 │ 5 │ 8 │ 11 │ 9 │ 14 │ 7 │ 13 │ 9 │ 4 │ 11 │
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│ 9 │ 10 │ 14 │ 2 │ 9 │ 13 │ 7 │ 8 │ 16 │ 13 │ 10 │ 9 │ 8 │ 7 │ 4 │
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│ 12 │ 1 │ 6 │ 8 │ 4 │ 0 │ 10 │ 20 │ 7 │ 11 │ 13 │ 12 │ 15 │ 8 │ 5 │
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│ 10 │ 14 │ 6 │ 16 │ 11 │ 7 │ 10 │ 3 │ 2 │ 6 │ 15 │ 10 │ 7 │ 4 │ 13 │
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│ 15 │ 7 │ 12 │ 6 │ 17 │ 15 │ 13 │ 4 │ 6 │ 10 │ 9 │ 10 │ 18 │ 12 │ 5 │
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│ 5 │ 13 │ 8 │ 12 │ 14 │ 3 │ 7 │ 7 │ 12 │ 17 │ 12 │ 3 │ 11 │ 17 │ 13 │
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│ 12 │ 13 │ 9 │ 7 │ 9 │ 10 │ 9 │ 6 │ 12 │ 11 │ 11 │ 7 │ 17 │ 7 │ 14 │
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│ 16 │ 8 │ 14 │ 10 │ 19 │ 9 │ 9 │ 14 │ 7 │ 6 │ 7 │ 10 │ 14 │ 8 │ 10 │
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│ 8 │ 9 │ 11 │ 6 │ 11 │ 14 │ 8 │ 11 │ 9 │ 5 │ 9 │ 14 │ 12 │ 7 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
From top to bottom, results for operators min, max, mean, deviation
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│ 5│ 1│ 6│ 2│ 4│ 0│ 7│ 3│ 2│ 5│ 7│ 3│ 7│ 4│ 4│
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│ 16│ 14│ 18│ 16│ 19│ 15│ 13│ 20│ 16│ 17│ 15│ 14│ 18│ 17│ 14│
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│11.1│9.44│10.8│ 8.0│11.8│8.44│ 9.0│9.33│8.88│10.3│10.3│9.77│12.3│8.22│9.55│
├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
│3.28│3.74│3.81│3.91│4.25│4.85│1.76│5.03│3.84│3.82│2.53│3.11│3.71│3.82│3.65│
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
<> Enter <filename> [filename ...]:
Exercice B7
Ecrire un programme scramble dont le rôle est
d'encrypter/décrypter les données contenues dans un fichier texte à l'aide
d'une clé alphanumérique fournie par l'utilisateur. Le choix de l'algorithme
de cryptage est libre, la seule contrainte est qu'il soit symétrique,
c'est-à-dire qu'en recryptant le fichier crypté avec la même clé key, on
retrouve le fichier initial. Une manière simple de réaliser ce cryptage, est
d'appliquer un opérateur "ou exclusif" (noté ^ en Python) entre les codes
Unicode des caractères de la clé et ceux du fichier texte.
Exemple d'exécution :
────────────────────────────────────────────────────────────────────────────────
SCRAMBLE : scramble a list of text files according to a user-provided password
User input : <password> <filename> [filename ...]
where password:str without whitespaces
App output : Message showing whether each file has been scrambled
Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter password and filename(s) : HastaLaVista toto.txt titi.txt
toto.txt : Scrambled
titi.txt : Access error
<> Enter filename :
Exercice B8
Ecrire un programme primefacto qui permet d'afficher
les décompositions en facteurs premiers pour tous les nombres entiers inférieurs
à une valeur n entrée par l'utilisateur. Pour simplifier
l'implémentation, on va commencer par réutiliser le code du programme
A8_prime.py pour pouvoir stocker les nombres premiers
trouvés dans un fichier CSV. Le programme primefacto
n'aura ainsi plus qu'à utiliser ce fichier pour parcourir les nombres premiers et
détecter ceux qui sont des diviseurs du nombre à décomposer.
Exemple d'exécution :
────────────────────────────────────────────────────────────────────────────────
PRIMEFACTO : compute all prime factorizations for numbers from 2 to n
User input : (where n:int > 1)
App output : sequence of all prime factorizations for numbers from 2 to n
────────────────────────────────────────────────────────────────────────────────
<> Enter value for : 25
2 = 2
3 = 3
4 = 2 * 2
5 = 5
6 = 2 * 3
7 = 7
8 = 2 * 2 * 2
9 = 3 * 3
10 = 2 * 5
11 = 11
12 = 2 * 2 * 3
13 = 13
14 = 2 * 7
15 = 3 * 5
16 = 2 * 2 * 2 * 2
17 = 17
18 = 2 * 3 * 3
19 = 19
20 = 2 * 2 * 5
21 = 3 * 7
22 = 2 * 11
23 = 23
24 = 2 * 2 * 2 * 3
<> Enter command:
Exercice B9
Ecrire un programme latin qui permet de générer et
d'afficher un carré latin aléatoire. Un carré latin est une matrice n x n dont chaque ligne et chaque colonne contient les
nombres de 1 à n, répartis
de telle manière à ce que chaque nombre ne figure qu'une fois sur chacune des
lignes et sur chacune des colonnes (cf. exemple d'exécution). Les
caractéristiques du carré latin sont spécifiées par l'utilisateur avec une
commande sous la forme:
n=15 file=latin.txt
où n correspond à la taille du carré généré et
file au nom du fichier dans lequel stocker le
résultat de l'affichage. Comme pour le programme
fiboplus (cf. exercice B5), les éléments de la ligne de commande sont
optionnels et peuvent être entrés dans n'importe quel ordre. Si l'un des
éléments est omis, le programme utilisera sa valeur par défaut, en l'occurrence:
10 pour n et "" (chaîne vide) pour file (ce qui signifie que l'affichage se fait à l'écran et non
dans un fichier).
Exemple d'exécution :
────────────────────────────────────────────────────────────────────────────────
LATIN : generate a random latin square
User input : ['chars =' ] ['n =' ] ['file =' ]
- chars:str = string defining the charset used for matrix cells
- n:int > 0 = when 'n' is defined, argument 'chars' is ignored
and integer numbers from 1 to 'n' are used for matrix cells
- filename:str = name of output file (default = output on screen)
App output: random latin square containing either chars or numbers
Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter command: n=9
┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ 8 │ 5 │ 4 │ 2 │ 9 │ 3 │ 1 │ 6 │ 7 │
├───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 7 │ 4 │ 3 │ 1 │ 8 │ 2 │ 9 │ 5 │ 6 │
├───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 9 │ 6 │ 5 │ 3 │ 1 │ 4 │ 2 │ 7 │ 8 │
├───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 2 │ 8 │ 7 │ 5 │ 3 │ 6 │ 4 │ 9 │ 1 │
├───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 4 │ 1 │ 9 │ 7 │ 5 │ 8 │ 6 │ 2 │ 3 │
├───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 6 │ 3 │ 2 │ 9 │ 7 │ 1 │ 8 │ 4 │ 5 │
├───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 1 │ 7 │ 6 │ 4 │ 2 │ 5 │ 3 │ 8 │ 9 │
├───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 5 │ 2 │ 1 │ 8 │ 6 │ 9 │ 7 │ 3 │ 4 │
├───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 3 │ 9 │ 8 │ 6 │ 4 │ 7 │ 5 │ 1 │ 2 │
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
<> Enter command line: chars='ABCDE'
┌───┬───┬───┬───┬───┐
│ E │ C │ A │ B │ D │
├───┼───┼───┼───┼───┤
│ C │ A │ D │ E │ B │
├───┼───┼───┼───┼───┤
│ A │ D │ B │ C │ E │
├───┼───┼───┼───┼───┤
│ B │ E │ C │ D │ A │
├───┼───┼───┼───┼───┤
│ D │ B │ E │ A │ C │
└───┴───┴───┴───┴───┘
<> Enter command: n=25 file=latin.txt
Latin square written in file "latin.txt"
<> Enter command:
...
Christophe Schlick