Matplotlib Pcolor Visualisierungstutorial

Einführung

In diesem Tutorial erhalten Sie eine Einführung in die Verwendung von Pcolor in Matplotlib. Mit Pcolor können Sie 2D-Bildplots generieren, und wir werden Ihnen zeigen, wie es in Matplotlib eingesetzt wird.

Tipps für die VM

Nachdem der VM-Start abgeschlossen 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 der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby um Hilfe bitten. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie sofort beheben.

Skills Graph

Einfaches Pcolor-Demo

Der erste Schritt besteht darin, ein einfaches Pcolor-Demo zu erstellen. Dies wird Ihnen zeigen, wie ein grundlegender Pcolor-Plot erstellt wird.

Z = np.random.rand(6, 10)

fig, (ax0, ax1) = plt.subplots(2, 1)

c = ax0.pcolor(Z)
ax0.set_title('standardmäßig: keine Kanten')

c = ax1.pcolor(Z, edgecolors='k', linewidths=4)
ax1.set_title('dicke Kanten')

fig.tight_layout()
plt.show()

Vergleich von Pcolor mit ähnlichen Funktionen

Der zweite Schritt besteht darin, Pcolor mit ähnlichen Funktionen wie Pcolormesh, Imshow und Pcolorfast zu vergleichen. Dies wird Ihnen helfen, die Unterschiede zwischen diesen Funktionen zu verstehen und wann Sie jede von ihnen verwenden sollten.

## Verkleinern Sie diese Werte, um die Auflösung zu erhöhen
dx, dy = 0.15, 0.05

## Generieren Sie 2 2D-Gitter für die x- und y-Begrenzungen
y, x = np.mgrid[-3:3+dy:dy, -3:3+dx:dx]
z = (1 - x/2 + x**5 + y**3) * np.exp(-x**2 - y**2)
## x und y sind die Begrenzungen, daher sollte z der Wert *innerhalb* dieser Begrenzungen sein.
## Entfernen Sie daher den letzten Wert aus dem z-Array.
z = z[:-1, :-1]
z_min, z_max = -abs(z).max(), abs(z).max()

fig, axs = plt.subplots(2, 2)

ax = axs[0, 0]
c = ax.pcolor(x, y, z, cmap='RdBu', vmin=z_min, vmax=z_max)
ax.set_title('pcolor')
fig.colorbar(c, ax=ax)

ax = axs[0, 1]
c = ax.pcolormesh(x, y, z, cmap='RdBu', vmin=z_min, vmax=z_max)
ax.set_title('pcolormesh')
fig.colorbar(c, ax=ax)

ax = axs[1, 0]
c = ax.imshow(z, cmap='RdBu', vmin=z_min, vmax=z_max,
              extent=[x.min(), x.max(), y.min(), y.max()],
              interpolation='nearest', origin='lower', aspect='auto')
ax.set_title('Bild (nächstes, aspect="auto")')
fig.colorbar(c, ax=ax)

ax = axs[1, 1]
c = ax.pcolorfast(x, y, z, cmap='RdBu', vmin=z_min, vmax=z_max)
ax.set_title('pcolorfast')
fig.colorbar(c, ax=ax)

fig.tight_layout()
plt.show()

Pcolor mit logarithmischer Skala

Der dritte Schritt besteht darin, einen Pcolor-Plot mit logarithmischer Skala zu erstellen. Dies ist nützlich, wenn Sie Daten mit einem großen Wertebereich haben.

N = 100
X, Y = np.meshgrid(np.linspace(-3, 3, N), np.linspace(-2, 2, N))

## Ein niedriger Buckel mit einem Ausläufer.
## Braucht eine logarithmische Skala auf der z/Farbachse, damit wir sowohl den Buckel als auch den Ausläufer sehen.
## Eine lineare Skala zeigt nur den Ausläufer.
Z1 = np.exp(-X**2 - Y**2)
Z2 = np.exp(-(X * 10)**2 - (Y * 10)**2)
Z = Z1 + 50 * Z2

fig, (ax0, ax1) = plt.subplots(2, 1)

c = ax0.pcolor(X, Y, Z, shading='auto',
               norm=LogNorm(vmin=Z.min(), vmax=Z.max()), cmap='PuBu_r')
fig.colorbar(c, ax=ax0)

c = ax1.pcolor(X, Y, Z, cmap='PuBu_r', shading='auto')
fig.colorbar(c, ax=ax1)

plt.show()

Zusammenfassung

In diesem Tutorial haben wir Ihnen gezeigt, wie Sie Pcolor in Matplotlib verwenden. Wir haben mit einem einfachen Pcolor-Demo begonnen, verglichen dann Pcolor mit ähnlichen Funktionen wie Pcolormesh und Imshow. Schließlich haben wir einen Pcolor-Plot mit logarithmischer Skala erstellt.