Matplotlib Floating Axes

Einführung

In diesem Lab werden wir lernen, wie man das floating_axes-Modul von Matplotlib verwendet, um benutzerdefinierte Diagramme mit nicht-rectangularer Form zu erstellen. Dieses Modul ist nützlich, wenn wir Daten auf nicht-cartesischen Koordinatensystemen wie z. B. Polarkoordinaten- oder logarithmischen Diagrammen darstellen möchten. Wir werden demonstrieren, wie man einen Streudiagramm, einen Balkendiagramm und einen Sektordiagramm mit unterschiedlichen Koordinatensystemen erstellt.

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 während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Importieren der erforderlichen Bibliotheken

Zunächst müssen wir die erforderlichen Bibliotheken importieren. Wir werden Matplotlib, NumPy und einige Module aus mpl_toolkits.axisartist und mpl_toolkits.axisartist.grid_finder verwenden.

import matplotlib.pyplot as plt
import numpy as np

from matplotlib.projections import PolarAxes
from matplotlib.transforms import Affine2D
import mpl_toolkits.axisartist.angle_helper as angle_helper
import mpl_toolkits.axisartist.floating_axes as floating_axes
from mpl_toolkits.axisartist.grid_finder import (DictFormatter, FixedLocator,
                                                 MaxNLocator)

Erstellen eines einfachen Diagramms mit beweglichen Achsen

In diesem Schritt werden wir ein einfaches Diagramm mit beweglichen Achsen mit GridHelperCurveLinear erstellen. Wir werden ein Streudiagramm und ein Balkendiagramm mit einer nicht-rectangularen Form erstellen.

def setup_axes1(fig, rect):
    tr = Affine2D().scale(2, 1).rotate_deg(30)

    grid_helper = floating_axes.GridHelperCurveLinear(
        tr, extremes=(-0.5, 3.5, 0, 4),
        grid_locator1=MaxNLocator(nbins=4),
        grid_locator2=MaxNLocator(nbins=4))

    ax1 = fig.add_subplot(
        rect, axes_class=floating_axes.FloatingAxes, grid_helper=grid_helper)
    ax1.grid()

    aux_ax = ax1.get_aux_axes(tr)

    return ax1, aux_ax

fig = plt.figure(figsize=(8, 4))
fig.subplots_adjust(wspace=0.3, left=0.05, right=0.95)

ax1, aux_ax1 = setup_axes1(fig, 131)
aux_ax1.bar([0, 1, 2, 3], [3, 2, 1, 3])

Erstellen eines Polardiagramms

In diesem Schritt werden wir ein Polardiagramm mit GridHelperCurveLinear erstellen. Wir werden ein Streudiagramm mit einer nicht-rectangularen Form erstellen.

def setup_axes2(fig, rect):
    tr = PolarAxes.PolarTransform()

    pi = np.pi
    angle_ticks = [(0, r"$0$"),
                   (.25*pi, r"$\frac{1}{4}\pi$"),
                   (.5*pi, r"$\frac{1}{2}\pi$")]
    grid_locator1 = FixedLocator([v for v, s in angle_ticks])
    tick_formatter1 = DictFormatter(dict(angle_ticks))

    grid_locator2 = MaxNLocator(2)

    grid_helper = floating_axes.GridHelperCurveLinear(
        tr, extremes=(.5*pi, 0, 2, 1),
        grid_locator1=grid_locator1,
        grid_locator2=grid_locator2,
        tick_formatter1=tick_formatter1,
        tick_formatter2=None)

    ax1 = fig.add_subplot(
        rect, axes_class=floating_axes.FloatingAxes, grid_helper=grid_helper)
    ax1.grid()

    aux_ax = ax1.get_aux_axes(tr)

    aux_ax.patch = ax1.patch
    ax1.patch.zorder = 0.9

    return ax1, aux_ax

ax2, aux_ax2 = setup_axes2(fig, 132)
theta = np.random.rand(10)*.5*np.pi
radius = np.random.rand(10) + 1.
aux_ax2.scatter(theta, radius)

Erstellen eines Sektordiagramms

In diesem Schritt werden wir ein Sektordiagramm mit GridHelperCurveLinear erstellen. Wir werden ein Streudiagramm mit einer nicht-rectangularen Form erstellen.

def setup_axes3(fig, rect):
    tr_rotate = Affine2D().translate(-95, 0)
    tr_scale = Affine2D().scale(np.pi/180., 1.)
    tr = tr_rotate + tr_scale + PolarAxes.PolarTransform()

    grid_locator1 = angle_helper.LocatorHMS(4)
    tick_formatter1 = angle_helper.FormatterHMS()

    grid_locator2 = MaxNLocator(3)

    ra0, ra1 = 8.*15, 14.*15
    cz0, cz1 = 0, 14000
    grid_helper = floating_axes.GridHelperCurveLinear(
        tr, extremes=(ra0, ra1, cz0, cz1),
        grid_locator1=grid_locator1,
        grid_locator2=grid_locator2,
        tick_formatter1=tick_formatter1,
        tick_formatter2=None)

    ax1 = fig.add_subplot(
        rect, axes_class=floating_axes.FloatingAxes, grid_helper=grid_helper)

    ax1.axis["left"].set_axis_direction("bottom")
    ax1.axis["right"].set_axis_direction("top")

    ax1.axis["bottom"].set_visible(False)
    ax1.axis["top"].set_axis_direction("bottom")
    ax1.axis["top"].toggle(ticklabels=True, label=True)
    ax1.axis["top"].major_ticklabels.set_axis_direction("top")
    ax1.axis["top"].label.set_axis_direction("top")

    ax1.axis["left"].label.set_text(r"cz [km$^{-1}$]")
    ax1.axis["top"].label.set_text(r"$\alpha_{1950}$")
    ax1.grid()

    aux_ax = ax1.get_aux_axes(tr)

    aux_ax.patch = ax1.patch
    ax1.patch.zorder = 0.9

    return ax1, aux_ax

ax3, aux_ax3 = setup_axes3(fig, 133)
theta = (8 + np.random.rand(10)*(14 - 8))*15.
radius = np.random.rand(10)*14000.
aux_ax3.scatter(theta, radius)

Anzeigen des Diagramms

Schließlich müssen wir das Diagramm mit der show()-Funktion von Matplotlib anzeigen.

plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man das floating_axes-Modul von Matplotlib verwendet, um benutzerdefinierte Diagramme mit nicht-rectangularer Form zu erstellen. Wir haben ein Streudiagramm, ein Balkendiagramm und ein Sektordiagramm mit unterschiedlichen Koordinatensystemen erstellt. Wir haben GridHelperCurveLinear verwendet, um die erforderlichen Transformationen zu erstellen, FixedLocator und MaxNLocator, um die Gitternetzlinien festzulegen, und DictFormatter und FormatterHMS, um die Skalenmarkierungen zu formatieren.