Matplotlib Zeitreihen-Liniendiagramm

Eine Zeitreihe ist eine Sammlung von Datenbeobachtungen, die durch die Zeit in chronologischer Reihenfolge indiziert sind. Diese Daten werden in der Regel (aber nicht unbedingt) in regelmäßigen Abständen aufgezeichnet. Zeitreihen werden häufig im Bankwesen, im Handel, im Marketing, in der Wissenschaft und in anderen Branchen verwendet. Die typischste visuelle Darstellung von Zeitreihendaten ist ein Liniendiagramm, bei dem die Zeit auf die x-Achse und der Messwert auf die y-Achse gelegt wird.

In diesem Lernprogramm lernen wir, wie man mit matplotlib, einer wichtigen Python-Bibliothek für die Darstellung von Zeitreihen, Linienplots erstellt und anpasst.

Erste Schritte mit matplotlib Zeitreihenplottern

Bibliotheken importieren und die Daten laden

Zuerst importieren wir die notwendigen Python-Bibliotheken und laden die Daten - einen Kaggle-Datensatz Tägliche Wechselkurse pro Euro 1999-2023. Wir werden auch einige grundlegende Datenbereinigungen vornehmen:

import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

df = pd.read_csv('euro-daily-hist_1999_2022.csv')
df = df.iloc[:, [0, 4, 28, -2]]
df.columns = ['Date', 'CAD', 'NZD', 'USD']

for col in ['CAD', 'NZD', 'USD']:
    df = df[df[col] != '-']
    df[col] = pd.to_numeric(df[col])
   
df = df[df['Date'] >= '2022-12-01'].reset_index(drop=True)
print(df.head(3))
print(f'\nThe date range: {df.Date.min()}/{ df.Date.max()}')

Output:

Date     CAD     NZD     USD
0  2023-01-27  1.4479  1.6759  1.0865
1  2023-01-26  1.4568  1.6799  1.0895
2  2023-01-25  1.4544  1.6792  1.0878

The date range: 2022-12-01/2023-01-27

Konvertierung von Datum/Zeit-Strings in datetime-Objekte

Um effizient mit Zeitreihen zu arbeiten, müssen wir Datums- oder Zeitstrings mit der Funktion pandas.to_datetime in Datetime-Objekte umwandeln:

df['Date'] = pd.to_datetime(df['Date'])
print(df['Date'].dtypes)

Output:

datetime64[ns]

Wenn du eine Auffrischung brauchst, wie du mit Zeitreihen in Python arbeitest, kannst du den Kurs Manipulating Time Series Data in Python nutzen.

Festlegen einer Datumsspalte als DataFrame-Index

Jetzt setzen wir die Spalte Date als DataFrame-Index mit der Methode set_index:

df = df.set_index('Date')
print(df.head(3))

Output:

              CAD     NZD     USD
Date                             
2023-01-27  1.4479  1.6759  1.0865
2023-01-26  1.4568  1.6799  1.0895
2023-01-25  1.4544  1.6792  1.0878

Erstellen eines einfachen einzeiligen Matplotlib-Zeitreihenplots

Um eine einfache Zeitreihengrafik zu erstellen, verwenden wir die Standardmethode matplotlib.pyplot.plot(x, y):

plt.plot(df.index, df['CAD'])

Output:

Erstellen einer mehrzeiligen Matplotlib-Zeitreihengrafik

Um eine mehrzeilige Zeitreihendarstellung zu erstellen, führen wir einfach die matplotlib.pyplot.plot(x, y) Methode so oft wie nötig:

plt.plot(df.index, df['CAD'])
plt.plot(df.index, df['NZD'])
plt.plot(df.index, df['USD'])

Durch die Verwendung der for-Schleife wird der obige Code optimiert:

for col in ['CAD', 'NZD', 'USD']:
    plt.plot(df.index, df[col])

Output: 

Matplotlib-Zeitreihenplots anpassen

Um unser Zeitreihen-Diagramm lesbarer und überzeugender zu machen, müssen wir es anpassen. Wir können einige gängige Matplotlib-Anpassungen vornehmen, z. B. die Größe der Abbildung anpassen, einen Diagrammtitel und Achsenbeschriftungen hinzufügen und anpassen, die Linieneigenschaften ändern, Markierungen hinzufügen und anpassen usw. Andere Anpassungen sind spezifisch für Zeitreihendiagramme, z. B. das Anpassen von Zeitachsen-Ticks und deren Beschriftungen oder das Hervorheben bestimmter Zeiträume.

Anpassen der Figur und der Achsen

Mit den Standard-Matplotlib-Methoden können wir die Abbildung und die Achsen eines Zeitreihen-Diagramms auf viele Arten anpassen, wie in den Code-Kommentaren unten beschrieben:

# Adjusting the figure size
fig = plt.subplots(figsize=(16, 5))

# Creating a plot
plt.plot(df.index, df['CAD'])

# Adding a plot title and customizing its font size
plt.title('EUR-CAD rate', fontsize=20)

# Adding axis labels and customizing their font size
plt.xlabel('Date', fontsize=15)
plt.ylabel('Rate', fontsize=15)

# Rotaing axis ticks and customizing their font size
plt.xticks(rotation=30, fontsize=15)

# Changing the plot resolution - zooming in the period from 15.12.2022 till 15.01.2023
plt.xlim(pd.Timestamp('2022-12-15'), pd.Timestamp('2023-01-15'))

Ausgabe: 

Anpassen der Linieneigenschaften

Wie bei gewöhnlichen Liniendiagrammen ist es möglich, die Linieneigenschaften eines Zeitreihen-Liniendiagramms zu ändern, z. B. die Linienfarbe, den Stil oder die Breite:

plt.plot(df.index, df['CAD'], color='green', linestyle='dashed', linewidth=3)

Ausgabe:

Hinzufügen und Anpassen von Markern

Wie bei jedem Liniendiagramm können wir auch bei einem Zeitreihen-Liniendiagramm Markierungen setzen und deren Symbol, Farbe, Randfarbe und Größe anpassen:

plt.plot(df.index, df['CAD'], marker='o', markerfacecolor='yellow', markeredgecolor='red', markersize=8)

Anpassen der Ticks der Zeitachse

Erstellen wir zunächst ein einfaches Matplotlib-Zeitreihen-Diagramm mit einigen wichtigen Anpassungen:

fig = plt.subplots(figsize=(16, 5))
plt.plot(df.index, df['CAD'])
plt.title('EUR-CAD rate', fontsize=20)
plt.xlabel('Date', fontsize=15)
plt.ylabel('Rate', fontsize=15)
plt.xlim(df.index.min(), df.index.max())

Ausgabe: 

Wir sehen, dass Matplotlib standardmäßig einige zufällige Zecken zusammen mit ihren Beschriftungen anzeigt. Wir möchten aber vielleicht die Kontrolle darüber übernehmen, welche Ticks auf der Zeitachse angezeigt werden. In diesem Fall müssen wir der Methode matplotlib.pyplot.xticks eine Liste mit den erforderlichen Daten (oder Zeiten) als Strings oder Pandas-Zeitstempel übergeben:

fig = plt.subplots(figsize=(16, 5))
plt.plot(df.index, df['CAD'])
plt.title('EUR-CAD rate', fontsize=20)
plt.xlabel('Date', fontsize=15)
plt.ylabel('Rate', fontsize=15)
plt.xlim(df.index.min(), df.index.max())

# Defining and displaying time axis ticks
ticks = ['2022-12-05', '2023-01-02', '2023-01-20']
plt.xticks(ticks)

Output: 

Oben hat Matplotlib die ausgewählten Zecken angezeigt und sie automatisch beschriftet.

Wenn wir anzeigen wollen alle anzeigen wollen, sollten wir der Methode eine Liste mit den Indizes der Zeitreihen übergeben matplotlib.pyplot.xticks Methode übergeben:

fig = plt.subplots(figsize=(16, 5))
plt.plot(df.index, df['CAD'])
plt.title('EUR-CAD rate', fontsize=20)
plt.xlabel('Date', fontsize=15)
plt.ylabel('Rate', fontsize=15)
plt.xlim(df.index.min(), df.index.max())

# Defining and displaying all time axis ticks
ticks = list(df.index)
plt.xticks(ticks, rotation=45)

Output: 

Anpassen der Beschriftung von Zeitachsen-Tickern

Die Beschriftung der Zeitachse auf dem obigen Liniendiagramm kann überwältigend aussehen. Vielleicht wollen wir sie formatieren, um sie besser lesbar zu machen. Zu diesem Zweck können wir die Klasse matplotlib.dates.DateFormatter verwenden und ihr einen String im strftime-Format übergeben, der angibt, wie wir die Datums-/Zeitangaben sehen möchten. Dann übergeben wir diesen Formatierer an die Methode matplotlib.axis.XAxis.set_major_formatter:

fig, ax = plt.subplots(figsize=(16, 5))
plt.plot(df.index, df['CAD'])
plt.title('EUR-CAD rate', fontsize=20)
plt.xlabel('Date', fontsize=15)
plt.ylabel('Rate', fontsize=15)
plt.xlim(df.index.min(), df.index.max())
ticks = list(df.index)
plt.xticks(ticks, rotation=45)

# Formatting time axis tick labels
ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%b %d'))

Output: 

Diese Dokumentationsseite enthält eine vollständige Liste aller möglichen strftime-Formatcodes.

Hervorhebung bestimmter Zeiträume

Manchmal möchten wir bestimmte Zeiträume in einem Zeitreihendiagramm schattieren. Zu diesem Zweck können wir die Methode matplotlib.pyplot.axvspan verwenden. Sie benötigt zwei Argumente: den Anfangs- und den Endzeitpunkt des gewünschten Zeitraums im Datumsformat. Die Methode kann auch einige optionale Parameter annehmen, um das Aussehen eines hervorgehobenen Bereichs anzupassen, z. B. seine Farbe, Randfarbe, Transparenz, Linienbreite oder Füllmuster.

Wenden wir diese Technik auf die Grafik aus dem vorherigen Abschnitt an:

fig, ax = plt.subplots(figsize=(16, 5))
plt.plot(df.index, df['CAD'])
plt.title('EUR-CAD rate', fontsize=20)
plt.xlabel('Date', fontsize=15)
plt.ylabel('Rate', fontsize=15)
plt.xlim(df.index.min(), df.index.max())
ticks = list(df.index)
plt.xticks(ticks, rotation=45)
ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%b %d'))

# Highlighting the time period from 15.12.2022 to 1.01.2023 and customizing the shaded area
plt.axvspan(datetime(2022, 12, 15), datetime(2023, 1, 1), facecolor='yellow', alpha=0.5, hatch='/', edgecolor='red', linewidth=5)

Output: 

Speichern einer Matplotlib-Zeitreihengrafik in einer Datei

Wir können uns dafür entscheiden, eine Zeitreihengrafik in einer Bilddatei zu speichern, anstatt sie nur anzuzeigen. Dazu verwenden wir die Methode matplotlib.pyplot.savefig und geben den Dateinamen an. Kehren wir zum Beispiel zu unserem ersten Grundplot zurück:

plt.plot(df.index, df['CAD'])

# Saving the resulting plot to a file
plt.savefig('time series line plot.png')

Oben haben wir den Plot in einer Datei namens Zeitreihen-Liniendiagramm.png gespeichert, die sich am selben Ort wie unser aktuelles Programm befindet.

Fazit

Zusammenfassend haben wir in diesem Tutorial besprochen, wie man in Matplotlib Linienplots für Zeitreihen erstellt und anpasst. Dabei haben wir sowohl gängige Matplotlib-Methoden als auch fortgeschrittenere Methoden verwendet, die nur für Zeitreihenvisualisierungen geeignet sind.

Nachdem du diese grundlegenden Techniken gelernt hast, möchtest du vielleicht tiefer in die Arbeit mit Zeitreihendaten und deren Visualisierung in Python eintauchen. In diesem Fall solltest du dir die folgenden umfassenden, anfängerfreundlichen und durchgängigen Ressourcen ansehen:

• Zeitreihen mit Python Lernpfad
• Zeitreihenanalyse in Python Kurs
• Visualisierung von Zeitreihendaten in Python Kurs