Matplotlib Streudiagramme in Python — Vollständiger Leitfaden

Die scatter()-Funktion von Matplotlib ermöglicht es, die Beziehung zwischen zwei numerischen Variablen zu visualisieren, indem an jedem (x, y)-Datenpunkt ein Marker gesetzt wird. Anders als ein Liniendiagramm trifft ein Streudiagramm keine Annahme über Reihenfolge oder Kontinuität — jeder Punkt steht für sich allein. Das macht es zur bevorzugten Wahl beim Erkunden von Korrelationen, beim Erkennen von Clustern und beim Aufspüren von Ausreißern.

Dieses Kapitel deckt alles ab, vom ersten Streudiagramm bis zu professionellen Techniken: punktbezogene Farb- und Größenkodierung, Transparenz, Farbleisten, Mehrgruppen-Diagramme, Punktbeschriftungen und das Speichern publikationsreifer Dateien.

Stellen Sie vor dem Einstieg sicher, dass Matplotlib installiert ist:

pip install matplotlib

Falls Sie neu bei Matplotlib sind, lesen Sie zuerst die Kapitel Matplotlib-Einführung und Erste Schritte.

Wann ein Streudiagramm verwenden?

Verwenden Sie ein Streudiagramm, wenn:

Sie die Korrelation zwischen zwei numerischen Variablen erkunden möchten (Körpergröße vs. Gewicht, Lernstunden vs. Prüfungspunktzahl).
Sie Cluster erkennen müssen — Gruppen von Punkten, die natürlich zusammenliegen.
Sie Ausreißer identifizieren möchten — Punkte weit von der Hauptverteilung entfernt.
Sie eine dritte Variable durch Markergröße oder Farbe kodieren (ein „Blasendiagramm" ist ein Streudiagramm, bei dem die Größe einer dritten Variable entspricht).

Vermeiden Sie Streudiagramme, wenn eine Achse ungeordnete Kategorien darstellt — ein Balkendiagramm ist dort übersichtlicher. Für Trends über eine kontinuierliche geordnete Variable ist ein Liniendiagramm geeigneter.

Ein einfaches Streudiagramm erstellen

Übergeben Sie zwei gleichlange Sequenzen — x-Werte und y-Werte — an plt.scatter():

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y = [2, 4, 5, 4, 7, 8, 6, 9, 10, 12]

plt.scatter(x, y)

plt.title('Basic Scatter Plot')
plt.xlabel('X Values')
plt.ylabel('Y Values')

plt.tight_layout()
plt.show()

plt.tight_layout() verhindert das Abschneiden von Beschriftungen — machen Sie es zur Gewohnheit vor jedem show()- oder savefig()-Aufruf.

Markergröße anpassen

Der Parameter s steuert die Markergröße in Punkten zum Quadrat (Standard ist 20). Erhöhen Sie ihn, damit Punkte leichter zu sehen sind, besonders bei Präsentationen:

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5, 6, 7, 8]
y = [3, 1, 4, 1, 5, 9, 2, 6]

plt.scatter(x, y, s=120)

plt.title('Larger Markers')
plt.xlabel('X')
plt.ylabel('Y')
plt.tight_layout()
plt.show()

Sie können s auch eine Liste oder ein array übergeben, damit jeder Punkt seine eigene Größe erhält — so kodiert man eine dritte numerische Variable als Blasengröße:

import matplotlib.pyplot as plt

x      = [1, 2, 3, 4, 5]
y      = [5, 3, 6, 2, 7]
sizes  = [100, 300, 50, 400, 200]   # third variable encoded as bubble area

plt.scatter(x, y, s=sizes)

plt.title('Bubble Chart — size encodes a third variable')
plt.xlabel('X')
plt.ylabel('Y')
plt.tight_layout()
plt.show()

Markerfarbe anpassen

Eine einheitliche Farbe für alle Punkte

Übergeben Sie einen Farbnamen, einen Hex-String oder ein RGB-Tupel an c (oder color):

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 4, 1, 5, 3]

plt.scatter(x, y, s=100, c='steelblue')

plt.title('Single Color')
plt.xlabel('X')
plt.ylabel('Y')
plt.tight_layout()
plt.show()

Punktbezogene Farbe aus einer numerischen Variable

Die Übergabe eines arrays an c ordnet jeden Wert über die in cmap angegebene Farbkarte einer Farbe zu. Fügen Sie plt.colorbar() hinzu, um zu zeigen, was die Farben bedeuten:

import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(seed=42)
x      = rng.random(50)
y      = rng.random(50)
values = rng.random(50)          # third variable, e.g. intensity or temperature

scatter = plt.scatter(x, y, s=80, c=values, cmap='viridis')
plt.colorbar(scatter, label='Intensity')

plt.title('Color-Mapped Scatter Plot')
plt.xlabel('X')
plt.ylabel('Y')
plt.tight_layout()
plt.show()

'viridis' ist eine wahrnehmungsgleichmäßige Farbkarte, die in Graustufen lesbar und für farbenblinde Leser zugänglich ist. Weitere gute Optionen sind 'plasma', 'cividis' und 'coolwarm'.

Transparenz mit `alpha` steuern

Wenn viele Punkte überlappen, bilden sie einen undurchsichtigen Blob, der die wahre Dichte verbirgt. Setzen Sie alpha (0 = vollständig transparent, 1 = vollständig opak), um überlappende Strukturen sichtbar zu machen:

import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(seed=0)
x = rng.normal(loc=0, scale=1, size=300)
y = rng.normal(loc=0, scale=1, size=300)

plt.scatter(x, y, s=40, alpha=0.4)

plt.title('Transparent Markers Reveal Density (alpha=0.4)')
plt.xlabel('X')
plt.ylabel('Y')
plt.tight_layout()
plt.show()

Ein guter Ausgangspunkt ist alpha=0.4 bis 0.6. Passen Sie den Wert je nach Punktanzahl an.

Markerkanten gestalten

Verwenden Sie edgecolors, um jedem Marker einen Rahmen hinzuzufügen, und linewidths, um die Rahmendicke zu steuern. Das hilft, Punkte vor einem farbigen Hintergrund hervorzuheben:

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5, 6]
y = [3, 1, 4, 1, 5, 9]

plt.scatter(x, y, s=150, c='gold', edgecolors='black', linewidths=1.5)

plt.title('Markers with Edges')
plt.xlabel('X')
plt.ylabel('Y')
plt.tight_layout()
plt.show()

Übergeben Sie edgecolors='none', um Kanten vollständig zu entfernen (dies ist die Standardeinstellung für die meisten Farbkarten).

Mehrere Gruppen darstellen

Um Gruppen zu vergleichen, rufen Sie plt.scatter() einmal pro Gruppe auf und vergeben Sie ein Label. Matplotlib weist jedem Aufruf automatisch eine andere Standardfarbe zu:

import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(seed=7)

# Group A — centered around (2, 3)
ax_x = rng.normal(loc=2, scale=0.5, size=30)
ax_y = rng.normal(loc=3, scale=0.5, size=30)

# Group B — centered around (5, 6)
bx_x = rng.normal(loc=5, scale=0.5, size=30)
bx_y = rng.normal(loc=6, scale=0.5, size=30)

# Group C — centered around (8, 2)
cx_x = rng.normal(loc=8, scale=0.5, size=30)
cx_y = rng.normal(loc=2, scale=0.5, size=30)

plt.scatter(ax_x, ax_y, s=60, label='Group A')
plt.scatter(bx_x, bx_y, s=60, label='Group B')
plt.scatter(cx_x, cx_y, s=60, label='Group C')

plt.legend()
plt.title('Multi-Group Scatter Plot')
plt.xlabel('X')
plt.ylabel('Y')
plt.tight_layout()
plt.show()

Jeder scatter()-Aufruf wählt automatisch die nächste Farbe aus dem Standard-Farbzyklus. Übergeben Sie c='red' (oder eine beliebige Farbe), um dies zu überschreiben.

Einzelne Punkte beschriften

Verwenden Sie plt.annotate(), um bestimmte Punkte zu beschriften — nützlich zum Hervorheben von Ausreißern oder wichtigen Beobachtungen:

import matplotlib.pyplot as plt

cities = ['London', 'Berlin', 'Madrid', 'Rome', 'Paris']
population = [9.0, 3.7, 3.3, 2.8, 2.1]   # millions
area       = [1572, 892, 604, 1285, 105]   # km²

plt.scatter(area, population, s=100, c='steelblue', edgecolors='black', linewidths=0.8)

for i, city in enumerate(cities):
    plt.annotate(
        city,
        xy=(area[i], population[i]),
        xytext=(8, 4),                      # offset in points
        textcoords='offset points',
        fontsize=9,
    )

plt.title('European City Population vs. Area')
plt.xlabel('Area (km²)')
plt.ylabel('Population (millions)')
plt.tight_layout()
plt.show()

Das Muster xytext + textcoords='offset points' verschiebt das Label leicht, sodass es nicht direkt auf dem Marker sitzt.

Logarithmische Achsen verwenden

Wenn Daten mehrere Größenordnungen umspannen, komprimieren lineare Achsen die meisten Punkte in eine Ecke. Wechseln Sie mit plt.xscale('log') oder plt.yscale('log') zu einer logarithmischen Skala:

import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(seed=1)
x = np.logspace(1, 5, 60)            # 10¹ to 10⁵
y = x * rng.uniform(0.5, 2.0, 60)   # roughly proportional, with noise

plt.scatter(x, y, s=40, alpha=0.7)
plt.xscale('log')
plt.yscale('log')

plt.title('Log-Scale Scatter Plot')
plt.xlabel('X (log scale)')
plt.ylabel('Y (log scale)')
plt.tight_layout()
plt.show()

Beide Achsen umspannen nun gleichmäßige Intervalle von Zehnerpotenzen und verteilen die Daten gleichmäßig über die Plotfläche.

Eine Regressionslinie hinzufügen

Ein Streudiagramm zeigt einzelne Punkte; das Hinzufügen einer Trendlinie zeigt den Gesamttrend. Berechnen Sie Steigung und Achsenabschnitt mit np.polyfit():

import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(seed=3)
x = np.linspace(0, 10, 40)
y = 2.5 * x + rng.normal(scale=3, size=40)   # linear trend + noise

# Fit a degree-1 polynomial (straight line)
slope, intercept = np.polyfit(x, y, 1)
trend_line = slope * x + intercept

plt.scatter(x, y, s=50, label='Data points', alpha=0.7)
plt.plot(x, trend_line, color='red', linewidth=2, label=f'Trend (slope={slope:.2f})')

plt.legend()
plt.title('Scatter Plot with Regression Line')
plt.xlabel('X')
plt.ylabel('Y')
plt.tight_layout()
plt.show()

np.polyfit(x, y, 1) gibt [slope, intercept] für die bestangepasste Linie durch die Punkte zurück.

Ein Streudiagramm in eine Datei speichern

Verwenden Sie plt.savefig() anstelle von plt.show(), um das Diagramm auf die Festplatte zu schreiben. Rufen Sie es vor plt.show() auf — nach show() wird die Figure gelöscht:

import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(seed=9)
x = rng.random(60)
y = rng.random(60)

plt.scatter(x, y, s=60, alpha=0.6, c='teal', edgecolors='white', linewidths=0.5)
plt.title('Saved Scatter Plot')
plt.xlabel('X')
plt.ylabel('Y')
plt.tight_layout()

plt.savefig('scatter.png', dpi=150)   # PNG at 150 DPI
plt.savefig('scatter.pdf')             # vector PDF — best for publication
plt.show()

Häufige Formatoptionen: 'png' (Raster, Web), 'pdf' (Vektor, Publikation), 'svg' (Vektor, Web). Erhöhen Sie dpi auf 300 für druckqualitative Rasterbilder.

`scatter()` vs. `plot()` — Was sollte man verwenden?

Beide Funktionen können reine Marker-Plots erstellen, dienen aber unterschiedlichen Zwecken:

Merkmal	`plt.scatter()`	`plt.plot()`
Punktbezogene Größe (`s`)	Ja — array übergeben	Nein
Punktbezogene Farbe (`c`)	Ja — array übergeben	Nein (eine Farbe pro Aufruf)
Farbkarten-Unterstützung	Ja (`cmap`)	Begrenzt
Leistung bei großen Datensätzen	Langsamer	Schneller
Verbindungslinie	Nein	Ja

Verwenden Sie scatter(), wenn Sie punktbezogenes Styling benötigen (Farbe oder Größe variiert je nach Daten). Verwenden Sie plot(marker='o', linestyle='None') für einfache Marker-Plots bei großen Datensätzen, wo Geschwindigkeit wichtig ist. Weitere Markerstile finden Sie im Kapitel Matplotlib Markers.

Vollständiges Beispiel

Das folgende in sich geschlossene Skript kombiniert die nützlichsten Techniken — Farbzuordnung, Größenkodierung, Transparenz, eine Farbleiste und eine Legende:

import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(seed=42)

n = 80
x      = rng.standard_normal(n)
y      = 0.8 * x + rng.standard_normal(n) * 0.6   # correlated
sizes  = rng.uniform(30, 200, n)                   # bubble area
values = rng.random(n)                             # third variable for color

fig, ax = plt.subplots(figsize=(8, 5))

sc = ax.scatter(
    x, y,
    s=sizes,
    c=values,
    cmap='plasma',
    alpha=0.75,
    edgecolors='white',
    linewidths=0.5,
)

plt.colorbar(sc, ax=ax, label='Intensity')

ax.set_title('Comprehensive Scatter Plot Example', fontsize=13)
ax.set_xlabel('X Variable')
ax.set_ylabel('Y Variable (correlated)')
fig.tight_layout()
plt.savefig('scatter_complete.png', dpi=150)
plt.show()

Wichtige Punkte:

fig, ax = plt.subplots() liefert explizite Figure- und Axes-Objekte — die empfohlene Vorgehensweise für alles, was über einen schnellen Prototyp hinausgeht.
ax.scatter() auf einem Axes-Objekt verhält sich identisch zu plt.scatter().
plt.colorbar(sc, ax=ax, label='...') hängt die Farbleiste an die spezifischen Axes.

Best Practices

Zeigen Sie die Skala. Wenn Sie c mit einer Farbkarte verwenden, fügen Sie immer eine Farbleiste hinzu, damit Leser wissen, was die Farben bedeuten.
Vermeiden Sie Überzeichnung. Bei mehr als ~500 Punkten setzen Sie alpha < 1 oder wechseln zu einem 2-D-Histogramm (plt.hist2d()) oder einem Hexbin-Plot (plt.hexbin()).
Wählen Sie zugängliche Farbkarten. 'viridis', 'plasma' und 'cividis' sind wahrnehmungsgleichmäßig und farbenblindfreundlich. Vermeiden Sie 'jet' und 'rainbow'.
Beschriften Sie Achsen mit Einheiten. plt.xlabel('Größe (cm)') ist informativer als plt.xlabel('Größe').
Fügen Sie einen Titel hinzu, der die Erkenntnis formuliert. „Größe vs. Gewicht — positive Korrelation" ist nützlicher als „Streudiagramm".