Matplotlib Fill Between

Einführung

Matplotlib ist eine Datenvisualisierungsbibliothek in der Programmiersprache Python. Es wird verwendet, um statische, animierte und interaktive Visualisierungen in Python zu erstellen. In diesem Lab werden Sie lernen, wie Sie die fill_between-Funktion aus Matplotlib verwenden, um den Bereich zwischen zwei Linien zu füllen.

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 öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von 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.

Skills Graph

Grundlegender Gebrauch

Die fill_between-Funktion kann verwendet werden, um den Bereich zwischen zwei Linien zu füllen. Die Parameter y1 und y2 können Skalare sein, was eine horizontale Grenze bei den angegebenen y-Werten angibt. Wenn nur y1 angegeben wird, wird y2 standardmäßig auf 0 gesetzt.

x = np.arange(0.0, 2, 0.01)
y1 = np.sin(2 * np.pi * x)
y2 = 0.8 * np.sin(4 * np.pi * x)

fig, (ax1, ax2, ax3) = plt.subplots(3, 1, sharex=True, figsize=(6, 6))

ax1.fill_between(x, y1)
ax1.set_title('fill between y1 and 0')

ax2.fill_between(x, y1, 1)
ax2.set_title('fill between y1 and 1')

ax3.fill_between(x, y1, y2)
ax3.set_title('fill between y1 and y2')
ax3.set_xlabel('x')
fig.tight_layout()

Konfidenzintervalle

Eine häufige Anwendung von fill_between ist die Darstellung von Konfidenzintervallen. fill_between verwendet die Farben des Farbzyklus als Füllfarbe. Es ist daher oft ratsam, die Farbe zu verblassen, indem man die Fläche mithilfe von alpha halbtransparent macht.

N = 21
x = np.linspace(0, 10, 11)
y = [3.9, 4.4, 10.8, 10.3, 11.2, 13.1, 14.1,  9.9, 13.9, 15.1, 12.5]

## fit a linear curve and estimate its y-values and their error.
a, b = np.polyfit(x, y, deg=1)
y_est = a * x + b
y_err = x.std() * np.sqrt(1/len(x) +
                          (x - x.mean())**2 / np.sum((x - x.mean())**2))

fig, ax = plt.subplots()
ax.plot(x, y_est, '-')
ax.fill_between(x, y_est - y_err, y_est + y_err, alpha=0.2)
ax.plot(x, y, 'o', color='tab:brown')

Selektives Füllen horizontaler Bereiche

Der Parameter where ermöglicht es, die x-Bereiche anzugeben, die gefüllt werden sollen. Es ist ein boolescher Array der gleichen Größe wie x. Nur die x-Bereiche von aufeinanderfolgenden True-Sequenzen werden gefüllt. Folglich wird der Bereich zwischen benachbarten True- und False-Werten niemals gefüllt. Es wird daher empfohlen, interpolate=True festzulegen, es sei denn, die x-Abstände der Datenpunkte sind genug fein, sodass der obige Effekt nicht auffällt.

x = np.array([0, 1, 2, 3])
y1 = np.array([0.8, 0.8, 0.2, 0.2])
y2 = np.array([0, 0, 1, 1])

fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)

ax1.set_title('interpolation=False')
ax1.plot(x, y1, 'o--')
ax1.plot(x, y2, 'o--')
ax1.fill_between(x, y1, y2, where=(y1 > y2), color='C0', alpha=0.3)
ax1.fill_between(x, y1, y2, where=(y1 < y2), color='C1', alpha=0.3)

ax2.set_title('interpolation=True')
ax2.plot(x, y1, 'o--')
ax2.plot(x, y2, 'o--')
ax2.fill_between(x, y1, y2, where=(y1 > y2), color='C0', alpha=0.3,
                 interpolate=True)
ax2.fill_between(x, y1, y2, where=(y1 <= y2), color='C1', alpha=0.3,
                 interpolate=True)
fig.tight_layout()

Selektives Markieren horizontaler Bereiche über die gesamte Achse

Der gleiche Auswahlmechanismus kann angewendet werden, um die volle vertikale Höhe der Achse zu füllen. Um unabhängig von den y-Grenzen zu sein, fügen wir eine Transformation hinzu, die die x-Werte in Datenkoordinaten und die y-Werte in Achsenkoordinaten interpretiert. Das folgende Beispiel markiert die Bereiche, in denen die y-Daten über einem angegebenen Schwellenwert liegen.

fig, ax = plt.subplots()
x = np.arange(0, 4 * np.pi, 0.01)
y = np.sin(x)
ax.plot(x, y, color='black')

threshold = 0.75
ax.axhline(threshold, color='green', lw=2, alpha=0.7)
ax.fill_between(x, 0, 1, where=y > threshold,
                color='green', alpha=0.5, transform=ax.get_xaxis_transform())

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie die fill_between-Funktion aus Matplotlib verwenden, um den Bereich zwischen zwei Linien zu füllen. Sie haben auch gelernt, wie Sie horizontalen Bereiche selektiv füllen und horizontale Bereiche über die gesamte Achse markieren.