Plotten von Daten und Zeichenketten

Der grundlegendste Weg, Matplotlib-Plotting-Methoden zu verwenden, ist die Übergabe von Koordinaten als numerische Numpy-Arrays. Zum Beispiel funktioniert plot(x, y), wenn x und y Numpy-Arrays von Gleitkommazahlen (oder Ganzzahlen) sind. Plotting-Methoden funktionieren auch, wenn numpy.asarray x und y in ein Array von Gleitkommazahlen konvertieren kann; z. B. kann x eine Python-Liste sein.

Matplotlib hat auch die Fähigkeit, andere Datentypen zu konvertieren, wenn ein "Unit Converter" für den Datentyp existiert. Matplotlib verfügt über zwei integrierte Konverter, einen für Daten und einen für Listen von Zeichenketten. Andere nachgelagerte Bibliotheken haben ihre eigenen Konverter, um ihre Datentypen zu handhaben.

Die Methode zum Hinzufügen von Konvertern zu Matplotlib wird in matplotlib.units beschrieben. Hier geben wir einen kurzen Überblick über die integrierten Daten- und Zeichenkettenkonverter.

Datenkonvertierung

Wenn x und/oder y eine Liste von datetime-Objekten oder ein Array von numpy.datetime64-Objekten sind, verfügt Matplotlib über einen integrierten Konverter, der das Datum in eine Gleitkommazahl umwandelt und geeignete Tick-Locator und -Formatter für Daten zur Achse hinzufügt. Siehe matplotlib.dates.

Im folgenden Beispiel erhält die x-Achse einen Konverter, der von numpy.datetime64 in Gleitkommazahlen konvertiert, sowie einen Locator, der Ticks am Anfang des Monats platziert, und einen Formatter, der die Ticks entsprechend beschriftet.

import numpy as np

import matplotlib.dates as mdates
import matplotlib.units as munits

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(5.4, 2), layout='constrained')
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)

Beachten Sie, dass, wenn wir versuchen, eine Gleitkommazahl auf der x-Achse zu plotten, diese in Einheiten von Tagen seit der "Epoche" für den Konverter geplottet wird, in diesem Fall 1970-01-01 (siehe Matplotlib-Datumsformat). Wenn wir also den Wert 0 plotten, beginnen die Ticks bei 1970-01-01. (Der Locator wählt nun auch alle zwei Jahre einen Tick anstelle von jedem Monat.)

fig, ax = plt.subplots(figsize=(5.4, 2), layout='constrained')
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)
# 0 gets labeled as 1970-01-01
ax.plot(0, 0, 'd')
ax.text(0, 0, ' Float x=0', rotation=45)

Wir können den Locator und den Formatter anpassen; siehe Datums-Tick-Locator und Datums-Formatter für eine vollständige Liste und Datums-Tick-Locator und -Formatter für Beispiele deren Verwendung. Hier lokalisieren wir alle zwei Monate und formatieren nur mit dem 3-buchstabigen Namen des Monats unter Verwendung von "%b" (siehe strftime für Formatcodes).

fig, ax = plt.subplots(figsize=(5.4, 2), layout='constrained')
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)
ax.xaxis.set_major_locator(mdates.MonthLocator(bymonth=np.arange(1, 13, 2)))
ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))
ax.set_xlabel('1980')

Der Standard-Locator ist AutoDateLocator und der Standard-Formatter AutoDateFormatter. Es gibt auch "kompakte" Formatter und Locator, die eine kompaktere Beschriftung liefern und über rcParams eingestellt werden können. Beachten Sie, wie anstelle der redundanten "Jan"-Beschriftung am Jahresanfang "1980" verwendet wird. Weitere Beispiele finden Sie unter Datums-Ticks mit ConciseDateFormatter formatieren.

plt.rcParams['date.converter'] = 'concise'

fig, ax = plt.subplots(figsize=(5.4, 2), layout='constrained')
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)

Wir können die Grenzen der Achse festlegen, entweder durch Übergabe der entsprechenden Daten als Grenzen oder durch Übergabe eines Gleitkommawerts in den entsprechenden Einheiten von Tagen seit der Epoche. Wenn wir dies benötigen, können wir diesen Wert von date2num erhalten.

fig, axs = plt.subplots(2, 1, figsize=(5.4, 3), layout='constrained')
for ax in axs.flat:
    time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
    x = np.arange(len(time))
    ax.plot(time, x)

# set xlim using datetime64:
axs[0].set_xlim(np.datetime64('1980-02-01'), np.datetime64('1980-04-01'))

# set xlim using floats:
# Note can get from mdates.date2num(np.datetime64('1980-02-01'))
axs[1].set_xlim(3683, 3683+60)

Zeichenkettenkonvertierung: kategoriale Plots

Manchmal möchten wir Kategorien auf einer Achse anstelle von Zahlen beschriften. Matplotlib erlaubt dies unter Verwendung eines "kategorialen" Konverters (siehe category).

data = {'apple': 10, 'orange': 15, 'lemon': 5, 'lime': 20}
names = list(data.keys())
values = list(data.values())

fig, axs = plt.subplots(1, 3, figsize=(7, 3), sharey=True, layout='constrained')
axs[0].bar(names, values)
axs[1].scatter(names, values)
axs[2].plot(names, values)
fig.suptitle('Categorical Plotting')

Beachten Sie, dass die "Kategorien" in der Reihenfolge geplottet werden, in der sie zuerst angegeben werden, und dass nachfolgendes Plotten in einer anderen Reihenfolge die ursprüngliche Reihenfolge nicht beeinflusst. Darüber hinaus werden neue Ergänzungen am Ende hinzugefügt (siehe "pear" unten).

fig, ax = plt.subplots(figsize=(5, 3), layout='constrained')
ax.bar(names, values)

# plot in a different order:
ax.scatter(['lemon', 'apple'], [7, 12])

# add a new category, "pear", and put the other categories in a different order:
ax.plot(['pear', 'orange', 'apple', 'lemon'], [13, 10, 7, 12], color='C1')

Beachten Sie, dass bei Verwendung von plot wie oben die Reihenfolge des Plotting auf die ursprüngliche Reihenfolge der Daten abgebildet wird, sodass die neue Linie in der angegebenen Reihenfolge verläuft.

Der Kategorie-Konverter bildet Kategorien auf Ganzzahlen ab, beginnend bei Null. Daten können also auch manuell mit einer Gleitkommazahl zur Achse hinzugefügt werden. Beachten Sie, dass, wenn eine Gleitkommazahl übergeben wird, der keine "Kategorie" zugeordnet ist, der Datenpunkt trotzdem geplottet werden kann, aber kein Tick erstellt wird. Im Folgenden plotten wir Daten bei 4.0 und 2.5, aber dort wird kein Tick erstellt, da dies keine Kategorien sind.

fig, ax = plt.subplots(figsize=(5, 3), layout='constrained')
ax.bar(names, values)
# arguments for styling the labels below:
args = {'rotation': 70, 'color': 'C1',
        'bbox': {'color': 'white', 'alpha': .7, 'boxstyle': 'round'}}


# 0 gets labeled as "apple"
ax.plot(0, 2, 'd', color='C1')
ax.text(0, 3, 'Float x=0', **args)

# 2 gets labeled as "lemon"
ax.plot(2, 2, 'd', color='C1')
ax.text(2, 3, 'Float x=2', **args)

# 4 doesn't get a label
ax.plot(4, 2, 'd', color='C1')
ax.text(4, 3, 'Float x=4', **args)

# 2.5 doesn't get a label
ax.plot(2.5, 2, 'd', color='C1')
ax.text(2.5, 3, 'Float x=2.5', **args)

Das Festlegen der Grenzen für eine Kategorieachse kann durch Angabe der Kategorien oder durch Angabe von Gleitkommazahlen erfolgen.

fig, axs = plt.subplots(2, 1, figsize=(5, 5), layout='constrained')
ax = axs[0]
ax.bar(names, values)
ax.set_xlim('orange', 'lemon')
ax.set_xlabel('limits set with categories')
ax = axs[1]
ax.bar(names, values)
ax.set_xlim(0.5, 2.5)
ax.set_xlabel('limits set with floats')

Kategorieachsen sind für einige Plot-Typen hilfreich, können aber zu Verwirrung führen, wenn Daten als Liste von Zeichenketten eingelesen werden, selbst wenn sie als Liste von Gleitkommazahlen oder Daten gedacht sind. Dies geschieht manchmal beim Einlesen von durch Kommas getrennten Wertdateien (CSV). Der kategoriale Locator und Formatter platziert einen Tick bei jedem Zeichenkettenwert und beschriftet jeden davon.

fig, ax = plt.subplots(figsize=(5.4, 2.5), layout='constrained')
x = [str(xx) for xx in np.arange(100)]  # list of strings
ax.plot(x, np.arange(100))
ax.set_xlabel('x is list of strings')

Wenn dies nicht gewünscht ist, konvertieren Sie die Daten einfach vor dem Plotten in Gleitkommazahlen.

fig, ax = plt.subplots(figsize=(5.4, 2.5), layout='constrained')
x = np.asarray(x, dtype='float')  # array of float.
ax.plot(x, np.arange(100))
ax.set_xlabel('x is array of floats')

Konverter, Formatter und Locator auf einer Achse bestimmen

Manchmal ist es hilfreich zu debuggen, was Matplotlib zur Konvertierung der eingehenden Daten verwendet. Dies können wir tun, indem wir die Eigenschaft converter auf der Achse abfragen. Wir können auch die Formatter und Locator mit get_major_locator und get_major_formatter abfragen.

Beachten Sie, dass der Konverter standardmäßig *None* ist.

fig, axs = plt.subplots(3, 1, figsize=(6.4, 7), layout='constrained')
x = np.arange(100)
ax = axs[0]
ax.plot(x, x)
label = f'Converter: {ax.xaxis.get_converter()}\n '
label += f'Locator: {ax.xaxis.get_major_locator()}\n'
label += f'Formatter: {ax.xaxis.get_major_formatter()}\n'
ax.set_xlabel(label)

ax = axs[1]
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)
label = f'Converter: {ax.xaxis.get_converter()}\n '
label += f'Locator: {ax.xaxis.get_major_locator()}\n'
label += f'Formatter: {ax.xaxis.get_major_formatter()}\n'
ax.set_xlabel(label)

ax = axs[2]
data = {'apple': 10, 'orange': 15, 'lemon': 5, 'lime': 20}
names = list(data.keys())
values = list(data.values())
ax.plot(names, values)
label = f'Converter: {ax.xaxis.get_converter()}\n '
label += f'Locator: {ax.xaxis.get_major_locator()}\n'
label += f'Formatter: {ax.xaxis.get_major_formatter()}\n'
ax.set_xlabel(label)

Mehr über "Unit"-Unterstützung

Die Unterstützung für Daten und Kategorien ist Teil der "Unit"-Unterstützung, die in Matplotlib integriert ist. Diese wird in matplotlib.units und im Beispiel Grundlegende Einheiten beschrieben.

Die Unit-Unterstützung funktioniert, indem sie den Typ der an die Plot-Funktion übergebenen Daten abfragt und an den ersten Konverter in einer Liste weiterleitet, der diesen Datentyp akzeptiert. Wenn also x datetime-Objekte enthält, ist der Konverter _SwitchableDateConverter; wenn er Zeichenketten enthält, wird er an den StrCategoryConverter gesendet.

for k, v in munits.registry.items():
    print(f"type: {k};\n    converter: {type(v)}")

type: <class 'decimal.Decimal'>;
    converter: <class 'matplotlib.units.DecimalConverter'>
type: <class 'numpy.datetime64'>;
    converter: <class 'matplotlib.dates._SwitchableDateConverter'>
type: <class 'datetime.date'>;
    converter: <class 'matplotlib.dates._SwitchableDateConverter'>
type: <class 'datetime.datetime'>;
    converter: <class 'matplotlib.dates._SwitchableDateConverter'>
type: <class 'str'>;
    converter: <class 'matplotlib.category.StrCategoryConverter'>
type: <class 'numpy.str_'>;
    converter: <class 'matplotlib.category.StrCategoryConverter'>
type: <class 'bytes'>;
    converter: <class 'matplotlib.category.StrCategoryConverter'>
type: <class 'numpy.bytes_'>;
    converter: <class 'matplotlib.category.StrCategoryConverter'>

Es gibt eine Reihe von nachgelagerten Bibliotheken, die eigene Konverter mit Locatoren und Formatter bereitstellen. Unterstützung für physikalische Einheiten wird unter anderem von astropy, pint und unyt bereitgestellt.

High-Level-Bibliotheken wie pandas und nc-time-axis (und somit xarray) bieten eigene Datumsunterstützung. Diese Unterstützung kann manchmal mit der nativen Datumsunterstützung von Matplotlib inkompatibel sein, daher ist Vorsicht geboten, wenn Matplotlib-Locator und -Formatter verwendet werden, falls diese Bibliotheken genutzt werden.