Anpassen von Matplotlib-Legenden

Einführung

In diesem Lab werden wir untersuchen, wie man Legenden in Matplotlib erstellt und anpasst. Legenden werden verwendet, um die Bedeutung der Elemente in einem Diagramm zu erklären, einschließlich von Linien, Balken und Markern. Wir werden demonstrieren, wie man Legenden für bestimmte Linien, komplexe Beschriftungen und komplexere Diagramme erstellt. Schließlich werden wir zeigen, wie man benutzerdefinierte Klassen schreibt, um Legenden zu stylisieren.

VM-Tipps

Nachdem die VM gestartet ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Legende für bestimmte Linien erstellen

In diesem Schritt werden wir eine Legende für bestimmte Linien erstellen.

## Import notwendige Bibliotheken
import matplotlib.pyplot as plt
import numpy as np

## Definiere Daten für das Diagramm
t1 = np.arange(0.0, 2.0, 0.1)
t2 = np.arange(0.0, 2.0, 0.01)

## Erstelle ein Diagramm mit mehreren Linien
fig, ax = plt.subplots()
l1, = ax.plot(t2, np.exp(-t2))
l2, l3 = ax.plot(t2, np.sin(2 * np.pi * t2), '--o', t1, np.log(1 + t1), '.')
l4, = ax.plot(t2, np.exp(-t2) * np.sin(2 * np.pi * t2),'s-.')

## Erstelle eine Legende für zwei der Linien
ax.legend((l2, l4), ('oszillierend', 'gedämpft'), loc='upper right', shadow=True)

## Füge Beschriftungen und Titel zum Diagramm hinzu
ax.set_xlabel('Zeit')
ax.set_ylabel('Spannung')
ax.set_title('Gedämpfte Schwingung')

## Zeige das Diagramm an
plt.show()

Komplexere Beschriftungen plotten

In diesem Schritt werden wir komplexere Beschriftungen plotten.

## Definiere Daten für das Diagramm
x = np.linspace(0, 1)

## Erstelle ein Diagramm mit mehreren Linien
fig, (ax0, ax1) = plt.subplots(2, 1)
for n in range(1, 5):
    ax0.plot(x, x**n, label=f"{n=}")

## Erstelle eine Legende mit mehreren Spalten und einem Titel
leg = ax0.legend(loc="upper left", bbox_to_anchor=[0, 1],
                 ncols=2, shadow=True, title="Legende", fancybox=True)
leg.get_title().set_color("rot")

## Erstelle ein Diagramm mit mehreren Linien und Markern
ax1.plot(x, x**2, label="mehrere\nLinien")
half_pi = np.linspace(0, np.pi / 2)
ax1.plot(np.sin(half_pi), np.cos(half_pi), label=r"$\frac{1}{2}\pi$")
ax1.plot(x, 2**(x**2), label="$2^{x^2}$")

## Erstelle eine Legende mit einer Schatteneffekt
ax1.legend(shadow=True, fancybox=True)

## Zeige das Diagramm an
plt.show()

Legenden an komplexere Diagramme anfügen

In diesem Schritt werden wir Legenden an komplexere Diagramme anfügen.

## Definiere Daten für das Diagramm
fig, axs = plt.subplots(3, 1, layout="constrained")
top_ax, middle_ax, bottom_ax = axs

## Erstelle ein Balkendiagramm mit mehreren Balken
top_ax.bar([0, 1, 2], [0.2, 0.3, 0.1], width=0.4, label="Balken 1",
           align="center")
top_ax.bar([0.5, 1.5, 2.5], [0.3, 0.2, 0.2], color="rot", width=0.4,
           label="Balken 2", align="center")
top_ax.legend()

## Erstelle ein Fehlerbalkendiagramm mit mehreren Fehlern
middle_ax.errorbar([0, 1, 2], [2, 3, 1], xerr=0.4, fmt="s", label="test 1")
middle_ax.errorbar([0, 1, 2], [3, 2, 4], yerr=0.3, fmt="o", label="test 2")
middle_ax.errorbar([0, 1, 2], [1, 1, 3], xerr=0.4, yerr=0.3, fmt="^",
                   label="test 3")
middle_ax.legend()

## Erstelle ein Stabdiagramm mit einer Legende
bottom_ax.stem([0.3, 1.5, 2.7], [1, 3.6, 2.7], label="Stabtest")
bottom_ax.legend()

## Zeige das Diagramm an
plt.show()

Legendentext mit mehr als einem Legendenzeichen erstellen

In diesem Schritt werden wir Legendentext mit mehr als einem Legendenzeichen erstellen.

## Definiere Daten für das Diagramm
fig, (ax1, ax2) = plt.subplots(2, 1, layout='constrained')
p1 = ax1.scatter([1], [5], c='r', marker='s', s=100)
p2 = ax1.scatter([3], [2], c='b', marker='o', s=100)
p3, = ax1.plot([1, 5], [4, 4],'m-d')

## Erstelle eine Legende mit zwei Zeichen für einen Eintrag
l = ax1.legend([(p1, p3), p2], ['zwei Zeichen', 'ein Zeichen'], scatterpoints=1,
               numpoints=1, handler_map={tuple: HandlerTuple(ndivide=None)})

## Erstelle zwei Balkendiagramme übereinander und ändere den Abstand zwischen den Legendenzeichen
x_left = [1, 2, 3]
y_pos = [1, 3, 2]
y_neg = [2, 1, 4]
rneg = ax2.bar(x_left, y_neg, width=0.5, color='w', hatch='///', label='-1')
rpos = ax2.bar(x_left, y_pos, width=0.5, color='k', label='+1')

## Behandle jeden Legendentext unterschiedlich, indem du spezifische `HandlerTuple`s verwendest
l = ax2.legend([(rpos, rneg), (rneg, rpos)], ['pad!=0', 'pad=0'],
               handler_map={(rpos, rneg): HandlerTuple(ndivide=None),
                            (rneg, rpos): HandlerTuple(ndivide=None, pad=0.)})

## Zeige das Diagramm an
plt.show()

Benutzereigene Klassen schreiben, um Legenden zu stylisieren

In diesem Schritt werden wir benutzereigene Klassen schreiben, um Legenden zu stylisieren.

## Definiere Daten für das Diagramm
class HandlerDashedLines(HandlerLineCollection):
    """
    Benutzerspezifischer Handler für LineCollection-Instanzen.
    """
    def create_artists(self, legend, orig_handle,
                       xdescent, ydescent, width, height, fontsize, trans):
        ## ermittle, wie viele Linien es gibt
        numlines = len(orig_handle.get_segments())
        xdata, xdata_marker = self.get_xdata(legend, xdescent, ydescent,
                                             width, height, fontsize)
        leglines = []
        ## teile den vertikalen Raum, in dem die Linien platziert werden,
        ## in gleich große Teile basierend auf der Anzahl der Linien auf
        ydata = np.full_like(xdata, height / (numlines + 1))
        ## für jede Linie erzeuge die Linie an der richtigen Position
        ## und setze das Strichelduster
        for i in range(numlines):
            legline = Line2D(xdata, ydata * (numlines - i) - ydescent)
            self.update_prop(legline, orig_handle, legend)
            ## setze Farbe, Strichelduster und Linienstärke auf die
            ## der Linien in der LineCollection
            versuche:
                color = orig_handle.get_colors()[i]
            außer:
                color = orig_handle.get_colors()[0]
            versuche:
                dashes = orig_handle.get_dashes()[i]
            außer:
                dashes = orig_handle.get_dashes()[0]
            versuche:
                lw = orig_handle.get_linewidths()[i]
            außer:
                lw = orig_handle.get_linewidths()[0]
            wenn das zweite Element von dashes nicht None ist:
                legline.set_dashes(dashes[1])
            legline.set_color(color)
            legline.set_transform(trans)
            legline.set_linewidth(lw)
            leglines.append(legline)
        return leglines

## Erstelle ein Diagramm mit mehreren Linien
x = np.linspace(0, 5, 100)
fig, ax = plt.subplots()
colors = plt.rcParams['axes.prop_cycle'].by_key()['color'][:5]
styles = ['solid', 'dashed', 'dashed', 'dashed','solid']
for i, color, style in zip(range(5), colors, styles):
    ax.plot(x, np.sin(x) -.1 * i, c=color, ls=style)

## Erstelle Proxy-Künstler und eine Legende
line = [[(0, 0)]]
lc = mcol.LineCollection(5 * line, linestyles=styles, colors=colors)
ax.legend([lc], ['multi-line'], handler_map={type(lc): HandlerDashedLines()},
          handlelength=2.5, handleheight=3)

## Zeige das Diagramm an
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Matplotlib Legenden erstellt und anpasst. Wir haben gezeigt, wie man Legenden für bestimmte Linien, komplexe Beschriftungen und komplexere Diagramme erstellt. Wir haben auch gezeigt, wie man benutzerdefinierte Klassen schreibt, um Legenden zu stylisieren. Legenden sind ein wichtiger Bestandteil jedes Diagramms, und das Verständnis, wie man sie erstellt und anpasst, ist unerlässlich für die Erstellung effektiver Visualisierungen.