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 :

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" :

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

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

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