Text in Matplotlib-Plots

Einführung in das Plotten und Arbeiten mit Text in Matplotlib.

Matplotlib bietet umfangreiche Textunterstützung, einschließlich Unterstützung für mathematische Ausdrücke, TrueType-Unterstützung für Raster- und Vektorausgaben, durch Zeilenumbruch getrennten Text mit beliebigen Drehungen und Unicode-Unterstützung.

Da es Schriften direkt in Ausgabedokumente einbettet, z. B. für Postscript oder PDF, sehen Sie auf dem Bildschirm das, was Sie in der Hardcopy erhalten. Die FreeType- Unterstützung erzeugt sehr schöne, geglättete Schriftarten, die selbst bei kleinen Rastergrößen gut aussehen. Matplotlib enthält eine eigene matplotlib.font_manager(Dank an Paul Barrett), die einen plattformübergreifenden, W3C- konformen Algorithmus zum Auffinden von Schriftarten implementiert.

Der Benutzer hat eine große Kontrolle über die Texteigenschaften (Schriftgröße, Schriftstärke, Textposition und -farbe usw.) mit sinnvollen Standardeinstellungen in der rc-Datei . Und für diejenigen, die sich für mathematische oder wissenschaftliche Zahlen interessieren, implementiert Matplotlib eine große Anzahl mathematischer TeX-Symbole und -Befehle, die mathematische Ausdrücke überall in Ihrer Figur unterstützen.

Einfache Textbefehle

Die folgenden Befehle werden verwendet, um Text in den impliziten und expliziten Schnittstellen zu erstellen (siehe Matplotlib-Anwendungsschnittstellen (APIs) für eine Erklärung der Kompromisse):

implizite API	explizite API	Bezeichnung
text	text	Fügen Sie Text an einer beliebigen Stelle der Axes.
annotate	annotate	Fügen Sie eine Anmerkung mit einem optionalen Pfeil an einer beliebigen Stelle der Axes.
xlabel	set_xlabel	Fügen Sie der Axesx-Achse von eine Beschriftung hinzu.
ylabel	set_ylabel	AxesFügen Sie der Y-Achse von eine Beschriftung hinzu.
title	set_title	Fügen Sie der Axes.
figtext	text	Fügen Sie Text an einer beliebigen Stelle der Figure.
suptitle	suptitle	Fügen Sie der Figure.

Alle diese Funktionen erstellen und geben eine TextInstanz zurück, die mit einer Vielzahl von Schriftarten und anderen Eigenschaften konfiguriert werden kann. Das folgende Beispiel zeigt alle diese Befehle in Aktion, und weitere Einzelheiten werden in den folgenden Abschnitten bereitgestellt.

import matplotlib
import matplotlib.pyplot as plt

fig = plt.figure()
ax = fig.add_subplot()
fig.subplots_adjust(top=0.85)

# Set titles for the figure and the subplot respectively
fig.suptitle('bold figure suptitle', fontsize=14, fontweight='bold')
ax.set_title('axes title')

ax.set_xlabel('xlabel')
ax.set_ylabel('ylabel')

# Set both x- and y-axis limits to [0, 10] instead of default [0, 1]
ax.axis([0, 10, 0, 10])

ax.text(3, 8, 'boxed italics text in data coords', style='italic',
        bbox={'facecolor': 'red', 'alpha': 0.5, 'pad': 10})

ax.text(2, 6, r'an equation: $E=mc^2$', fontsize=15)

ax.text(3, 2, 'Unicode: Institut für Festkörperphysik')

ax.text(0.95, 0.01, 'colored text in axes coords',
        verticalalignment='bottom', horizontalalignment='right',
        transform=ax.transAxes,
        color='green', fontsize=15)

ax.plot([2], [1], 'o')
ax.annotate('annotate', xy=(2, 1), xytext=(3, 4),
            arrowprops=dict(facecolor='black', shrink=0.05))

plt.show()

Beschriftungen für x- und y-Achse

Das Angeben der Beschriftungen für die x- und y-Achse ist über die Methoden set_xlabelund einfach.set_ylabel

import matplotlib.pyplot as plt
import numpy as np

x1 = np.linspace(0.0, 5.0, 100)
y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)

fig, ax = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1)
ax.set_xlabel('time [s]')
ax.set_ylabel('Damped oscillation [V]')

plt.show()

Die x- und y-Labels werden automatisch so platziert, dass sie die x- und y-Ticklabels löschen. Vergleichen Sie die Grafik unten mit der oben, und beachten Sie, dass sich die y-Markierung links von der oben befindet.

fig, ax = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1*10000)
ax.set_xlabel('time [s]')
ax.set_ylabel('Damped oscillation [V]')

plt.show()

Wenn Sie die Beschriftungen verschieben möchten, können Sie das Schlüsselwortargument labelpad angeben , wobei der Wert Punkte ist (1/72", dieselbe Einheit, die zum Angeben von Schriftgrößen verwendet wird).

fig, ax = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1*10000)
ax.set_xlabel('time [s]')
ax.set_ylabel('Damped oscillation [V]', labelpad=18)

plt.show()

Oder die Labels akzeptieren alle TextSchlüsselwortargumente, einschließlich position , über die wir die Labelpositionen manuell angeben können. Hier platzieren wir das xlabel ganz links von der Achse. Beachten Sie, dass die y-Koordinate dieser Position keine Auswirkung hat - um die y-Position anzupassen, müssen wir das Labelpad -Schlüsselwortargument verwenden .

fig, ax = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1)
ax.set_xlabel('time [s]', position=(0., 1e6), horizontalalignment='left')
ax.set_ylabel('Damped oscillation [V]')

plt.show()

Alle Beschriftungen in diesem Tutorial können durch Manipulieren der matplotlib.font_manager.FontPropertiesMethode oder durch benannte Schlüsselwortargumente geändert werdenset_xlabel

from matplotlib.font_manager import FontProperties

font = FontProperties()
font.set_family('serif')
font.set_name('Times New Roman')
font.set_style('italic')

fig, ax = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1)
ax.set_xlabel('time [s]', fontsize='large', fontweight='bold')
ax.set_ylabel('Damped oscillation [V]', fontproperties=font)

plt.show()

Schließlich können wir natives TeX-Rendering in allen Textobjekten verwenden und mehrere Zeilen haben:

fig, ax = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.2, left=0.2)
ax.plot(x1, np.cumsum(y1**2))
ax.set_xlabel('time [s] \n This was a long experiment')
ax.set_ylabel(r'$\int\ Y^2\ dt\ \ [V^2 s]$')
plt.show()

Titel

Subplot-Titel werden auf die gleiche Weise wie Labels gesetzt, aber es gibt die loc- Schlüsselwortargumente, die die Position und Ausrichtung vom Standardwert von ändern können loc=center.

fig, axs = plt.subplots(3, 1, figsize=(5, 6), tight_layout=True)
locs = ['center', 'left', 'right']
for ax, loc in zip(axs, locs):
    ax.plot(x1, y1)
    ax.set_title('Title with loc at '+loc, loc=loc)
plt.show()

Der vertikale Abstand für Titel wird über rcParams["axes.titlepad"](Standard: 6.0) gesteuert. Die Einstellung auf einen anderen Wert verschiebt den Titel.

fig, ax = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(top=0.8)
ax.plot(x1, y1)
ax.set_title('Vertically offset title', pad=30)
plt.show()

Ticks und Ticklabels

Das Platzieren von Ticks und Ticklabels ist ein sehr kniffliger Aspekt beim Erstellen einer Figur. Matplotlib tut sein Bestes, um die Aufgabe automatisch zu erledigen, bietet aber auch einen sehr flexiblen Rahmen, um die Auswahlmöglichkeiten für Tick-Positionen und deren Beschriftung zu bestimmen.

Terminologie

Achsen haben ein matplotlib.axis.AxisObjekt für ax.xaxisund ax.yaxisdas die Informationen darüber enthält, wie die Beschriftungen in der Achse angeordnet sind.

Die Achsen-API wird ausführlich in der Dokumentation zu erklärt axis.

Ein Achsenobjekt hat Haupt- und Nebenteilstriche. Die Achse verfügt über Axis.set_major_locatorund Axis.set_minor_locatorMethoden, die die aufgezeichneten Daten verwenden, um die Position von großen und kleinen Ticks zu bestimmen. Es gibt auch Axis.set_major_formatterund Axis.set_minor_formatterMethoden, die die Tick-Beschriftungen formatieren.

Einfache Ticks

Oft ist es praktisch, einfach die Tick-Werte und manchmal auch die Tick-Beschriftungen zu definieren und die Standard-Locators und -Formatierer zu überschreiben. Davon wird abgeraten, da es die interaktive Navigation der Handlung unterbricht. Es kann auch die Achsengrenzen zurücksetzen: Beachten Sie, dass das zweite Diagramm die Ticks enthält, nach denen wir gefragt haben, einschließlich derjenigen, die weit außerhalb der automatischen Anzeigegrenzen liegen.

fig, axs = plt.subplots(2, 1, figsize=(5, 3), tight_layout=True)
axs[0].plot(x1, y1)
axs[1].plot(x1, y1)
axs[1].xaxis.set_ticks(np.arange(0., 8.1, 2.))
plt.show()

Wir können dies natürlich im Nachhinein beheben, aber es zeigt eine Schwäche der Hartcodierung der Ticks auf. Dieses Beispiel ändert auch das Format der Ticks:

fig, axs = plt.subplots(2, 1, figsize=(5, 3), tight_layout=True)
axs[0].plot(x1, y1)
axs[1].plot(x1, y1)
ticks = np.arange(0., 8.1, 2.)
# list comprehension to get all tick labels...
tickla = [f'{tick:1.2f}' for tick in ticks]
axs[1].xaxis.set_ticks(ticks)
axs[1].xaxis.set_ticklabels(tickla)
axs[1].set_xlim(axs[0].get_xlim())
plt.show()

Tick-Locators und -Formatierer

Anstatt eine Liste aller Ticklabels zu erstellen, hätten wir matplotlib.ticker.StrMethodFormatter(neuer str.format() Formatstring) oder matplotlib.ticker.FormatStrFormatter(alter '%'-Formatstring) verwenden und an die ax.xaxis. A matplotlib.ticker.StrMethodFormatterkann auch durch Übergabe von a erstellt werden, strohne dass der Formatierer explizit erstellt werden muss.

fig, axs = plt.subplots(2, 1, figsize=(5, 3), tight_layout=True)
axs[0].plot(x1, y1)
axs[1].plot(x1, y1)
ticks = np.arange(0., 8.1, 2.)
axs[1].xaxis.set_ticks(ticks)
axs[1].xaxis.set_major_formatter('{x:1.1f}')
axs[1].set_xlim(axs[0].get_xlim())
plt.show()

Und natürlich hätten wir einen nicht standardmäßigen Locator verwenden können, um die Tick-Positionen festzulegen. Beachten Sie, dass wir immer noch die Tick-Werte übergeben, aber die oben verwendete x-Limit-Korrektur wird nicht benötigt.

fig, axs = plt.subplots(2, 1, figsize=(5, 3), tight_layout=True)
axs[0].plot(x1, y1)
axs[1].plot(x1, y1)
locator = matplotlib.ticker.FixedLocator(ticks)
axs[1].xaxis.set_major_locator(locator)
axs[1].xaxis.set_major_formatter('±{x}°')
plt.show()

Der Standardformatierer matplotlib.ticker.MaxNLocatorheißt as. Das Schlüsselwort steps enthält eine Liste von Vielfachen, die für Tick-Werte verwendet werden können. dh in diesem Fall wären 2, 4, 6 akzeptable Ticks, ebenso wie 20, 40, 60 oder 0,2, 0,4, 0,6. 3, 6, 9 wäre jedoch nicht akzeptabel, da 3 nicht in der Liste der Schritte erscheint.ticker.MaxNLocator(self, nbins='auto', steps=[1, 2, 2.5, 5, 10])

nbins=autoverwendet einen Algorithmus, um zu bestimmen, wie viele Ticks akzeptabel sind, basierend auf der Länge der Achse. Die Schriftgröße des Ticklabels wird berücksichtigt, aber die Länge des Tickstrings nicht (weil sie noch nicht bekannt ist). In der unteren Reihe sind die Ticklabels ziemlich groß, also stellen wir ein nbins=4, dass die Labels richtig passen Handdiagramm.

fig, axs = plt.subplots(2, 2, figsize=(8, 5), tight_layout=True)
for n, ax in enumerate(axs.flat):
    ax.plot(x1*10., y1)

formatter = matplotlib.ticker.FormatStrFormatter('%1.1f')
locator = matplotlib.ticker.MaxNLocator(nbins='auto', steps=[1, 4, 10])
axs[0, 1].xaxis.set_major_locator(locator)
axs[0, 1].xaxis.set_major_formatter(formatter)

formatter = matplotlib.ticker.FormatStrFormatter('%1.5f')
locator = matplotlib.ticker.AutoLocator()
axs[1, 0].xaxis.set_major_formatter(formatter)
axs[1, 0].xaxis.set_major_locator(locator)

formatter = matplotlib.ticker.FormatStrFormatter('%1.5f')
locator = matplotlib.ticker.MaxNLocator(nbins=4)
axs[1, 1].xaxis.set_major_formatter(formatter)
axs[1, 1].xaxis.set_major_locator(locator)

plt.show()

Schließlich können wir Funktionen für den Formatierer mit angeben matplotlib.ticker.FuncFormatter. Außerdem wird wie matplotlib.ticker.StrMethodFormatterbeim Übergeben einer Funktion automatisch eine matplotlib.ticker.FuncFormatter.

def formatoddticks(x, pos):
    """Format odd tick positions."""
    if x % 2:
        return f'{x:1.2f}'
    else:
        return ''


fig, ax = plt.subplots(figsize=(5, 3), tight_layout=True)
ax.plot(x1, y1)
locator = matplotlib.ticker.MaxNLocator(nbins=6)
ax.xaxis.set_major_formatter(formatoddticks)
ax.xaxis.set_major_locator(locator)

plt.show()

Dateticks

Matplotlib kann datetime.datetimeund numpy.datetime64 Objekte als Zeichenargumente akzeptieren. Datums- und Uhrzeitangaben erfordern eine spezielle Formatierung, die häufig von manuellen Eingriffen profitieren kann. Um zu helfen, haben Datumsangaben spezielle Locators und Formatters, die im matplotlib.datesModul definiert sind.

Ein einfaches Beispiel ist wie folgt. Beachten Sie, wie wir die Tick-Labels drehen müssen, damit sie sich nicht überschneiden.

import datetime

fig, ax = plt.subplots(figsize=(5, 3), tight_layout=True)
base = datetime.datetime(2017, 1, 1, 0, 0, 1)
time = [base + datetime.timedelta(days=x) for x in range(len(x1))]

ax.plot(time, y1)
ax.tick_params(axis='x', rotation=70)
plt.show()

Wir können ein Format an übergeben matplotlib.dates.DateFormatter. Beachten Sie auch, dass der 29. und der nächste Monat sehr nah beieinander liegen. Wir können dies beheben, indem wir die dates.DayLocatorKlasse verwenden, die es uns ermöglicht, eine Liste der zu verwendenden Tage des Monats anzugeben. Ähnliche Formatierer sind im matplotlib.dates Modul aufgeführt.

import matplotlib.dates as mdates

locator = mdates.DayLocator(bymonthday=[1, 15])
formatter = mdates.DateFormatter('%b %d')

fig, ax = plt.subplots(figsize=(5, 3), tight_layout=True)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.plot(time, y1)
ax.tick_params(axis='x', rotation=70)
plt.show()

Legenden und Anmerkungen

• Legenden: Legendenführer

• Anmerkungen: Anmerkungen