TOC

Comment représenter graphiquement la fréquence des mots en utilisant matplotlib avec Python 3

introduction

Les données textuelles existent sous de nombreuses formes différentes, du journalisme aux médias sociaux en passant par les courriels. Lorsque nous analysons et visualisons des données textuelles, nous pouvons mettre en évidence des tendances générales susceptibles de modifier notre interprétation du texte.

Dans ce tutoriel, nous allons explorer la fréquence des mots dans un corpus de texte. Le programme que nous allons créer recherchera dans un document en texte brut et organisera chaque mot unique avec sa fréquence. Nous allons ensuite représenter graphiquement les données trouvées en utilisant + matplotlib +.

Conditions préalables

Pour pouvoir utiliser ce didacticiel, assurez-vous que les conditions préalables suivantes sont remplies:

Enfin, assurez-vous de suivre https://www.digitalocean.com/community/tutorials/how-to-plot-data-in-python-3-using-matplotlib#step-1-%E2%80%94-importing -matplotlib [Etape 1 - importer + matplotlib +] de notre Comment tracer des données en Python 3 Utilisation de matplotlib car il est essentiel que + matplotlib + soit installé pour ce projet.

Étape 1 - Configuration du fichier de programme

Maintenant que + matplotlib est installé sur votre ordinateur, nous pouvons commencer à créer notre projet.

En utilisant un éditeur de texte de votre choix, créez un nouveau fichier Python et appelez-le + word_freq.py +. Ce sera notre fichier principal.

Dans ce programme, nous allons import + matplotlib + et le https: //www.digitalocean. com / communauté / tutoriels / comment-construire-classes-et-définir-objets-en-python-3 [classe] dont nous avons besoin (qui est + pyplot +), en lui passant le + plt + https: / /www.digitalocean.com/community/tutorials/how-to-import-modules-in-python-3#aliasing-modules[alias]. Ceci déclare essentiellement + plt + en tant que variable globale qui sera utilisée tout au long de notre script.

word_freq.py

import matplotlib.pyplot as plt

Nous allons ensuite importer des packages par défaut en Python. Celles-ci seront utilisées pour configurer et prendre des entrées en ligne de commande. Le paquet important à noter est + argparse +. C’est ce que nous allons utiliser pour récupérer des informations à partir de la ligne de commande et inclure du texte d’aide pour l’utilisateur.

Importons les packages par défaut suivants en Python:

word_freq.py

import matplotlib.pyplot as plt

Enfin, créez la méthode principale standard et appelez. Dans la méthode principale, nous allons écrire la plupart de notre code.

word_freq.py

import matplotlib.pyplot as plt
import sys
import operator
import argparse

Maintenant que nous avons tout importé et configuré le squelette de notre projet, nous pouvons maintenant utiliser les packages que nous avons importés.

Étape 2 - Configuration de l’analyseur d’arguments

Pour cette partie, nous allons créer les arguments de ligne de commande et les stocker dans une variable pour une lecture rapide. accès.

Dans notre méthode principale, créons notre variable d’analyseur et affectons-la au constructeur par défaut + argparse + fournit. Nous assignerons ensuite l’argument attendu pour le mot que nous rechercherons dans le fichier. Enfin, nous assignerons l’argument attendu du fichier dans lequel le mot est contenu. Ce sera un fichier + .txt +.

word_freq.py

...
def main():










if __name__ == "__main__":
 main()

Pour le moment, le premier argument de la méthode est le titre de ce que nous attendons de la ligne de commande. Le deuxième argument + help =" …​ "+ est utilisé pour fournir à l’utilisateur des informations sur le contenu de l’argument de ligne de commande.

Ensuite, nous allons sauvegarder les arguments donnés dans une autre variable que nous appellerons + args +.

word_freq.py

...
def main():
 parser = argparse.ArgumentParser()
 parser.add_argument(
     "word",
     help="the word to be searched for in the text file."
 )
 parser.add_argument(
     "filename",
     help="the path to the text file to be searched through"
 )



if __name__ == "__main__":
 main()

Pour faire bonne mesure, nous devrions toujours vérifier vos entrées au cas où il y aurait une faute de frappe dans les arguments de ligne de commande. C’est également pour empêcher notre script de planter brusquement. Laissons donc les erreurs en utilisant une instruction + try +.

word_freq.py

...
def main():
   ...
   args = parser.parser_args()








if __name__ == "__main__":
 main()

Nous utilisons + sys.exit (1) + pour indiquer à l’utilisateur qu’il y a eu un problème avec le code et que celui-ci n’a pas pu aboutir.

Notre projet pourra désormais prendre en compte des arguments en ligne de commande. L’étape suivante consiste à analyser notre fichier d’entrée.

Étape 3 - Analyser le fichier

Dans cette étape, nous allons créer un fichier, lire chaque mot, enregistrer la fréquence d’affichage et enregistrer le tout dans un type de données de dictionnaire.

Créons une fonction] appelée https://www.digitalocean.com/community/tutorials/how-to-define-functions-in-python-3 mot et le nom du fichier), puis appelez cette fonction dans + main () +.

word_freq.py

...
def main():
   ...




if __name__ == "__main__":
 main()

La première étape de l’analyse du fichier consiste à créer un type de données de dictionnaire que nous appellerons + doc +. Cela contiendra chaque mot trouvé dans le fichier et gardera une trace de combien de fois il est apparu.

word_freq.py

...
def word_freq( word, filename ):


if __name__ == "__main__":
 main()

La prochaine étape serait de parcourir le fichier donné. Ceci est fait en utilisant une boucle nested + pour +.

La première boucle + pour + est conçue pour ouvrir le fichier et en extraire la première ligne. Ensuite, il prend ce qui est dans chaque ligne et le divise sur la base d’une chaîne de caractère d’espacement, entre les mots, tout en stockant les mots dans un tableau.

La seconde boucle + pour + prend ce tableau et le parcourt en vérifiant s’il s’agit ou non du dictionnaire. Si c’est le cas, nous y ajoutons un compte. Si ce n’est pas le cas, nous créons une nouvelle entrée et l’initialisons à 1.

word_freq.py

...
def word_freq(word, filename):
   doc = {}









if __name__ == "__main__":
 main()

Nous en sommes maintenant à la moitié du projet.

Pour récapituler, + notre méthode main () + devrait configurer nos entrées en ligne de commande et les transmettre à la fonction + word_freq () +. + word_freq () + devrait extraire le mot et le nom de fichier de la ligne de commande et sauvegarder chaque mot unique trouvé dans le fichier texte.

Ensuite, nous allons prendre ces données et les organiser pour les utiliser dans notre graphique.

Étape 4 - Stockage et tri des données

Avant de faire le graphique, nous devons nous assurer que le mot est réellement dans le fichier que nous avons ouvert. Nous pouvons le faire avec une déclaration + if + https://www.digitalocean.com/community/tutorials/how-to-write-conditional-statements-in-python-3-2.

word_freq.py

...
def word_freq(word, filename):
   ...
     else:
         doc[entry] = 1




if __name__ == "__main__":
 main()

Maintenant que nous savons que le mot est dans le fichier, nous pouvons commencer à configurer les données pour notre graphique.

Nous devons d’abord commencer par trier notre type de données de dictionnaire du plus élevé au moins en occurrence et par l’initialisation des variables pour une utilisation ultérieure. Nous devons trier notre dictionnaire afin qu’il soit correctement visualisé sur le graphique.

word_freq.py

...
def word_freq(word, filename):
   ...
   if (not word in doc):
       sys.stderr.write("Error: " + word + " does not appear in " + filename)
       sys.exit(1)







if __name__ == "__main__":
 main()

Les deux variables à noter sont + just_the_occur + qui sont les données qui contiendront combien de fois un mot est apparu. L’autre variable est + just_the_rank + qui est la variable qui contiendra les données relatives au rang du mot.

Maintenant que nous avons le dictionnaire trié, nous allons le parcourir pour trouver notre mot et son rang, ainsi que pour renseigner notre graphique avec ces données.

word_freq.py

...
def word_freq( word, filename ):
   ...

 sortedDoc = (sorted(doc.items(), key = operator.itemgetter(1)))[::-1]
 just_the_occur = []
 just_the_rank = []
 word_rank = 0
 word_frequency = 0











if __name__ == "__main__":
 main()

Ici, nous devons nous assurer que les deux variables + just_the_occur + et + just_the_rank + ont la même longueur, sinon + matplotlib + ne nous laissera pas créer le graphe.

Nous avons également ajouté une instruction + if + dans la boucle pour trouver notre mot (dont nous savons déjà qu’il existe) et en extraire le rang et la fréquence.

Nous avons maintenant tout ce dont nous avons besoin pour créer votre graphique. Notre prochaine étape est de le créer enfin.

Étape 5 - Création du graphique

À ce stade, nous pouvons brancher la variable + plt + que nous avons créée au début. Pour créer notre graphique, nous avons besoin d’un titre, d’une étiquette d’axe des y, d’une étiquette d’axe des x, d’une échelle et d’un type de graphique.

Dans notre cas, nous allons créer un graphique de base de journal 10 pour organiser nos données. Les étiquettes de titre et d’axe peuvent correspondre à tout ce que vous voulez, mais plus elles sont descriptives, mieux ce sera pour les personnes qui consultent votre graphique.

word_freq.py

...
def word_freq( word, filename ):
   ...
 just_the_rank.append(entry_num)
 entry_num += 1
 just_the_occur.append(entry[1])



















if __name__ == "__main__":
 main()

Les fonctions title, + plt.ylabel () +, et + plt.xlabel () + sont des étiquettes pour chaque axe.

La fonction + plt.loglog () + prend + just_the_rank + et + just_the_occur + pour les axes x et y respectivement.

Nous changeons la base de journal et la fixons à 10.

Ensuite, nous configurons l’intrigue de manière à disperser et à souligner notre point. Nous en avons fait une étoile orange de taille 100, donc c’est prononcé. Enfin, nous l’avons étiqueté avec notre mot.

Une fois que tout est terminé pour notre graphique, nous disons qu’il soit affiché avec + plt.show () +.

Maintenant que notre code est enfin terminé, nous pouvons le tester.

Étape 6 - Exécution du programme

Pour lire notre exemple de texte, nous aurons besoin d’un fichier texte, nous allons donc en télécharger un de Project Gutenberg, un projet bénévole qui fournit des livres numériques gratuits (principalement du domaine public) aux lecteurs.

Sauvegardons le texte du roman _http: //www.gutenberg.org/ebooks/98 [Un conte de deux villes] _ de Charles Dickens dans un fichier nommé + villes.txt + avec + curl + dans notre répertoire courant qui contient notre script Python:

curl http://www.gutenberg.org/files/98/98-0.txt --output cities.txt

Exécutons ensuite notre code en passant les paramètres du mot de notre choix (nous utiliserons «poisson») et le nom du fichier texte:

python word_freq.py fish cities.txt

Si tout fonctionne correctement, vous devriez voir ceci:

image: https: //assets.digitalocean.com/articles/eng_python/WordFrequency/word-frequency-matplotlib.png [diagramme de dispersion de fréquence de mots dans matplotlib]

Nous voyons le classement du mot «poisson» est 5309 et une visualisation des occurrences.

Maintenant, vous pouvez continuer à expérimenter différents mots et différents fichiers texte. Pour en savoir plus sur l’utilisation de fichiers texte, consultez notre Comment traiter les fichiers de texte brut en Python 3 tutoriel.

Code terminé et améliorations du code

À ce stade, vous devriez avoir un programme pleinement fonctionnel qui déterminera la fréquence des mots d’un mot donné dans un fichier + .txt +.

Vous trouverez ci-dessous notre code complet pour ce projet.

word_freq.py

import matplotlib.pyplot as plt
import sys
import operator
import argparse


def main():
   parser = argparse.ArgumentParser()
   parser.add_argument(
       "word",
       help="the word to be searched for in the text file."
   )
   parser.add_argument(
       "filename",
       help="the path to the text file to be searched through"
   )

   args = parser.parse_args()

   try:
       open(args.filename)
   except FileNotFoundError:

       # Custom error print
       sys.stderr.write("Error: " + args.filename + " does not exist!")
       sys.exit(1)

   word_freq(args.word, args.filename)


def word_freq(word, filename):
   doc = {}

   for line in open(filename):

       # Assume each word is separated by a space
       split = line.split(' ')
       for entry in split:
           if (doc.__contains__(entry)):
               doc[entry] = int(doc.get(entry)) + 1
           else:
               doc[entry] = 1

   if (word not in doc):
       sys.stderr.write("Error: " + word + " does not appear in " + filename)
       sys.exit(1)

   sorted_doc = (sorted(doc.items(), key=operator.itemgetter(1)))[::-1]
   just_the_occur = []
   just_the_rank = []
   word_rank = 0
   word_frequency = 0

   entry_num = 1
   for entry in sorted_doc:

       if (entry[0] == word):
           word_rank = entry_num
           word_frequency = entry[1]

       just_the_rank.append(entry_num)
       entry_num += 1
       just_the_occur.append(entry[1])

   plt.title("Word Frequencies in " + filename)
   plt.ylabel("Total Number of Occurrences")
   plt.xlabel("Rank of word(\"" + word + "\" is rank " + str(word_rank) + ")")
   plt.loglog(just_the_rank, just_the_occur, basex=10)
   plt.scatter(
       [word_rank],
       [word_frequency],
       color="orange",
       marker="*",
       s=100,
       label=word
   )
   plt.show()

if __name__ == "__main__":
   main()

Maintenant que tout est terminé, nous pouvons apporter des améliorations et des modifications à ce code.

Si nous voulions comparer la fréquence de deux mots, nous ajouterions une position de mot supplémentaire dans nos arguments de ligne de commande. Pour ce faire, il faudrait ajouter un autre vérificateur pour le mot et davantage de variables pour les mots.

Nous pouvons également modifier le programme afin qu’il compare la longueur de chaque mot à un autre. Pour ce faire, nous comparerions les mots par longueur et enregistrerions chaque longueur unique dans le dictionnaire.

Conclusion

Nous venons de créer un programme pour lire un fichier texte et organiser les données pour voir la fréquence d’un mot spécifique par rapport aux autres dans un texte.

Si vous êtes intéressé par la visualisation de données, vous pouvez également consulter notre https://www.digitalocean.com/community/tutorials/how-to-make-a-bar-chart-with-javascript-and-the-d3- tutoriel de bibliothèque [Comment faire un graphique à barres avec JavaScript et la bibliothèque D3].

Related