Lutscher-Grafik | Lutscherdiagramme in Python

Teilen auf Facebook
Teilen auf twittern
Teilen auf verlinktin
Teilen auf Telegramm
Teilen auf WhatsApp

Inhalt

Dieser Artikel wurde im Rahmen der Data Science Blogathon

Wie die Evolution des Menschen, Auch Datenvisualisierungstechniken haben sich im Laufe der Zeit entwickelt. In der letzten Zeit, Es wurden bessere Visualisierungstechniken als je zuvor eingeführt. Jeden Tag, Menschen erfinden ihre eigene Visualisierungserfindung mit einem abschließenden ZIEL: die Geschichte hinter den Daten verbessern. Zweifellos, fortgeschrittene Datenvisualisierungstechniken erfordern mehr Geschick und Mühe, aber die grafik lohnt sich immer. Aber dank des menschlichen Gehirns, Was früher mehrere Codezeilen erforderte, ist jetzt mit einem einzeiligen Funktionsaufruf möglich. Dies erklärt besser unsere Behauptung, dass sich Datenvisualisierungstechniken im Laufe der Zeit weiterentwickelt haben..

In diesem Artikel wird eine der beliebten und leistungsstarken Datenvisualisierungstechniken erörtert, die von Unternehmen häufig verwendet werden, um Daten zu beschreiben und sie in Python darzustellen.. Wie ich sagte, Das Plotten dieser Plots ist keine Herausforderung mehr. Die Bibliothek muss man kennen, die an der Technik beteiligten Funktionen und Argumente.

54792pexels-alleksana-4475278-3698816
Bild von alleksana aus Pexels

Inhaltsverzeichnis

  1. Was sind Lollipop-Grafiken??
  2. So zeichnen Sie ein Lutscherdiagramm in Python?
  3. Improvisieren Sie Ihre Lollipop-Grafiken
  4. Vergleich von Balkendiagrammen und Lollipop-Diagrammen
  5. Schlussfolgerungen

Was sind Lollipop-Grafiken??

Die Lollipop-Grafik besteht aus einem Riegel und einem Stick, der dem Stick und dem Kandiszucker obenauf ähnelt, beziehungsweise. Gefüllte Kreise werden auf die Balken gelegt, was die Ähnlichkeit mit dem gezuckerten Lutscher gibt. Die Lollipop-Grafik, wie das Balkendiagramm, wird verwendet, um die verschiedenen Klassen in einer Kategorie zu vergleichen. Deswegen, Dies ist ein großartiges Werkzeug, um den Vergleich zwischen Klassen zu visualisieren. Aber, Was unterscheidet es vom Balkendiagramm?? Zuerst, macht es einfach, die Werte zu identifizieren, wenn wir oben einen gefüllten Kreis haben. Zweitens, wenn wir mehr kurse haben, sagen wir mehr als 10, Balkendiagramme werden unübersichtlich und für Endbenutzer schwer zu lesen. Während, Zweitens, Lollipop-Charts verwenden die schmalen Balken, was einen größeren Raum für mehr Klassen schafft. Nochmal, wie Balkendiagramme, wir können die Lutscher horizontal verfolgen, wenn die Anzahl der Klassen hoch ist.

Lollipop-Charts werden auch verlangt, um Rangfolgen zwischen den Klassen anzuzeigen. Zum Beispiel, wenn wir vergleichen wollen 20 verschiedene Automodelle basierend auf ihrem Kraftstoffverbrauch. In ähnlichen Szenarien, Lollipop-Grafiken sind hilfreich, um die Arbeit effizient zu erledigen und minimale Grafiken bereitzustellen.

26927pexels-fauxels-3183153-6439916

Fauxels-Bild von Pexels

So zeichnen Sie ein Lutscherdiagramm in Python?

Lollipop-Graphen können in Python effizient mit der Matplotlib-Bibliothek geplottet werden. Die Matplotlib-Bibliothek enthält eine nützliche Funktion .Mutter() die dazu gedacht ist, Lollipop-Charts zu erstellen. Mal sehen wie es funktioniert.

1. Bibliotheken importieren

import matplotlib.pyplot als plt
numpy als np importieren

2. Zufällige Datenerstellung

x = ['EIN', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'ICH', 'J']
y = z.B. linspace(1, (np.log(0.2 * np.pi)), 10)

3. Zeichnen Sie das Lutscherdiagramm

plt.stem(x, Ja, use_line_collection = True)
plt.zeigen()

In plt.stem (), Wir haben das Argument use_line_collection auf True gesetzt. Dadurch werden dem Diagramm einzelne Linien als LineCollection hinzugefügt. Wenn wir dieses Argument nicht angeben, gibt eine UserWarning aus und erinnert uns daran, das Argument auf True zu setzen. Dies erhöht die Leistung des Stammplots.

4. Alles zusammenfügen

import matplotlib.pyplot als plt
numpy als np importieren
x = ['EIN', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'ICH', 'J']
y = np.zufällig.zufällig(1, (np.log(0.2 * np.pi)), 10)
plt.stem(x, Ja, use_line_collection = True)
plt.zeigen()
42006l1-9239754

Grundlegendes Lutscherdiagramm (Quelle: PC)

Improvisieren Sie Ihre Lollipop-Grafiken

Lollipop-Grafiken können durch Hinzufügen von Argumenten zu . verbessert werden .Mutter() Verbesserung der Lesbarkeit und Datenbeschreibungsfähigkeiten. Einige Improvisationen, die gemacht werden können, sind:

EIN. Hinzufügen zusätzlicher Argumente:

import matplotlib.pyplot als plt
numpy als np importieren
x = ['EIN', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'ICH', 'J']
y = z.B. linspace(1, (np.log(0.2 * np.pi)), 10)
plt.stem(x, Ja, Markerfmt ="S", linefmt="--", basefmt=":", use_line_collection=Wahr)
plt.zeigen()

Beim Ausführen dieses Codes, wir erhalten:

69459l2-8024298

Lollipop-Diagramm mit zusätzlichen Argumenten (Quelle: persönlicher Computer)

Hier, Wir haben drei Modifikationen vorgenommen:

EIN. Maker-Format – Wir spezifizieren Markerfmt = ‘s’, Dies ersetzte den ausgefüllten Kreis unseres Lollipop-Diagramms durch ein Quadrat (s bezieht sich auf Quadrat)

B. Linienformat – Wir spezifizieren linefmat = ‘-‘, Dies ersetzte den Stamm unseres Lollipop-Diagramms durch eine Doppelpunktlinie. (- bezieht sich auf den Doppelstrich)

C. Baseline-Format – Wir spezifizieren basefmt = ‘:’, dies ersetzte die Grundlinie unseres Lollipop-Diagramms zum Doppelpunkt.

2. Klassifikation der Lutschertabelle

import matplotlib.pyplot als plt
numpy als np importieren
x = ['EIN', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'ICH', 'J']
y = Liste(z.B. linspace(1, (np.log(0.2 * np.pi)), 10))
y.sort()
plt.stem(x, Ja, Markerfmt ="S", linefmt="--", basefmt=":", use_line_collection=Wahr)
plt.zeigen()

Beim Ausführen dieses Codes, wir erhalten:

58697l3-9213932

Geordnetes Lutscherdiagramm mit zusätzlichen Argumenten (Quelle: persönlicher Computer)

Denken Sie daran, dass wir hier die X-Labels codiert haben. Deswegen, X-Labels sind keinem Wert zugeordnet. Und deshalb beim Bestellen der Werte, Etiketten bleiben am selben Ort.

3. Zeichnen eines horizontalen Palettendiagramms

import matplotlib.pyplot als plt
numpy als np importieren
x = ['EIN', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'ICH', 'J']
y = Liste(z.B. linspace(1, (np.log(0.2 * np.pi)), 10))
y.sort()
my_range=range(1,len(x)+1)
plt.hlines(y = x, xmin = 0 , xmax = y, Farbe="Himmelblau")
plt.plot(Ja, x, "Ö")
plt.zeigen()

Beim Ausführen dieses Codes, wir erhalten:

21249l4-4200757

Horizontales Palettendiagramm (Quelle: persönlicher Computer)

Hier, Wir verwenden die .hlines-Methode () um die horizontalen Sticks des Lollipop-Diagramms zu zeichnen, und der Zuckerzucker wird mit der .plot-Methode aufgetragen () Angabe des Markers als “Ö”.

Vergleich von Balkendiagrammen und Lollipop-Diagrammen

Vergleichen wir das Balkendiagramm und den Lollipop mit einem Beispiel, um festzustellen, welches gut zu unserem Beispiel passt. Hier, Wir werden die Unterplots für das horizontale Balkendiagramm und das horizontale Palettendiagramm zeichnen, um die Zahlen nebeneinander zu vergleichen. Wir haben Zufallsdaten mit der NumPy-Bibliothek generiert. Auf der Y-Achse, wir haben die benutzt Distanz() Funktion und konvertierte jedes Label in einen String.

import matplotlib.pyplot als plt
numpy als np importieren
x = Liste(Karte(str, Bereich(1, 35)))
y = Liste(np.zufällig.zufällig(34))
F, axs = plt.subplots(1,2,Feigengröße=(12,6))
Achsen[0].barh(x,Ja)
Achsen[1].hlines(y = x, xmin = 0 , xmax = y, Farbe="Himmelblau")
Achsen[1].Handlung(Ja, x, Markierung = "Ö", Linienbreite = 0)
plt.zeigen()

Beim Ausführen dieses Codes, wir erhalten:

25508l7-9466640

Vergleich von horizontalem Balkendiagramm und horizontalem Palettendiagramm (Quelle: persönlicher Computer)

Deswegen, Das Lesen der Daten ist auf dem horizontalen Palettendiagramm einfacher als auf dem horizontalen Balkendiagramm. Man kann die Werte leicht klassifizieren und die Klassen innerhalb vergleichen. Was ist mehr, eine größere Anzahl von Klassen in einer Kategorie kann die Klassenachse sättigen. Deswegen, Auf eine Art von Diagramm sollte man sich bei einem Problem nicht verlassen. Das Zeichnen verschiedener Diagramme für ein Problem und die Auswahl des besten ist eine klügere Entscheidung.

Notiz: Hier verwenden wir die .random-Methode () de NumPy zufällig. Jedes Mal, wenn wir den Code ausführen, erzeugt einen anderen Satz von Werten. Deswegen, Sie erhalten jedes Mal unterschiedliche Grafiken, wenn wir den Code ausführen.

Schlussfolgerungen

In diesem Artikel, Wir haben gelernt, wie man in Python ein einfaches Lollipop-Diagramm erstellt. Aber das Thema endet hier nicht. Es gibt viele Modifikationen, die an Ihren Lollipop-Grafiken vorgenommen werden können. Diejenigen, die wir zuvor gelernt haben, sind die grundlegendsten Änderungen, die mit weniger Aufwand durchgeführt werden können. Heute, viele BI-Tools und Programmiersprachen sind in der Lage, erweiterte Visualisierungen wie Lollipop-Charts zu erstellen. Eigentlich, das .Mutter() Die Matplotlib-Methode ist von der MATLAB-Root-Methode inspiriert. Wir können die Lollipop-Charts den Sonderfall des Balkendiagramms nennen. Wir besprechen auch, welche Fehler beim Erstellen eines Lollipop-Diagramms vermieden werden sollten.. Sie können versuchen, Ihre eigene Version von Lollipop Charts zu erstellen, da Sie immer lernen, indem Sie es versuchen..

Über den Autor

Verbinde dich mit mir auf LinkedIn Hier.

Schau dir hier meine anderen Artikel an

Sie können mir Ihre wertvollen Kommentare auf LinkedIn zur Verfügung stellen.

Danke, dass du uns deine Zeit schenkst!

Die in diesem Lollipop-Chart-Artikel gezeigten Medien sind nicht Eigentum von DataPeaker und werden nach Ermessen des Autors verwendet.

Abonniere unseren Newsletter

Wir senden Ihnen keine SPAM-Mail. Wir hassen es genauso wie du.