Matplotlib-Liniendiagramme in Python — Vollständiger Leitfaden

Die plot()-Funktion von Matplotlib ist das Hauptwerkzeug für Liniendiagramme — Grafiken, die Datenpunkte mit einer durchgehenden Linie verbinden, um Trends über die Zeit oder entlang einer kontinuierlichen Variablen darzustellen. Dieses Kapitel behandelt alles von Ihrem ersten Sinus-Diagramm bis hin zu professionellen Details wie Annotationen, schattierten Bereichen und dem Speichern druckreifer Dateien.

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

pip install matplotlib

Wenn Sie neu in der Bibliothek sind, lesen Sie zuerst die Kapitel Matplotlib-Einführung und Erste Schritte.

Wann ein Liniendiagramm verwenden?

Verwenden Sie ein Liniendiagramm, wenn:

• Sie Trends über die Zeit zeigen möchten (Aktienkurse, Temperaturen über Monate, Trainingsverlust über Epochen).
• Die x-Achse eine kontinuierliche oder geordnete Variable darstellt (Zeit, Entfernung, Frequenz).
• Sie mehrere Reihen vergleichen möchten, die dieselbe x-Achse teilen.

Vermeiden Sie Liniendiagramme für ungeordnete Kategorien — dort ist ein Balkendiagramm klarer. Für die Beziehung zwischen zwei unabhängigen numerischen Variablen ohne implizite Reihenfolge empfiehlt sich stattdessen ein Streudiagramm.

Ein einfaches Liniendiagramm erstellen

Die minimale Signatur lautet plt.plot(x, y). Sowohl x als auch y können Python-Listen oder NumPy-arrays sein.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)   # 100 evenly-spaced points from 0 to 10
y = np.sin(x)

plt.plot(x, y)

plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.title('Sine Wave')

plt.tight_layout()
plt.show()

np.linspace(start, stop, num) gibt num gleichmäßig verteilte Werte zurück — eine praktische Methode, um glatte Kurven zu erzeugen, ohne eine Schleife zu schreiben. plt.tight_layout() passt den Abstand so an, dass Achsenbeschriftungen niemals abgeschnitten werden; es ist eine gute Gewohnheit, es vor jedem show()- oder savefig()-Aufruf einzufügen.

Linienfarbe und -stil ändern

Den Format-String-Kurzschreibweise verwenden

Übergeben Sie einen Format-String '[color][marker][linestyle]' als drittes positionales Argument:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y, 'r--')   # red dashed line

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Red Dashed Sine Wave')
plt.tight_layout()
plt.show()

Häufige Farbkürzel: b blau, g grün, r rot, c cyan, m magenta, y gelb, k schwarz, w weiß.

Häufige Linienstil-Codes: - durchgehend (Standard), -- gestrichelt, -. Strich-Punkt, : gepunktet.

Benannte Parameter verwenden

Benannte Parameter sind besser lesbar und geben Ihnen feinere Kontrolle:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(
    x, y,
    color='steelblue',
    linestyle='--',
    linewidth=2,
)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Styled Line')
plt.tight_layout()
plt.show()

Marker zu Datenpunkten hinzufügen

Marker zeichnen ein Symbol an jedem Datenpunkt, was nützlich ist, wenn die Rohdaten wenige Punkte haben und Sie diese explizit anzeigen möchten.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 9)   # only 9 points — markers are visible
y = np.sin(x)

plt.plot(
    x, y,
    color='darkorange',
    linewidth=1.5,
    marker='o',          # circle marker
    markersize=8,
    markerfacecolor='white',
    markeredgewidth=1.5,
)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave with Markers')
plt.tight_layout()
plt.show()

Häufige Marker-Codes: 'o' Kreis, 's' Quadrat, '^' Dreieck oben, 'D' Raute, '+' Plus, 'x' Kreuz, '*' Stern.

Weitere Informationen finden Sie im Kapitel Matplotlib-Marker mit der vollständigen Liste und erweiterten Formatierungsoptionen.

Mehrere Linien darstellen

Rufen Sie plt.plot() mehrfach auf, bevor Sie plt.show() aufrufen. Jeder Aufruf fügt eine neue Linie zu denselben Achsen hinzu. Übergeben Sie ein label-Argument und rufen Sie dann plt.legend() auf, um automatisch eine Legende zu erzeugen.

import matplotlib.pyplot as plt
import numpy as np

x  = np.linspace(0, 10, 200)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.sin(x) * np.exp(-x / 5)   # damped sine

plt.plot(x, y1, label='sin(x)', linewidth=1.5)
plt.plot(x, y2, label='cos(x)', linewidth=1.5, linestyle='--')
plt.plot(x, y3, label='damped sin(x)', linewidth=1.5, linestyle='-.')

plt.xlabel('x')
plt.ylabel('y')
plt.title('Multiple Lines')
plt.legend()

plt.tight_layout()
plt.show()

Matplotlib durchläuft automatisch seine Standard-Farbpalette, sodass Sie für jede Linie keine unterschiedlichen Farben angeben müssen, es sei denn, Sie möchten diese überschreiben.

Achsengrenzen steuern

plt.xlim() und plt.ylim() legen den sichtbaren Bereich jeder Achse fest. Übergeben Sie (min, max), um herein- oder herauszuzoomen:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y)

plt.xlim(0, 5)     # show only the first half
plt.ylim(-1.2, 1.2)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave (Zoomed In)')
plt.tight_layout()
plt.show()

Um Matplotlib eine Grenze automatisch bestimmen zu lassen, während die andere festgelegt bleibt, verwenden Sie None als Platzhalter: plt.xlim(None, 5) lässt die untere Grenze automatisch.

Ein Gitternetz hinzufügen

plt.grid(True) fügt ein leichtes Gitternetz hinzu, das das Ablesen von Werten aus dem Diagramm erleichtert. Sie können nur die Haupt- oder Nebenticks ansprechen und den Stil steuern:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y, color='steelblue', linewidth=2)

plt.grid(True, linestyle='--', color='grey', alpha=0.5)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave with Grid')
plt.tight_layout()
plt.show()

Weitere Informationen finden Sie im Kapitel Matplotlib-Gitternetz zur vollständigen Diskussion der Gitternetz-Anpassung.

Punkte annotieren

plt.annotate() zeichnet eine Textbeschriftung mit einem optionalen Pfeil, der auf eine bestimmte Datenkoordinate zeigt. Dies ist nützlich, um Spitzen, Täler oder bedeutende Ereignisse hervorzuheben.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y, color='steelblue', linewidth=1.5)

# Annotate the first peak (approx. x = pi/2)
plt.annotate(
    'peak',
    xy=(np.pi / 2, 1),            # point to annotate
    xytext=(np.pi / 2 + 1, 1.1),  # position of the text
    arrowprops=dict(arrowstyle='->', color='black'),
    fontsize=10,
)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Annotated Sine Wave')
plt.tight_layout()
plt.show()

Zwischen Linien füllen

plt.fill_between() schattiert den Bereich zwischen zwei Kurven (oder zwischen einer Kurve und einer Konstante). Dies wird häufig verwendet, um Konfidenzintervalle oder Unsicherheitsbänder darzustellen.

import matplotlib.pyplot as plt
import numpy as np

x    = np.linspace(0, 10, 200)
y    = np.sin(x)
# Simulate an upper and lower confidence bound
upper = y + 0.3
lower = y - 0.3

plt.plot(x, y, color='steelblue', linewidth=2, label='mean')
plt.fill_between(x, lower, upper, alpha=0.2, color='steelblue', label='±0.3 band')

plt.xlabel('x')
plt.ylabel('Amplitude')
plt.title('Line with Confidence Band')
plt.legend()
plt.tight_layout()
plt.show()

Das alpha-Argument steuert die Transparenz der Schattierung — Werte um 0.2–0.3 funktionieren meist gut, damit die Linie deutlich sichtbar bleibt.

Die objektorientierte API verwenden

Alle obigen Beispiele verwenden die zustandslose plt.*-Schnittstelle, die für Einzelplot-Skripte praktisch ist. Für komplexere Abbildungen (mehrere Teildiagramme, eingebettete Plots) verwenden Sie die objektorientierte API, bei der Sie mit expliziten Figure- und Axes-Objekten arbeiten:

import matplotlib.pyplot as plt
import numpy as np

x  = np.linspace(0, 10, 200)
y1 = np.sin(x)
y2 = np.cos(x)

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

ax.plot(x, y1, label='sin(x)', color='steelblue', linewidth=1.5)
ax.plot(x, y2, label='cos(x)', color='darkorange', linewidth=1.5, linestyle='--')

ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('OO-style Line Plot')
ax.legend()
ax.grid(True, linestyle=':', alpha=0.6)

plt.tight_layout()
plt.show()

Die OO-API spiegelt die plt.*-Aufrufe mit ax.set_*-Präfixen für Beschriftungen und Titel wider. Sie ist der bevorzugte Stil, wenn Sie mehrere Plots anordnen müssen — weitere Details finden Sie unter Matplotlib-Teildiagramme.

Ein Liniendiagramm in eine Datei speichern

Verwenden Sie plt.savefig() vor plt.show(). Geben Sie das Dateiformat durch die Erweiterung an:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y, color='steelblue', linewidth=2)
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Saved Line Plot')
plt.tight_layout()

plt.savefig('sine_wave.png', dpi=150)    # raster PNG at 150 dpi
plt.savefig('sine_wave.svg')             # vector SVG (ideal for web/print)

plt.show()

Häufige Formatoptionen: png, pdf, svg, eps. Verwenden Sie svg oder pdf, wenn Sie ein skalierbares, druckreifes Bild benötigen. Rufen Sie savefig() vor show() auf — nach show() wird die Abbildung geleert und savefig() würde ein leeres Bild erzeugen.

Abbildungsgröße steuern

Die Standard-Abbildung hat 6,4 × 4,8 Zoll bei 100 dpi. Überschreiben Sie sie mit figsize=(width_in, height_in):

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)

fig, ax = plt.subplots(figsize=(10, 4))   # wide and short
ax.plot(x, np.sin(x), label='sin', linewidth=1.5)
ax.plot(x, np.cos(x), label='cos', linewidth=1.5, linestyle='--')

ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('Wide Figure')
ax.legend()

plt.tight_layout()
plt.show()

Kurzübersicht

Verwandte Kapitel

• Matplotlib-Einführung — Bibliotheksübersicht und Installation
• Matplotlib Pyplot — die pyplot-Schnittstelle im Detail
• Matplotlib-Marker — Markerformen und Formatierung
• Matplotlib-Beschriftungen — Achsenbeschriftungen, Titel und Annotationen
• Matplotlib-Gitternetz — Gitternetzlinien hinzufügen und gestalten
• Matplotlib-Streudiagramme — Beziehungen zwischen zwei Variablen
• Matplotlib-Balkendiagramme — Mengen über Kategorien vergleichen
• Matplotlib-Teildiagramme — mehrere Diagramme in einer Abbildung