Radar-Charts mit Python Matplotlib erstellen

Einführung

In diesem Lab lernst du, wie du mithilfe der Matplotlib-Bibliothek in Python einen Radar-Chart erstellst. Ein Radar-Chart, auch als Spider- oder Sternen-Chart bekannt, ist eine graphische Methode, um multivariate Daten in Form eines zweidimensionalen Diagramms von drei oder mehr quantitativen Variablen darzustellen, die auf Achsen von einem gemeinsamen Punkt ausgehen. Es wird häufig verwendet, um verschiedene Produkte oder Lösungen auf der Grundlage mehrerer Faktoren zu vergleichen.

Tipps für die VM

Nachdem der Start der VM abgeschlossen ist, klicke in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal musst du 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 du bei der Lernphase Probleme hast, kannst du Labby gerne fragen. Gib nach der Sitzung Feedback, und wir werden das Problem für dich prompt beheben.

Bibliotheken importieren

Zunächst müssen wir die erforderlichen Bibliotheken importieren. Für diesen Tutorial sind Matplotlib und numpy erforderlich.

import matplotlib.pyplot as plt
import numpy as np

Definiere die Funktion für das Radar-Chart

Als nächstes definieren wir eine Funktion, um ein Radar-Chart zu erstellen. Diese Funktion nimmt zwei Argumente entgegen: num_vars und frame. num_vars ist die Anzahl der Variablen für das Radar-Chart, und frame gibt die Form des Rahmens an, der die Achsen umgibt.

from matplotlib.patches import Circle, RegularPolygon
from matplotlib.path import Path
from matplotlib.projections import register_projection
from matplotlib.projections.polar import PolarAxes
from matplotlib.spines import Spine
from matplotlib.transforms import Affine2D

def radar_factory(num_vars, frame='circle'):
    ## code for the function goes here

Definiere die Klassen RadarTransform und RadarAxes

Innerhalb der radar_factory-Funktion definieren wir die Klassen RadarTransform und RadarAxes. Diese Klassen werden verwendet, um das Radar-Chart zu erstellen.

class RadarTransform(PolarAxes.PolarTransform):
    ## code for the RadarTransform class goes here

class RadarAxes(PolarAxes):
    ## code for the RadarAxes class goes here

Definiere die fill- und plot-Methoden

Innerhalb der RadarAxes-Klasse definieren wir die fill- und plot-Methoden. Diese Methoden werden verwendet, um die Fläche innerhalb des Diagramms zu füllen und die Datenpunkte zu plotten, respective.

class RadarAxes(PolarAxes):
    ## code for the RadarAxes class goes here

    def fill(self, *args, closed=True, **kwargs):
        ## override the fill method
        return super().fill(closed=closed, *args, **kwargs)

    def plot(self, *args, **kwargs):
        ## override the plot method
        lines = super().plot(*args, **kwargs)
        for line in lines:
            self._close_line(line)

    def _close_line(self, line):
        ## helper method to close the line
        x, y = line.get_data()
        if x[0]!= x[-1]:
            x = np.append(x, x[0])
            y = np.append(y, y[0])
            line.set_data(x, y)

Definiere die Methoden set_varlabels, _gen_axes_patch und _gen_axes_spines

Innerhalb der RadarAxes-Klasse definieren wir auch die Methoden set_varlabels, _gen_axes_patch und _gen_axes_spines. Diese Methoden werden jeweils die Variablennamen festlegen, den Achsenausschnitt generieren und die Achsenkanten generieren.

class RadarAxes(PolarAxes):
    ## code for the RadarAxes class goes here

    def set_varlabels(self, labels):
        self.set_thetagrids(np.degrees(theta), labels)

    def _gen_axes_patch(self):
        if frame == 'circle':
            return Circle((0.5, 0.5), 0.5)
        elif frame == 'polygon':
            return RegularPolygon((0.5, 0.5), num_vars,
                                  radius=.5, edgecolor="k")
        else:
            raise ValueError("Unknown value for 'frame': %s" % frame)

    def _gen_axes_spines(self):
        if frame == 'circle':
            return super()._gen_axes_spines()
        elif frame == 'polygon':
            spine = Spine(axes=self,
                          spine_type='circle',
                          path=Path.unit_regular_polygon(num_vars))
            spine.set_transform(Affine2D().scale(.5).translate(.5,.5)
                                + self.transAxes)
            return {'polar': spine}
        else:
            raise ValueError("Unknown value for 'frame': %s" % frame)

Definiere die Beispiel-Daten

Jetzt definieren wir die Beispiel-Daten, die wir verwenden werden, um das Radar-Chart zu erstellen. Diese Daten stammen aus einer Studie zu den Schätzungen des Schadstoffquellprofils.

def example_data():
    data = [
        ['Sulfat', 'Nitrat', 'EC', 'OC1', 'OC2', 'OC3', 'OP', 'CO', 'O3'],
        ('Basecase', [
            [0.88, 0.01, 0.03, 0.03, 0.00, 0.06, 0.01, 0.00, 0.00],
            [0.07, 0.95, 0.04, 0.05, 0.00, 0.02, 0.01, 0.00, 0.00],
            [0.01, 0.02, 0.85, 0.19, 0.05, 0.10, 0.00, 0.00, 0.00],
            [0.02, 0.01, 0.07, 0.01, 0.21, 0.12, 0.98, 0.00, 0.00],
            [0.01, 0.01, 0.02, 0.71, 0.74, 0.70, 0.00, 0.00, 0.00]]),
        ('Mit CO', [
            [0.88, 0.02, 0.02, 0.02, 0.00, 0.05, 0.00, 0.05, 0.00],
            [0.08, 0.94, 0.04, 0.02, 0.00, 0.01, 0.12, 0.04, 0.00],
            [0.01, 0.01, 0.79, 0.10, 0.00, 0.05, 0.00, 0.31, 0.00],
            [0.00, 0.02, 0.03, 0.38, 0.31, 0.31, 0.00, 0.59, 0.00],
            [0.02, 0.02, 0.11, 0.47, 0.69, 0.58, 0.88, 0.00, 0.00]]),
        ('Mit O3', [
            [0.89, 0.01, 0.07, 0.00, 0.00, 0.05, 0.00, 0.00, 0.03],
            [0.07, 0.95, 0.05, 0.04, 0.00, 0.02, 0.12, 0.00, 0.00],
            [0.01, 0.02, 0.86, 0.27, 0.16, 0.19, 0.00, 0.00, 0.00],
            [0.01, 0.03, 0.00, 0.32, 0.29, 0.27, 0.00, 0.00, 0.95],
            [0.02, 0.00, 0.03, 0.37, 0.56, 0.47, 0.87, 0.00, 0.00]]),
        ('CO & O3', [
            [0.87, 0.01, 0.08, 0.00, 0.00, 0.04, 0.00, 0.00, 0.01],
            [0.09, 0.95, 0.02, 0.03, 0.00, 0.01, 0.13, 0.06, 0.00],
            [0.01, 0.02, 0.71, 0.24, 0.13, 0.16, 0.00, 0.50, 0.00],
            [0.01, 0.03, 0.00, 0.28, 0.24, 0.23, 0.00, 0.44, 0.88],
            [0.02, 0.00, 0.18, 0.45, 0.64, 0.55, 0.86, 0.00, 0.16]])
    ]
    return data

Setze die Anzahl der Variablen und berechne die Achswinkel

Wir setzen jetzt die Anzahl der Variablen und berechnen die gleichmäßig verteilten Achswinkel mit numpy.

N = 9
theta = radar_factory(N, frame='polygon')

Erzeuge das Radar-Chart

Schließlich können wir das Radar-Chart mit den Beispiel-Daten und der RadarAxes-Klasse erstellen.

data = example_data()
spoke_labels = data.pop(0)

fig, axs = plt.subplots(figsize=(9, 9), nrows=2, ncols=2,
                        subplot_kw=dict(projection='radar'))
fig.subplots_adjust(wspace=0.25, hspace=0.20, top=0.85, bottom=0.05)

colors = ['b', 'r', 'g','m', 'y']
for ax, (title, case_data) in zip(axs.flat, data):
    ax.set_rgrids([0.2, 0.4, 0.6, 0.8])
    ax.set_title(title, weight='bold', size='medium', position=(0.5, 1.1),
                 horizontalalignment='center', verticalalignment='center')
    for d, color in zip(case_data, colors):
        ax.plot(theta, d, color=color)
        ax.fill(theta, d, facecolor=color, alpha=0.25, label='_nolegend_')
    ax.set_varlabels(spoke_labels)

labels = ('Factor 1', 'Factor 2', 'Factor 3', 'Factor 4', 'Factor 5')
legend = axs[0, 0].legend(labels, loc=(0.9,.95),
                          labelspacing=0.1, fontsize='small')

fig.text(0.5, 0.965, '5-Factor Solution Profiles Across Four Scenarios',
         horizontalalignment='center', color='black', weight='bold',
         size='large')

plt.show()

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie mit der Matplotlib-Bibliothek in Python ein Radar-Chart erstellen. Ein Radar-Chart ist eine graphische Methode, um multivariate Daten in Form eines zweidimensionalen Diagramms von drei oder mehr quantitativen Variablen darzustellen, die auf Achsen ausgehend von demselben Punkt dargestellt werden. Es wird häufig verwendet, um verschiedene Produkte oder Lösungen auf der Grundlage mehrerer Faktoren zu vergleichen.