====== 1. But du TP ======

Nous allons manipuler une collection de documents avec le langage python et illustrer empiriquement la loi de Zipf. On va en particulier voir que les mots les plus courants sont des "mots outils".

===== Infos techniques =====
 
Le langage python est un langage interprété fortement typé. Il prend en charge les expressions régulières avec le module re (regular expression).
Vous pouvez trouver une référence à python en https://docs.python.org/2.7/. **Tous les exemples dans la suite sont en python 2.7, mais rien ne vous empêche de passer à des versions ultérieures. Dans ce cas les appels à la fonction <code>print</code> sont différents (ligne 37 par exemple...) : à vous de les adapter.**

* Les structures de contrôles sont les mêmes qu'en langage C avec syntaxe un peu différente.

* Le mot-clef def FonctionTest permet de définir des fonctions en python.

 => Appel: FonctionTest

* Pour ouvrir un fichier f = open("Chemin/Nom de fichier");

*Pour découper les chaines de caractères en mots, on utilisera la librairie d'extraction d'expressions régulières, par 

<code>import re</code> 

Une documentation de cette librairie est en [[https://docs.python.org/2/library/re.html|https://docs.python.org/2/library/re.html]]
Ensuite, on utilise la fonction re.compile() qui crée un objet pour une expression régulière. On appelle ensuite la fonction findall pour appliquer la découpage.

Utiisation d'une expression régulière (*en python 2.7*) qui découpe lettre par lettre une chaine de caractères trasnformée en minuscules (par la fonction lower()), en ne gardant que les lettres minuscules et les chiffres :

<code>strinput="A computer design in 2021 is described, which permits..."
objRegex=re.compile("([a-z0-9])")
splitorig=objRegex.findall(strinput.lower())
splitfinal=filter(None,splitorig)
</code>

Si on exécute ensuite la commande :
<code>
print splitfinal
</code>

Le résultat affiché est :
['a', 'c', 'o', 'm', 'p', 'u', 't', 'e', 'r', 'd', 'e', 's', 'i', 'g', 'n', 'i', 'n', '2', '0', '2', '1', 'i', 's', 'd', 'e', 's', 'c', 'r', 'i', 'b', 'e', 'd', 'w', 'h', 'i', 'c', 'h', 'p', 'e', 'r', 'm', 'i', 't', 's']

** Dans notre cas on devra découper en mots et pas en lettres, et on doit garder le passage en minuscule. **

**Note : si vous utilisez une version de python supérieure à 3.0, l'appel à filter est à enlever.**



* Il ne faut pas oublier que python est très sensible aux tabulations, car il n'utilise pas de séparateurs comme les parenthèses du language C.

* Une structure de donnée très utile en python est le dictionnaire python, elle va nous servir dans le TP : vous pouvez vous servir du dictionnaire "frequency" déjà déclaré dans le code en ligne 18). Un dictionnaire python est un tableau dont les indices ne sont pas des entiers mais des chaînes de caractères.
<code>dico={}
dico["toto"]=12
print dico["toto"]
</code>
affiche 12, car 12 est la valeur stockée pour l'identifiant "toto". Une telle structure peut nous permettre de stocker le nombre d'occurrences d'un mot.

* Pour savoir si un mot "word" est dans dictionnaire dico on écrit :
<code>if word in dico:
# le mot est dedans
else:
#  le mot n'est pas dedans
</code>

* Il est possible de passer en revue les éléments d'un dictionnaire en le triant par ses valeurs en utilisant :
<code>from operator import itemgetter  
...
for elem in reversed(sorted(dico.items(), key = itemgetter(1))):
    ...
</code>
Dans ce cas, elem contient le couple ("mot", nb. occurrences).

Pour sortir d'un for avant la fin de toutes les boucles, il est possible d'utiliser l'instruction :
<code>break;</code>

====== 2. Déroulement du TP ======

1. Rapatrier l'ensemble des documents traités, en {{ :cacm-miashs.zip |}}, et dézipper ce fichier

2. Rapatrier le code qui va nous servir de base à ce TP, en {{ :zipf_miashs_2021.py |}}

3. Affecter dans la ligne 15 à la variable inppathname le nom du répertoire qui contient les documents rapatriés :
<code>/.../cacm-miashs/</code>
Puis lancer la commande 
<code>python2.7 zipf_miashs_2021.py</code> pour vérifier que le code s'exécute (il ne fait que des traces).

4. Modifier la fonction splitInWords (ligne 19), de manière à ce qu'elle retrouve les mots de plus de 2 caractères qui commencent par une lettre. Vous pouvez tester tout d'abord sur l'exemple fournit plus haut, dans ce cas votre liste de mot ne doit pas contenir le "a" et le "2021".

5. Dans la fonction Zipf (ligne 28), ajouter le code qui gère le dictionnaire python qui stocke le vocabulaire : si un mot est nouveau alors on l'ajoute avec une occurrence de 1, sinon on ajoute 1 au nombre d'occurrences actuel.

6. Dans la fonction PrintInfoGen (ligne 46), afficher  : le nombre de mots du vocabulaire (c'est la taille du dictionnaire frequency), les 10 mots les plus fréquents (dans l'ordre de fréquence décroissant).

7. Afficher dans le programme principal (ligne 62) le nombre total de mots lus dans le corpus. Cela doit vous obliger à avoir un compteur de tous les mots lus.