Erstellen Sie atemberaubende Bandkästchendiagramme mit Matplotlib

Einführung

Matplotlib ist eine beliebte Datenvisualisierungsbibliothek für Python. In diesem Tutorial wird Ihnen die Erstellung eines Bandkästchen-Diagramms gezeigt, eine einzigartige Methode, um Daten zu visualisieren. Ein Bandkästchen-Diagramm ist ein Stapelsäulendiagramm, bei dem jeder Balken "bandartig" ist und ein Farbverlauf hat.

Tipps für die virtuelle Maschine

Nachdem der Start der virtuellen Maschine 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 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.

Bibliotheken importieren und Daten laden

In diesem Schritt werden wir die erforderlichen Bibliotheken importieren und die Daten laden.

import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cbook
from matplotlib import colors as mcolors
from matplotlib.image import AxesImage
from matplotlib.transforms import Bbox, BboxTransformTo, TransformedBbox

Die RibbonBox-Klasse erstellen

In diesem Schritt werden wir die RibbonBox-Klasse erstellen, die verwendet werden wird, um die Farbverläufe für die Bandkästchen zu erstellen.

class RibbonBox:
    ## Lade das Bandkästchen-Bild
    original_image = plt.imread(cbook.get_sample_data("Minduka_Present_Blue_Pack.png"))
    cut_location = 70
    b_and_h = original_image[:, :, 2:3]
    color = original_image[:, :, 2:3] - original_image[:, :, 0:1]
    alpha = original_image[:, :, 3:4]
    nx = original_image.shape[1]

    def __init__(self, color):
        rgb = mcolors.to_rgb(color)
        self.im = np.dstack([self.b_and_h - self.color * (1 - np.array(rgb)), self.alpha])

    def get_stretched_image(self, stretch_factor):
        stretch_factor = max(stretch_factor, 1)
        ny, nx, nch = self.im.shape
        ny2 = int(ny*stretch_factor)
        return np.vstack([self.im[:self.cut_location],
                          np.broadcast_to(self.im[self.cut_location], (ny2 - ny, nx, nch)),
                          self.im[self.cut_location:]])

Die RibbonBoxImage-Klasse erstellen

In diesem Schritt werden wir die RibbonBoxImage-Klasse erstellen, die verwendet werden wird, um die tatsächlichen Bandkästchen zu erstellen.

class RibbonBoxImage(AxesImage):
    zorder = 1

    def __init__(self, ax, bbox, color, *, extent=(0, 1, 0, 1), **kwargs):
        super().__init__(ax, extent=extent, **kwargs)
        self._bbox = bbox
        self._ribbonbox = RibbonBox(color)
        self.set_transform(BboxTransformTo(bbox))

    def draw(self, renderer, *args, **kwargs):
        stretch_factor = self._bbox.height / self._bbox.width

        ny = int(stretch_factor*self._ribbonbox.nx)
        if self.get_array() is None or self.get_array().shape[0]!= ny:
            arr = self._ribbonbox.get_stretched_image(stretch_factor)
            self.set_array(arr)

        super().draw(renderer, *args, **kwargs)

Das Diagramm erstellen

In diesem Schritt werden wir das tatsächliche Diagramm erstellen, indem wir die RibbonBoxImage-Klasse verwenden, um die Bandkästchen zu erstellen.

def main():
    fig, ax = plt.subplots()

    years = np.arange(2004, 2009)
    heights = [7900, 8100, 7900, 6900, 2800]
    box_colors = [(0.8, 0.2, 0.2),
                  (0.2, 0.8, 0.2),
                  (0.2, 0.2, 0.8),
                  (0.7, 0.5, 0.8),
                  (0.3, 0.8, 0.7)]

    for year, h, bc in zip(years, heights, box_colors):
        bbox0 = Bbox.from_extents(year - 0.4, 0., year + 0.4, h)
        bbox = TransformedBbox(bbox0, ax.transData)
        ax.add_artist(RibbonBoxImage(ax, bbox, bc, interpolation="bicubic"))
        ax.annotate(str(h), (year, h), va="bottom", ha="center")

    ax.set_xlim(years[0] - 0.5, years[-1] + 0.5)
    ax.set_ylim(0, 10000)

    ## Create a background gradient
    background_gradient = np.zeros((2, 2, 4))
    background_gradient[:, :, :3] = [1, 1, 0]
    background_gradient[:, :, 3] = [[0.1, 0.3], [0.3, 0.5]]
    ax.imshow(background_gradient, interpolation="bicubic", zorder=0.1,
              extent=(0, 1, 0, 1), transform=ax.transAxes, aspect="auto")

    plt.show()

main()

Das Diagramm verstehen

In diesem Schritt werden wir das Diagramm besprechen, das wir erstellt haben. Das Diagramm besteht aus übereinander gestapelten Bandkästchen, die einen Balkendiagramm bilden. Die Höhe jedes Bandkastens entspricht einem Wert in der Datenmenge. Die Bandkästchen haben ein Farbverlaufsschema, das sie visuell ansprechend macht.

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie man ein Bandkästchendiagramm mit Matplotlib erstellt. Wir haben die RibbonBox- und RibbonBoxImage-Klassen erstellt, um die Farbverläufe und die tatsächlichen Bandkästchen zu erstellen. Anschließend haben wir diese Klassen verwendet, um das Diagramm zu erstellen, das aus übereinander gestapelten Bandkästchen besteht, um ein Balkendiagramm zu bilden.

Matplotlib Bandkästchen