TOC

So zeichnen Sie die Häufigkeit von Wörtern mit matplotlib in Python 3 auf

Einführung

Textdaten gibt es in vielen verschiedenen Formen, vom Journalismus über soziale Medien bis hin zu E-Mails. Wenn wir Textdaten analysieren und visualisieren, können wir allgemeine Trends aufdecken, die die Art und Weise ändern, wie wir den Text interpretieren.

In diesem Tutorial untersuchen wir die Häufigkeit der grafischen Darstellung von Wörtern in einem Textkorpus. Das Programm, das wir erstellen, durchsucht ein einfaches Textdokument und ordnet jedes einzelne Wort in seiner Häufigkeit. Wir werden dann die gefundenen Daten mit + matplotlib + grafisch darstellen.

Voraussetzungen

Um dieses Lernprogramm verwenden zu können, müssen Sie die folgenden Voraussetzungen erfüllen:

Stellen Sie abschließend sicher, dass Sie https://www.digitalocean.com/community/tutorials/how-to-plot-data-in-python-3-using-matplotlib#step-1-%E2%80%94-importing folgen -matplotlib [Schritt 1 - Importieren von + matplotlib +] von https://www.digitalocean.com/community/tutorials/how-to-plot-data-in-python-3- using-matplotlib[How to Plot Data in Python 3 Verwenden von matplotlib], da für dieses Projekt "+ matplotlib +" unbedingt installiert sein muss.

Schritt 1 - Einrichten der Programmdatei

Jetzt, da wir + matplotlib auf Ihrem Computer installiert haben, können wir anfangen, unser Projekt zu erstellen.

Erstellen Sie mit einem Texteditor Ihrer Wahl eine neue Python-Datei und nennen Sie sie + word_freq.py +. Dies wird unsere Hauptdatei sein.

In diesem Programm werden wir import + matplotlib + und die https://www.digitalocean. de / community / tutorials / konstruieren-von-klassen-und-definier-objekten-in-python-3 [klasse], die wir brauchen (das ist + pyplot +) und übergeben die + plt + https: / /www.digitalocean.com/community/tutorials/how-to-import-modules-in-python-3#aliasing-modules[alias]. Dies deklariert im Wesentlichen "+ plt +" als globale Variable, die in unserem Skript verwendet wird.

word_freq.py

import matplotlib.pyplot as plt

Als Nächstes importieren wir einige Standardpakete in Python. Diese werden verwendet, um Befehlszeilen-Eingaben einzurichten und aufzunehmen. Das wichtige Paket, das zu beachten ist, ist "+ argparse +". Dies wird verwendet, um Informationen von der Befehlszeile abzurufen und Hilfetexte für den Benutzer einzuschließen.

Importieren Sie die folgenden Standardpakete in Python:

word_freq.py

import matplotlib.pyplot as plt

Zuletzt erstellen Sie die Standard-Hauptmethode und rufen sie auf. In der Hauptmethode schreiben wir den größten Teil unseres Codes.

word_freq.py

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

Nachdem wir alles importiert und das Grundgerüst für unser Projekt eingerichtet haben, können wir mit den importierten Paketen fortfahren.

Schritt 2 - Einrichten des Argument-Parsers

In diesem Teil erstellen wir die Befehlszeilenargumente und speichern sie in einer variable für den schnellen Zugriff Zugriff.

In unserer Hauptmethode erstellen wir unsere Parservariable und weisen sie dem Standardkonstruktor zu, den + argparse + bereitstellt. Dann weisen wir das erwartete Argument für das Wort zu, nach dem wir in der Datei suchen werden. Zuletzt weisen wir das erwartete Argument für die Datei zu, in der das Wort enthalten ist. Dies ist eine "+ .txt +" - Datei.

word_freq.py

...
def main():










if __name__ == "__main__":
 main()

Im Moment ist das erste Argument in der Methode der Titel dessen, was wir in der Befehlszeile erwarten. Das zweite Argument "+ help =" …​ "+" wird verwendet, um dem Benutzer einige Informationen darüber zu liefern, wie das Befehlszeilenargument lauten soll.

Als nächstes speichern wir die angegebenen Argumente in einer anderen Variablen, die wir "+ args +" nennen.

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()

Zur Sicherheit sollten wir Ihre Eingaben immer überprüfen, falls die Befehlszeilenargumente Tippfehler enthalten. Dies soll auch verhindern, dass unser Skript abrupt abstürzt. Behandeln wir Fehler daher mit einer "+ try +" - Anweisung.

word_freq.py

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








if __name__ == "__main__":
 main()

Wir verwenden "+ sys.exit (1) +", um dem Benutzer anzuzeigen, dass ein Problem mit dem Code aufgetreten ist und dieser nicht erfolgreich abgeschlossen werden konnte.

Unser Projekt kann jetzt Befehlszeilenargumente aufnehmen. Der nächste Schritt ist das Parsen unserer Eingabedatei.

Schritt 3 - Analysieren der Datei

In diesem Schritt werden wir eine Datei aufnehmen, jedes Wort lesen, protokollieren, wie oft sie erscheinen, und alles in einem Wörterbuchdatentyp speichern.

Lassen Sie uns eine Funktion mit dem Namen + word_freq () + erstellen, die zwei Befehlszeilenargumente (the word und der Dateiname) und rufen Sie diese Funktion dann in + main () + auf.

word_freq.py

...
def main():
   ...




if __name__ == "__main__":
 main()

Der erste Schritt zum Parsen der Datei besteht darin, einen Dictionary-Datentyp zu erstellen, den wir als + doc + bezeichnen. Dies speichert jedes Wort in der Datei und protokolliert, wie oft es vorgekommen ist.

word_freq.py

...
def word_freq( word, filename ):


if __name__ == "__main__":
 main()

Der nächste Schritt wäre, die angegebene Datei zu durchlaufen. Dies geschieht unter Verwendung einer nested + for + loop.

Die erste "+ für" -Schleife dient dazu, die Datei zu öffnen und die erste Zeile daraus zu ziehen. Dann nimmt es, was in jeder Zeile ist, und teilt es auf der Grundlage einer Zeichenfolge aus einem Leerzeichen zwischen Wörtern auf, während Wörter in einem Array gespeichert werden.

Die zweite "+ für +" -Schleife nimmt dieses Array und durchläuft es, um zu prüfen, ob es sich entweder im Wörterbuch befindet oder nicht. Wenn ja, addieren wir eine Zählung dazu. Ist dies nicht der Fall, erstellen wir einen neuen Eintrag und initialisieren ihn als 1.

word_freq.py

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









if __name__ == "__main__":
 main()

Jetzt sind wir mit dem Projekt auf halbem Weg.

Zusammenfassend sollte die Methode "+ our main () " die Befehlszeileneingaben einrichten und an die Funktion " word_freq () " übergeben. ` word_freq () +` sollte das Wort und den Dateinamen von der Befehlszeile nehmen und jedes einzelne Wort speichern, das in der Textdatei gefunden wird.

Als Nächstes nehmen wir diese Daten und organisieren sie für die Verwendung in unserer Grafik.

Schritt 4 - Speichern und Sortieren von Daten

Bevor wir das Diagramm erstellen, müssen wir sicherstellen, dass das Wort tatsächlich in der Datei enthalten ist, die wir geöffnet haben. Wir können dies mit einer "+ if +" conditional statement tun.

word_freq.py

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




if __name__ == "__main__":
 main()

Jetzt, da wir wissen, dass das Wort in der Datei enthalten ist, können wir beginnen, die Daten für unser Diagramm einzurichten.

Zuerst müssen wir unseren Dictionary-Datentyp vom höchsten bis zum niedrigsten Vorkommen sortieren und Variablen für die spätere Verwendung initialisieren. Wir müssen unser Wörterbuch so sortieren, dass es in der Grafik angemessen dargestellt wird.

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()

Die beiden Variablen, die notiert werden müssen, sind "+ just_the_occur ". Dies sind die Daten, die enthalten, wie oft ein Wort vorkommt. Die andere Variable ist " just_the_rank +". Dies ist die Variable, die die Daten zum Rang des Wortes enthält.

Nachdem wir das sortierte Wörterbuch haben, durchlaufen wir es, um sowohl unser Wort als auch seinen Rang zu finden und unsere Grafik mit diesen Daten zu füllen.

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()

Hier müssen wir sicherstellen, dass beide Variablen "+ just_the_occur " und " just_the_rank " die gleiche Länge haben, sonst lässt " matplotlib +" uns das Diagramm nicht erstellen.

Wir haben auch eine "+ if +" - Anweisung in die Schleife eingefügt, um unser Wort (von dem wir bereits wissen, dass es da ist) zu finden und seinen Rang und seine Häufigkeit zu ermitteln.

Jetzt haben wir alles, was wir brauchen, um Ihr Diagramm zu erstellen. Unser nächster Schritt ist, es endlich zu schaffen.

Schritt 5 - Erstellen des Diagramms

An dieser Stelle können wir die Variable "+ plt +" einfügen, die wir zu Beginn erstellt haben. Um unser Diagramm zu erstellen, benötigen wir einen Titel, eine Beschriftung der Y-Achse, eine Beschriftung der X-Achse, eine Skala und einen Diagrammtyp.

In unserem Fall erstellen wir ein Diagramm zur Protokollbasis 10, um unsere Daten zu organisieren. Die Titel- und Achsenbeschriftungen können beliebig sein. Je aussagekräftiger sie sind, desto besser ist sie für Personen, die Ihr Diagramm betrachten.

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()

Die Funktionen title, + plt.ylabel () + und + plt.xlabel () + sind Beschriftungen für jede Achse.

Die Funktion "+ plt.loglog () " verwendet " just_the_rank " und " just_the_occur +" für die x- bzw. y-Achse.

Wir ändern die Protokollbasis und setzen sie auf 10.

Dann setzen wir den Plot so, dass er unseren Punkt streut und hervorhebt. Wir haben es zu einem orangefarbenen Stern mit der Größe 100 gemacht. Schließlich haben wir es mit unserem Wort gekennzeichnet.

Sobald alles für unser Diagramm fertig ist, sagen wir, dass es mit + plt.show () + angezeigt werden soll.

Nachdem unser Code nun vollständig ist, können wir ihn testen.

Schritt 6 - Ausführen des Programms

Für unser Textbeispiel benötigen wir eine Textdatei, aus der wir lesen können. Laden Sie also eine Datei von Project Gutenberg herunter, einem Freiwilligenprojekt, das den Lesern kostenlose eBooks (meistens im öffentlichen Bereich) zur Verfügung stellt.

Speichern wir den Text des Romans _http: //www.gutenberg.org/ebooks/98 [A Tale of Two Cities] _ von Charles Dickens als Datei mit dem Namen + cities.txt + mit + curl + in unserem aktuellen Verzeichnis das hält unser Python-Skript:

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

Lassen Sie uns als Nächstes unseren Code ausführen, indem wir die Parameter des Wortes unserer Wahl (wir verwenden "fish") und den Namen der Textdatei übergeben:

python word_freq.py fish cities.txt

Wenn alles richtig funktioniert hat, sollten Sie dies sehen:

image: https: //assets.digitalocean.com/articles/eng_python/WordFrequency/word-frequency-matplotlib.png [Wortfrequenz-Streudiagramm in matplotlib]

Wir sehen, dass der Rang des Wortes "Fisch" 5309 ist, und eine Visualisierung der Vorkommen.

Jetzt können Sie weiter mit verschiedenen Wörtern und verschiedenen Textdateien experimentieren. Weitere Informationen zum Arbeiten mit Textdateien finden Sie unter How To Handle Plain Text Files in Python 3 Tutorial.

Fertiger Code und Code-Verbesserungen

Zu diesem Zeitpunkt sollten Sie über ein voll funktionsfähiges Programm verfügen, das die Worthäufigkeit eines bestimmten Wortes in einer "+ .txt +" - Datei bestimmt.

Unten finden Sie unseren vollständigen Code für dieses Projekt.

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()

Nachdem alles erledigt ist, gibt es einige mögliche Verbesserungen und Änderungen, die wir an diesem Code vornehmen können.

Wenn wir die Häufigkeit von zwei Wörtern vergleichen möchten, fügen wir unseren Befehlszeilenargumenten eine zusätzliche Wortposition hinzu. Um dies zu erreichen, müssten wir einen weiteren Checker für das Wort und weitere Variablen für die Wörter hinzufügen.

Wir können das Programm auch so modifizieren, dass es vergleicht, wie lange jedes Wort mit einem anderen Wort ist. Dazu würden wir die Wörter nach Länge vergleichen und jede einzelne Länge im Wörterbuch speichern.

Fazit

Wir haben gerade ein Programm erstellt, um eine Textdatei zu lesen und die Daten so zu organisieren, dass die Häufigkeit eines bestimmten Wortes im Vergleich zu den anderen in einem Text angezeigt wird.

Wenn Sie sich für Datenvisualisierung interessieren, können Sie auch unsere https://www.digitalocean.com/community/tutorials/how-to-make-a-bar-chart-with-javascript-and-the-d3- ansehen. library Tutorial [So erstellen Sie ein Balkendiagramm mit JavaScript und der D3-Bibliothek].

Related