il existe une barre de recherche ou l'on peut explorer les différents fichiers:
- fichiers contenant la chaîne de caractères "LE MOOC RECHERCHE REPRODUCTIBLE C'EST GENIAL":
- module1/exo1/aebef6b0a5.txt
- module1/exo1/f683bbad4b.txt
## historique gitlab
pour accéder à l'historique des commits il exite un bouton History qui permet de remonter au différents ajouts qu'il peut exister sur un fichier git
- le numéro du commit:
- 505c4e26
...
...
@@ -21,8 +26,15 @@ pour accéder à l'historique des commits il exite un bouton History qui permet
# exercice 02
## reproduction du PDF
le resultat du premiers exo est ici ou on utitlise le fait que jupyter fonctionne avec des cellules permet de passer facilement de code type python à du code type latex [pdf](https://lms.fun-mooc.fr/asset-v1:inria+41016+self-paced+type@asset+block/toy_notebook_fr.pdf)
## valeurs pour l'exo 2
- moyenne:
- 14.11
...
...
@@ -56,7 +68,7 @@ np.std(tab, ddof=1)
4.334094455301447
```
on extrait les données en python via la librairie pandas
reamrque: on extrait les données en python via la librairie pandas
## réponses exo 3-2
Quelle est l'année avec l'épidémie la plus forte ?
...
...
@@ -70,3 +82,414 @@ Quelle est l'année avec l'épidémie la plus faible ?
# Etude de l'Avare de Molière
Ouvre l'URL et lit le contenu en tant que fichier texte
`with urllib.request.urlopen(url) as response:`
# Lit les données depuis l'URL
Parcourt chaque partie du texte
``for partie in parties_texte:
lignes = partie.strip().splitlines() # Divise la partie en lignes
compteur_occurrences = 0 # Compteur d'occurrences pour cette partie``
et c'est la même chose pour les lignes
Pour récupérer le contenu d'un fichier texte via une URL on peut utiliser la fonction suivante:
``def get_text_from_url(url):
response = requests.get(url)
if response.status_code == 200:
return response.text
else:
return None ``
# dernière mission: évaluation par les pairs
On cherche dans ce code à traiter le nombre d'intervention de chaque personnage de l'Avare de Molière.
On va essayer de rendre cela plus facilement lisible avec des diagrammes et des graphiques.
J'ai decidé d'expliquer mon cheminement en décrivant cellule par cellule les actions que j'opère sur les données extraitent du texte.
## Première cellule:
Dans cette cellule on commence comme dans tous les code en python par importer les bibliothèques python que l'on va utiliser pour notre code ( les bibliothèque sont des ensembles de codes déja implémenté en python qui possèdent des applications spécifiques au problème que l'on veut résoudre).
Les importaions sont caractérisées par le terme 'import' ainsi on importe:
- numpy pour manipuler des matrices/tableaux multidimensionnels ainsi que des fonctions mathématiques opérant sur ces tableaux
- pandas permettant la manipulation et l'analyse des données
- matplotlib.pyplot qui sert à tracer et à visualiser les données sous forme de graphique
- requests permet de manipuler des fichier de type HTTP
- urllib.request possède des fonctions addaptées pour ouvrir des URLs
- io permet à python de traiter plus facilement les données de type I/O, le texte sont des données de ce type.
Ensuite on attribu à l'url que l'on traite le nom plus simple url
Puis on lit en fichier txt, et on utilise io pour extraire les données du texte que l'on nomme donc texte.
Dans un premiers temps on definit tous les Noms que l'on va aller chercher dans le texte, à savoir les noms des différents personnages de la pièce. Notre objectif est de compter alors le nombres de fois ou l'on retrouve chacun de ces noms dans le texte et ainsi on pourra remonter aux nombres d'élocutions de chaque personnage.
``
mot_a_chercher = "HARPAGON."
#mot_a_chercher = "VALÈRE."
#mot_a_chercher = "ÉLISE."
#mot_a_chercher = "CLÉANTE."
#mot_a_chercher = "LA FLÈCHE."
#mot_a_chercher = "MARIANE."
#mot_a_chercher = "ANSELME."
#mot_a_chercher = "FROSINE."
#mot_a_chercher = "MAÎTRE SIMON."
#mot_a_chercher = "MAÎTRE JACQUES."
#mot_a_chercher = "BRINDAVOINE."
#mot_a_chercher = "LA MERLUCHE."
#mot_a_chercher = "LE COMMISSAIRE."
``
``
#Compteur pour stocker le nombre d'occurrences du mot
compteurs_occurrences = []
``
On créer un compteur qui va nous permettre de stocker les différents nombres d'occurences.
``
#Ouvre l'URL et lit le contenu en tant que fichier texte
with urllib.request.urlopen(url) as response:
#Lit les données depuis l'URL et divise le texte en parties par les lignes commençant par '###'
#Pour afficher le nombre d'occurrences du mot dans chaque partie du texte:
#for i, occurrences in enumerate(compteurs_occurrences, start=1):
#print(f"Le mot '{mot_a_chercher}' apparaît {occurrences} fois dans la partie {i} du texte.")
``
On subdivise ensuite les parties pour obtenir des lignes distinctes, on initialise le nombre d'occurences à 0.
Une boucle nous permet d'ajouter une unité aux nombre d'occurence si il compte 1 fois le mot que l'on cherche dans la ligne.
On scanne ainsi le texte pour compter le nombres d'occurences, ensuites on ajoutes cela dans le tableau vide que l'on à initier précédement à l'aide de la fonction append.
## Troisième cellule
Une fois les différents comptes fait pour le nombre d'occurences de chaque personnage dans les différentes parties on créer des tableaux traduisant les résultats.
C'est un peu long mais on a pas trouver d'autres moyens (ça peut être optimisé...)
``
personnages=["HARPAGON", "VALÈRE", "ÉLISE", "CLÉANTE", "LA FLÈCHE", "MARIANE", "ANSELME", "FROSINE", "MAÎTRE SIMON", "MAÎTRE JACQUES", "BRINDAVOINE", "LA MERLUCHE", "LE COMMISSAIRE"]
partie1=[0,8,8,0,0,0,0,0,0,0,0,0,0]
partie2=[0,0,9,10,0,0,0,0,0,0,0,0,0]
partie3=[34,0,0,0,32,0,0,0,0,0,0,0,0]
partie4=[53,0,23,29,0,0,0,0,0,0,0,0,0]
partie5=[20,22,4,0,0,0,0,0,0,0,0,0,0]
partie6=[0,0,0,21,20,0,0,0,0,0,0,0,0]
partie7=[9,0,0,6,1,0,0,0,5,0,0,0,0]
partie8=[1,0,0,0,0,0,0,1,0,0,0,0,0]
partie9=[0,0,0,0,6,0,0,5,0,0,0,0,0]
partie10=[35,0,0,0,0,0,0,35,0,0,0,0,0]
partie11=[34,11,1,3,0,0,0,0,0,27,1,2,0]
partie12=[0,11,0,0,0,0,0,0,0,11,0,0,0]
partie13=[0,0,0,0,0,0,0,2,0,1,0,0,0]
partie14=[0,0,0,0,0,0,0,5,0,0,0,0,0]
partie15=[2,0,0,0,0,0,0,1,0,0,0,0,0]
partie16=[6,0,1,0,0,1,0,1,0,0,0,0,0]
partie17=[9,0,0,20,0,10,0,5,0,0,0,0,0]
partie18=[2,0,0,0,0,0,0,0,0,0,2,0,0]
partie19=[6,2,0,2,0,0,0,0,0,0,0,3,0]
partie20=[0,0,2,10,0,6,0,6,0,0,0,0,0]
partie21=[3,0,1,1,0,0,0,0,0,0,0,0,0]
partie22=[23,0,0,22,0,0,0,0,0,0,0,0,0]
partie23=[8,0,0,8,0,0,0,0,0,17,0,0,0]
partie24=[18,0,0,19,0,0,0,0,0,0,0,0,0]
partie25=[0,0,0,5,5,0,0,0,0,0,0,0,0]
partie26=[1,0,0,0,0,0,0,0,0,0,0,0,0]
partie27=[6,0,0,0,0,0,0,0,0,0,0,0,7]
partie28=[19,0,0,0,0,0,0,0,0,22,0,0,8]
partie29=[30,30,0,0,0,0,0,0,0,0,0,0,0]
partie30=[4,1,1,0,0,0,0,1,0,0,0,0,0]
partie31=[11,14,0,0,0,3,14,0,0,0,0,0,0]
partie32=[10,0,0,4,0,1,6,0,0,0,0,0,2]
``
## Quatrième cellule
Maintenant que l'on a des tableaux pour chaque scene on peut plus facilement visualiser les données, et notamment la part de parole de chaque personnages dans les différentes parties. On va donc utiliser la bibliothèque matplotlib.pyplot pour mettre en valeur nos résultat et les rendre plus visuelle.
Pour savoir comment marche la fonction qui trace les camenberts aller voir: [fonction.pie](https://www.python-simple.com/python-matplotlib/pie.php)
'plt.subplots' permet de tracer plusieurs graphiques sur une seule figure, ensuite on ajuste les positions de ces graphiques à l'aide 'plt.gcf().subplots_adjust'
``
%matplotlib notebook
fig, axs = plt.subplots(2, 4, figsize=(20,8))
plt.gcf().subplots_adjust(left = 0.2, bottom = 0.2, right = 0.9, top = 0.9, wspace = 1.1, hspace = 0)
``
Pour tracer les camenberts relatifs à toutes les parties du texte on utilise des boucle pour ce faciliter la tache, et on décide de regrouper ces camenbert par 8 (les 8 lignes en dessous de la boucles) dans une figure et donc d'avoir au total 4 (les 4 boucles) figures (car on a 32 parties), dans la boucle on associe un graphique camenbert à chacune des parties.
Sur ces camenberts j'ai choisit d'afficher le pourcentages de paroles de chaque l'occuteur de la scène, cela ce fait avec les paramètre de la fonction .pie; labels=personnages donne les noms et autopct = lambda x: str(round(x, 2)) + '%' donne le pourcentage de parole.
``
for i in range(2):
for j in range(4):
axs[i, j].set_title(f'Scène {i * 4 + j + 1}')
axs[0, 0].pie(partie1, labels=personnages,
autopct = lambda x: str(round(x, 2)) + '%')
axs[0, 1].pie(partie2, labels=personnages,
autopct = lambda x: str(round(x, 2)) + '%')
axs[0, 2].pie(partie3, labels=personnages,
autopct = lambda x: str(round(x, 2)) + '%')
axs[0, 3].pie(partie4, labels=personnages,
autopct = lambda x: str(round(x, 2)) + '%')
axs[1, 0].pie(partie5, labels=personnages,
autopct = lambda x: str(round(x, 2)) + '%')
axs[1, 1].pie(partie6, labels=personnages,
autopct = lambda x: str(round(x, 2)) + '%')
axs[1, 2].pie(partie7, labels=personnages,
autopct = lambda x: str(round(x, 2)) + '%')
axs[1, 3].pie(partie8, labels=personnages,
autopct = lambda x: str(round(x, 2)) + '%')
fig, axs2 = plt.subplots(2, 4, figsize=(20,8))
plt.gcf().subplots_adjust(left = 0.2, bottom = 0.2, right = 0.9, top = 0.9, wspace = 1.1, hspace = 0)
On affiche sur la console nos figure en utilisant plt.show().
## Cinquième Cellule
On veut maintenant afficher les résultat brut du nombre d'ocurrence par personnage pour cela on va céer une fonction qui recherche le nombre de fois ou apparait seul le nom d'un personnage dans le texte.
La technique suivante n'est pas optimiser mais fonctionne, pour sélectionner le nombre de prise de parole d'un personnage en particulier on décommente (on enlève # devant le nom du perso) la ligne qui lui est associé. Dans l'exemple ci-dessous on va afficher les prises de parole de Valère.
``
#mot_a_chercher = "HARPAGON."
mot_a_chercher = "VALÈRE."
#mot_a_chercher = "ÉLISE."
#mot_a_chercher = "CLÉANTE."
#mot_a_chercher = "LA FLÈCHE."
#mot_a_chercher = "MARIANE."
#mot_a_chercher = "ANSELME."
#mot_a_chercher = "FROSINE."
#mot_a_chercher = "MAÎTRE SIMON."
#mot_a_chercher = "MAÎTRE JACQUES."
#mot_a_chercher = "BRINDAVOINE."
#mot_a_chercher = "LA MERLUCHE."
#mot_a_chercher = "LE COMMISSAIRE."
``
On définit une fonction qui récupère le texte via l'url définit précédement et qui nous affiche si le texte a bien été récupéré en remplissant une variable 'response.text'.
``
#Fonction pour récupérer le contenu du fichier texte à partir d'une URL
def get_text_from_url(url):
response = requests.get(url)
if response.status_code == 200:
return response.text
else:
return None
``
Ensuite on récupere les données du texte par cette ligne.
``
#Récupère le contenu du fichier texte à partir de l'URL
text_content = get_text_from_url(url)
``
Enfin on defini la fonction qui va nous afficher le nombres de prise de parole, on définit les ligne en utiliasnt .lower().splitlines() qui découpe le texte en ligne, puis on fais la somme de chaque occurences trouvée avec la fonction sum() (qui fait la somme des itérables), puis on affiche enfin le résultat par par la commande print() qui affiche sur la console ce qu'on lui demande. Dans notre cas ce sera "Le nom Valère apparait seul X fois dans l'oeuvre"
``
#Vérifie combien de fois le mot apparaît seul sur une ligne dans le texte (en ignorant la casse)
if text_content:
lignes = text_content.lower().splitlines()
occurrences = sum(1 for ligne in lignes if ligne.strip() == mot_a_chercher.lower())
print(f"Le nom '{mot_a_chercher}' apparaît seul {occurrences} fois dans l'oeuvre.")
else:
print("Impossible de récupérer le contenu du fichier texte depuis l'URL.")
``
## Sixiéme cellule
Dans cette dernière cellule on exploite les résultats trouvés dans la section du dessus premièrement j'affiche les résultats pour l'ensemble des personnages, puis je les intègre dans un tableau que je nomme données.
Je crée aussi un tableau avec les différents noms (attention les données doivent avoir la même position relative dans le tableau que le nom associé sinon le tracé sera faux), enfaite je créer ces tableaux afin de pouvoir tracer un courbes qui prend en abscisse les noms et en ordonnée le nombre d'ocuurences associées.
Pour afficher cela j'utilise ensuite matplotlib.pyplot:
-plt.figure(figsize=(10,10)): créer une nouvelle figure ici avec des domension en x et y egales
-plt.title(): donne le titre de la figure
-plt.xlabel_plt.ylabel: donne le nom des axes
-plt.xticks(): étiquette de graduation
-plt.plot(): trace les données avec le premier argument en x et le deuxième en y
