Der Lebenszyklus eines Grundstücks

Dieses Tutorial soll den Anfang, die Mitte und das Ende einer einzelnen Visualisierung mit Matplotlib zeigen. Wir beginnen mit einigen Rohdaten und speichern am Ende eine Abbildung einer benutzerdefinierten Visualisierung. Unterwegs versuchen wir, einige nette Funktionen und Best Practices mit Matplotlib hervorzuheben.

Notiz

Dieses Tutorial basiert auf diesem hervorragenden Blogbeitrag von Chris Moffitt. Es wurde von Chris Holdgraf in dieses Tutorial umgewandelt.

Eine Anmerkung zu den expliziten vs. impliziten Schnittstellen

Matplotlib hat zwei Schnittstellen. Eine Erläuterung der Kompromisse zwischen den expliziten und impliziten Schnittstellen finden Sie unter Matplotlib Application Interfaces (APIs) .

In der explizit objektorientierten (OO) Schnittstelle verwenden wir direkt Instanzen von axes.Axes, um die Visualisierung in einer Instanz von aufzubauen figure.Figure. In der impliziten Schnittstelle, die von MATLAB inspiriert und modelliert wurde, wird eine globale zustandsbasierte Schnittstelle verwendet, die im pyplotModul gekapselt ist, um die "aktuellen Achsen" darzustellen. Sehen Sie sich die Pyplot-Tutorials an, um einen tieferen Einblick in die Pyplot-Oberfläche zu erhalten.

Die meisten Begriffe sind einfach, aber das Wichtigste, woran Sie denken sollten, ist Folgendes:

• Die Figur ist das letzte Bild, das 1 oder mehr Äxte enthalten kann.

• Die Achsen stellen einen einzelnen Plot dar (verwechseln Sie dies nicht mit dem Wort "Achse", das sich auf die x/y-Achse eines Plots bezieht).

Wir rufen Methoden auf, die das Plotten direkt von den Axes aus durchführen, was uns viel mehr Flexibilität und Möglichkeiten bei der Anpassung unseres Plots gibt.

Notiz

Im Allgemeinen bevorzugen Sie die explizite Schnittstelle gegenüber der impliziten Pyplot-Schnittstelle zum Plotten.

Unsere Daten

Wir verwenden die Daten aus dem Beitrag, aus dem dieses Tutorial abgeleitet wurde. Es enthält Verkaufsinformationen für eine Reihe von Unternehmen.

import numpy as np
import matplotlib.pyplot as plt


data = {'Barton LLC': 109438.50,
        'Frami, Hills and Schmidt': 103569.59,
        'Fritsch, Russel and Anderson': 112214.71,
        'Jerde-Hilpert': 112591.43,
        'Keeling LLC': 100934.30,
        'Koepp Ltd': 103660.54,
        'Kulas Inc': 137351.96,
        'Trantow-Barrows': 123381.38,
        'White-Trantow': 135841.99,
        'Will LLC': 104437.60}
group_data = list(data.values())
group_names = list(data.keys())
group_mean = np.mean(group_data)

Erste Schritte

Diese Daten werden natürlich als Balkendiagramm visualisiert, mit einem Balken pro Gruppe. Um dies mit dem objektorientierten Ansatz zu tun, erzeugen wir zunächst eine Instanz von figure.Figureund axes.Axes. Die Figur ist wie eine Leinwand, und die Achsen sind ein Teil dieser Leinwand, auf der wir eine bestimmte Visualisierung machen werden.

Notiz

Figuren können mehrere Achsen haben. Informationen dazu finden Sie im Tutorial „Tight Layout“ .

fig, ax = plt.subplots()

Jetzt, da wir eine Axes-Instanz haben, können wir darauf plotten.

fig, ax = plt.subplots()
ax.barh(group_names, group_data)

<BarContainer object of 10 artists>

Steuern des Stils

In Matplotlib sind viele Stile verfügbar, mit denen Sie Ihre Visualisierung an Ihre Bedürfnisse anpassen können. Um eine Liste von Stilen anzuzeigen, können wir verwenden style.

print(plt.style.available)

['Solarize_Light2', '_classic_test_patch', '_mpl-gallery', '_mpl-gallery-nogrid', 'bmh', 'classic', 'dark_background', 'fast', 'fivethirtyeight', 'ggplot', 'grayscale', 'seaborn-v0_8', 'seaborn-v0_8-bright', 'seaborn-v0_8-colorblind', 'seaborn-v0_8-dark', 'seaborn-v0_8-dark-palette', 'seaborn-v0_8-darkgrid', 'seaborn-v0_8-deep', 'seaborn-v0_8-muted', 'seaborn-v0_8-notebook', 'seaborn-v0_8-paper', 'seaborn-v0_8-pastel', 'seaborn-v0_8-poster', 'seaborn-v0_8-talk', 'seaborn-v0_8-ticks', 'seaborn-v0_8-white', 'seaborn-v0_8-whitegrid', 'tableau-colorblind10']

Sie können einen Stil wie folgt aktivieren:

plt.style.use('fivethirtyeight')

Lassen Sie uns nun das obige Diagramm neu erstellen, um zu sehen, wie es aussieht:

fig, ax = plt.subplots()
ax.barh(group_names, group_data)

<BarContainer object of 10 artists>

Der Stil steuert viele Dinge, wie Farbe, Linienstärken, Hintergründe usw.

Anpassen des Diagramms

Jetzt haben wir einen Plot mit dem allgemeinen Aussehen, das wir wollen, also passen wir ihn an, damit er druckfertig ist. Lassen Sie uns zuerst die Beschriftungen auf der x-Achse drehen, damit sie deutlicher angezeigt werden. axes.Axes.get_xticklabels()Wir können mit der Methode auf diese Labels zugreifen :

fig, ax = plt.subplots()
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()

Wenn wir die Eigenschaft vieler Elemente gleichzeitig festlegen möchten, ist es nützlich, die pyplot.setp()Funktion zu verwenden. Dies nimmt eine Liste (oder viele Listen) von Matplotlib-Objekten und versucht, ein Stilelement von jedem festzulegen.

fig, ax = plt.subplots()
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')

[None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None]

Es sieht so aus, als ob dadurch einige der Etiketten auf der Unterseite abgeschnitten wurden. Wir können Matplotlib anweisen, automatisch Platz für Elemente in den von uns erstellten Figuren zu schaffen. Dazu setzen wir den autolayoutWert unserer rcParams. Weitere Informationen zum Steuern des Stils, Layouts und anderer Funktionen von Diagrammen mit rcParams finden Sie unter Anpassen von Matplotlib mit Stylesheets und rcParams .

plt.rcParams.update({'figure.autolayout': True})

fig, ax = plt.subplots()
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')

[None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None]

Als Nächstes fügen wir dem Diagramm Beschriftungen hinzu. Um dies mit der OO-Schnittstelle zu tun, können wir die Artist.set()Methode verwenden, um Eigenschaften dieses Axes-Objekts festzulegen.

fig, ax = plt.subplots()
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')
ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company',
       title='Company Revenue')

[(-10000.0, 140000.0), Text(0.5, 87.00000000000003, 'Total Revenue'), Text(86.99999999999997, 0.5, 'Company'), Text(0.5, 1.0, 'Company Revenue')]

Wir können auch die Größe dieses Diagramms mit der pyplot.subplots() Funktion anpassen. Wir können dies mit dem Schlüsselwortargument figsize tun .

Notiz

Während die Indizierung in NumPy der Form (Zeile, Spalte) folgt, folgt das Schlüsselwortargument figsize der Form (Breite, Höhe). Dies folgt Konventionen in der Visualisierung, die sich leider von denen der linearen Algebra unterscheiden.

fig, ax = plt.subplots(figsize=(8, 4))
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')
ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company',
       title='Company Revenue')

[(-10000.0, 140000.0), Text(0.5, 86.99999999999997, 'Total Revenue'), Text(86.99999999999997, 0.5, 'Company'), Text(0.5, 1.0, 'Company Revenue')]

Für Etiketten können wir benutzerdefinierte Formatierungsrichtlinien in Form von Funktionen angeben. Unten definieren wir eine Funktion, die eine ganze Zahl als Eingabe nimmt und einen String als Ausgabe zurückgibt. Wenn sie mit Axis.set_major_formatteroder verwendet Axis.set_minor_formatterwerden, erstellen und verwenden sie automatisch eine ticker.FuncFormatterKlasse.

Für diese Funktion ist das xArgument das ursprüngliche Tick-Label und pos die Tick-Position. Wir werden xhier nur verwenden, aber beide Argumente werden benötigt.

def currency(x, pos):
    """The two arguments are the value and tick position"""
    if x >= 1e6:
        s = '${:1.1f}M'.format(x*1e-6)
    else:
        s = '${:1.0f}K'.format(x*1e-3)
    return s

Wir können diese Funktion dann auf die Beschriftungen in unserem Plot anwenden. Dazu verwenden wir das xaxisAttribut unserer Achsen. Auf diese Weise können Sie Aktionen auf einer bestimmten Achse in unserem Diagramm ausführen.

fig, ax = plt.subplots(figsize=(6, 8))
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')

ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company',
       title='Company Revenue')
ax.xaxis.set_major_formatter(currency)

Kombinieren mehrerer Visualisierungen

Es ist möglich, mehrere Plotelemente auf derselben Instanz von zu zeichnen axes.Axes. Dazu müssen wir einfach eine andere der Plot-Methoden für dieses Achsenobjekt aufrufen.

fig, ax = plt.subplots(figsize=(8, 8))
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')

# Add a vertical line, here we set the style in the function call
ax.axvline(group_mean, ls='--', color='r')

# Annotate new companies
for group in [3, 5, 8]:
    ax.text(145000, group, "New Company", fontsize=10,
            verticalalignment="center")

# Now we move our title up since it's getting a little cramped
ax.title.set(y=1.05)

ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company',
       title='Company Revenue')
ax.xaxis.set_major_formatter(currency)
ax.set_xticks([0, 25e3, 50e3, 75e3, 100e3, 125e3])
fig.subplots_adjust(right=.1)

plt.show()

Rettung unseres Grundstücks

Jetzt, da wir mit dem Ergebnis unseres Plots zufrieden sind, wollen wir ihn auf der Festplatte speichern. Es gibt viele Dateiformate, in denen wir in Matplotlib speichern können. Um eine Liste der verfügbaren Optionen anzuzeigen, verwenden Sie:

print(fig.canvas.get_supported_filetypes())

{'eps': 'Encapsulated Postscript', 'jpg': 'Joint Photographic Experts Group', 'jpeg': 'Joint Photographic Experts Group', 'pdf': 'Portable Document Format', 'pgf': 'PGF code for LaTeX', 'png': 'Portable Network Graphics', 'ps': 'Postscript', 'raw': 'Raw RGBA bitmap', 'rgba': 'Raw RGBA bitmap', 'svg': 'Scalable Vector Graphics', 'svgz': 'Scalable Vector Graphics', 'tif': 'Tagged Image File Format', 'tiff': 'Tagged Image File Format', 'webp': 'WebP Image Format'}

Wir können dann verwenden figure.Figure.savefig(), um die Figur auf der Festplatte zu speichern. Beachten Sie, dass es einige nützliche Flags gibt, die wir unten zeigen:

• transparent=Truemacht den Hintergrund der gespeicherten Figur transparent, wenn das Format dies unterstützt.

• dpi=80steuert die Auflösung (dots per square inch) der Ausgabe.

• bbox_inches="tight"passt die Grenzen der Figur zu unserer Handlung.

# Uncomment this line to save the figure.
# fig.savefig('sales.png', transparent=False, dpi=80, bbox_inches="tight")