M1 MEEF SD maths option info

 

Arbres en Python 

1 Représentation en mémoire
1.1 Avec des objets
On a vu qu’il était possible d’utiliser la programmation orientée objet pour simuler un chaînage.
Vous pouvez reprendre le travail effectué durant le TP sur les objets, et le modifier pour avoir toutes
les fonctions utiles à la manipulation d’un arbre binaire :
— Arbre(x) crée et renvoie un nouvel arbre formé d’un seul nœud dont l’étiquette est x.
— a.val(), a.fg() et a.fd() renvoient respectivement la racine, le fils gauche et le fils droit de a.
— a.modif_val(x) affecte la nouvelle valeur x à la racine de a.
— a.modif_g(b) et a.modif_d(b) remplacent respectivement le fils gauche ou droit de a par b.
(Attention, avec ces dernières fonctions certains sous-arbres peuvent se retrouver partagés entre
plusieurs arbres distincts !)

1.2 Autre représentation : chaînage par indices

Dans tout langage proposant des tableaux, on peut construire des arbres sous forme d’un tableau à
3 colonnes :
indice contenu du nœud indice de son fils gauche indice de son fils droit
0 A 1 2
1 B None None
2 C None None
.. .. .. ..
. . . .

On note que l’indice None représente un fils vide (mais on peut aussi utiliser −1 par exemple).
Il faut de plus mémoriser :
— l’indice de la racine (on pourrait décider que celle-ci est à l’indice 0 mais pour réorganiser l’arbre
ce n’est pas toujours pratique)
— le nombre de nœuds dans l’arbre (là encore pas indispensable, mais pratique pour savoir quelle
ligne est utilisable pour créer un nouveau nœud)

1.3 Premières manipulations

Exercice 1 Écrire des fonctions permettant de traduire un arbre depuis une de ces représentations vers
l’autre.

Exercice 2 Écrire les parcours en profondeur et en largeur pour la représentation de votre choix.

2 Applications
Exercice 3 Utiliser vos arbres binaires pour coder l’algorithme de Huffman :
— On lira les données à compresser dans un fichier (voir plus bas le « kit de survie » pour lire et
écrire dans des fichiers en Python).
— On comptera les occurrences de chaque caractère afin de déterminer un code binaire optimal.
— Et enfin on produira le texte compressé sous forme d’une suite de 0 et de 1 dans un second fichier.
Testez votre programme et observez la taille des fichiers produits : pouvez-vous expliquer ce qui se
passe ?
On pourra enfin s’intéresser au problème du décodage du fichier compressé.

1
3 Annexe : Lecture et écriture dans des fichiers
On présente ici le « kit de survie » pour qui veut lire et écrire dans des fichiers en Python. Une fois
le principe compris, l’utilisation est extrêmement simple : c’est un point fort de Python.

3.1 Lire les lignes d’un fichier

Le principe est le suivant :
1. On ouvre un fichier.
2. On lit les lignes successivement.
3. On ferme le fichier.
En pratique :
— L’ouverture du fichier consiste à associer (via la fonction open) un objet de type _io.TextIOWrapper
à un fichier existant. On peut voir cet objet comme quelque chose qui pointe au début du fichier
et auquel on peut demander de lire des lignes et d’en donner le résultat. Le principe n’est pas
d’aller voir à un endroit arbitraire, contrairement à ce que l’on ferait dans un tableau.
— La lecture des lignes peut se faire soit pas à pas via la méthode readline, qui lit la ligne courante
et passe à la suivante, soit globalement via la méthode readlines, qui crée la liste de toutes les
lignes et permet ainsi de traiter ces dernières dans une boucle. Chaque ligne est en fait une chaîne
de caractères (str).
— On ferme le fichier via la méthode close : il est conseillé d’écrire cette instruction aussitôt après
avoir écrit l’instruction open sous peine de l’oublier très souvent.
Dans l’exemple suivant, on ouvre un fichier dont le nom est tagada.txt, on affiche la première ligne
lue, puis on calcule la somme des longueurs de toutes les lignes suivantes.
mon_fichier = open ( ’ tagada . txt ’ , ’r ’) # ’r ’ pour lecture
print ( mon_fichier . readline ())
s = 0
for L in mon_fichier . readlines ():
s += len ( L )
mon_fichier . close ()
Une façon encore plus simple de parcourir les lignes d’un fichier consiste à écrire :
for L in mon_fichier: ...
Cela ressemble à la méthode readlines, à une subtile amélioration près. La séquence des lignes,
qui peut être grande, n’est pas créée avant d’être parcourue : les lignes sont lues à la volée, dès que la
précédente a été traitée.

3.2 Écrire des données dans un fichier

Pour écrire dans un fichier, on commence par l’ouvrir en écriture (ce qui aura pour effet d’écraser
ledit fichier, s’il existait déjà). Ensuite, on y écrit des chaînes de caractères via la méthode write et on
termine en fermant le fichier. Attention, ici la fermeture est cruciale : c’est à cet instant que le fichier va
réellement être écrit sur le disque.
Dans l’exemple suivant, on ouvre un fichier dans lequel on écrit successivement les éléments d’une
liste (un par ligne).
f = open ( ’ sauvegarde . txt ’ , ’w ’) # ’w ’ pour é criture
for elem in liste : # elem n ’ est pas forc é ment une cha i ne
f . write ( str ( elem )+ ’\ n ’) # il faut donc le convertir
f . close ()