Matplotlib benutzerdefinierte Einheiten

Einführung

Matplotlib ist eine Diagrammbibliothek für die Programmiersprache Python. Es bietet eine objektorientierte Schnittstelle zur Einbettung von Diagrammen in Anwendungen mit allgemeinen GUI-Toolkits wie Tkinter, wxPython, Qt oder GTK. Matplotlib ermöglicht es Entwicklern, eine Vielzahl von statischen, animierten und interaktiven Visualisierungen in Python zu erstellen.

In diesem Lab werden wir lernen, wie man in Matplotlib benutzerdefinierte Maßeinheiten erstellt und Daten mit diesen benutzerdefinierten Maßeinheiten darstellt.

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 nutzen.

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.

Bibliotheken importieren

Im ersten Schritt müssen wir die erforderlichen Bibliotheken importieren - matplotlib.pyplot, numpy, matplotlib.ticker und matplotlib.units.

import matplotlib.pyplot as plt
import numpy as np
import matplotlib.ticker as ticker
import matplotlib.units as units

Erstellen einer benutzerdefinierten Einheitsklasse

In diesem Schritt werden wir eine benutzerdefinierte Einheitsklasse - Foo - erstellen. Diese Klasse wird die Umwandlung und verschiedene Tick-Formatierungen je nach "Einheit" unterstützen. Hierbei ist die "Einheit" einfach ein skalarer Umrechnungsfaktor.

class Foo:
    def __init__(self, val, unit=1.0):
        self.unit = unit
        self._val = val * unit

    def value(self, unit):
        if unit is None:
            unit = self.unit
        return self._val / unit

Erstellen einer Konverterklasse

In diesem Schritt werden wir eine Konverterklasse - FooConverter - erstellen. Diese Klasse wird drei statische Methoden definieren - axisinfo, convert und default_units.

class FooConverter(units.ConversionInterface):
    @staticmethod
    def axisinfo(unit, axis):
        """Gibt die Foo AxisInfo zurück."""
        if unit == 1.0 oder unit == 2.0:
            return units.AxisInfo(
                majloc=ticker.IndexLocator(8, 0),
                majfmt=ticker.FormatStrFormatter("VAL: %s"),
                label='foo',
                )

        else:
            return None

    @staticmethod
    def convert(obj, unit, axis):
        """
        Konvertiert *obj* mit *unit*.

        Wenn *obj* eine Sequenz ist, gibt die konvertierte Sequenz zurück.
        """
        if np.iterable(obj):
            return [o.value(unit) for o in obj]
        else:
            return obj.value(unit)

    @staticmethod
    def default_units(x, axis):
        """Gibt die Standard-Einheit für *x* zurück oder None."""
        if np.iterable(x):
            for thisx in x:
                return thisx.unit
        else:
            return x.unit

Registrieren der benutzerdefinierten Einheitsklasse

In diesem Schritt werden wir die benutzerdefinierte Einheitsklasse - Foo - mit der Konverterklasse - FooConverter - registrieren.

units.registry[Foo] = FooConverter()

Erstellen von Datenpunkten

In diesem Schritt werden wir einige Datenpunkte mit der benutzerdefinierten Einheitsklasse - Foo - erstellen.

## create some Foos
x = [Foo(val, 1.0) for val in range(0, 50, 2)]
## and some arbitrary y data
y = [i for i in range(len(x))]

Erstellen von Diagrammen

In diesem Schritt werden wir zwei Diagramme erstellen - eines mit benutzerdefinierten Einheiten und das andere mit Standard-Einheiten.

fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle("Custom units")
fig.subplots_adjust(bottom=0.2)

## plot specifying units
ax2.plot(x, y, 'o', xunits=2.0)
ax2.set_title("xunits = 2.0")
plt.setp(ax2.get_xticklabels(), rotation=30, ha='right')

## plot without specifying units; will use the None branch for axisinfo
ax1.plot(x, y)  ## uses default units
ax1.set_title('default units')
plt.setp(ax1.get_xticklabels(), rotation=30, ha='right')

plt.show()

Führen Sie den Code aus

Im letzten Schritt führen Sie den Code aus, um die Diagramme mit benutzerdefinierten Einheiten zu erstellen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Matplotlib benutzerdefinierte Einheiten mit einer benutzerdefinierten Einheitsklasse und einer Konverterklasse erstellt. Anschließend haben wir zwei Diagramme erstellt - eines mit benutzerdefinierten Einheiten und das andere mit Standard-Einheiten - um die Verwendung dieser benutzerdefinierten Einheiten zu demonstrieren. Benutzerdefinierte Einheiten können nützlich sein, wenn es um komplexe Daten geht, für die eine benutzerdefinierte Skalierung oder Tick-Formatierung erforderlich ist.