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.