Liniendiagramme in MatplotLib mit Python

Erstellen eines einfachen Liniendiagramms in Matplotlib

Wir beginnen mit der Erstellung eines einfachen Liniendiagramms und passen es dann an, um es ansehnlicher und informativer zu machen.

plt.plot() verwenden, um ein Liniendiagramm zu erstellen

Um ein Liniendiagramm zu erstellen, verwenden wir die Funktion plt.plot(). Diese Funktion benötigt zwei Parameter: die Werte der x-Achse und die Werte der y-Achse. In unserem Fall ist die Datumsspalte die x-Achse, während die Spalte mit dem Abschluss die y-Achse darstellt. Hier ist der Code:

# Extract the date and close price columns
dates = df['Date']
closing_price = df['Close']

# Create a line plot
plt.plot(dates, closing_price)

# Show the plot
plt.show()

Wenn du den obigen Code ausführst, solltest du ein einfaches Liniendiagramm der DJIA-Aktie sehen. 

Anpassen des Liniendiagramms

Matplotlib bietet uns viele weitere Anpassungsmöglichkeiten, die wir nach unseren Bedürfnissen nutzen können.

Einstellen der Linienfarbe

Standardmäßig wird mit der Funktion plt.plot() eine blaue Linie gezeichnet. Du kannst die Linienfarbe jedoch ändern, indem du der Funktion einen color Parameter übergibst. Der Parameter color kann einen String enthalten, der den Farbnamen oder einen Hexadezimalcode darstellt. 

Hier ist ein Beispiel:

# Plot in Red colour
plt.plot(dates, closing_price, color='red')

# Show the plot
plt.show()

Mit diesem Code wird eine rote statt einer blauen Linie gezeichnet, wie unten gezeigt:

Grundlinienplot in rot

Einstellen der Linienbreite

Du kannst die Linienbreite auch ändern, indem du der Funktion plt.plot() einen Parameter linewidth übergibst. Der Parameter linewidth enthält einen Fließkommawert, der die Breite der Linie angibt. 

Hier ist ein Beispiel:

# Increasing the linewidth
plt.plot(dates, closing_price, linewidth=3)

# Show the plot
plt.show()

Mit diesem Code wird eine Linie mit einer Breite von 3 anstelle der Standardbreite gezeichnet, wie unten gezeigt: 

Dickere Linien im Diagramm aufgrund einer höheren Linienbreite

Einstellen des Linienstils

Du kannst den Linienstil ändern, indem du einen linestyle Parameter an die Funktion plt.plot() übergibst. Der Parameter linestyle enthält eine Zeichenkette, die den Linienstil darstellt. In der matplotlib-Dokumentation findest du eine umfangreiche Liste der verfügbaren Stile. 

Hier siehst du, wie sie im Code verwendet werden können:

# Individually plot lines in solid, dotted, dashed and dashdot

plt.plot(dates, closing_price, linestyle='solid') # Default line style
plt.plot(dates, closing_price, linestyle='dotted')
plt.plot(dates, closing_price, linestyle='dashed')
plt.plot(dates, closing_price, linestyle='dashdot')

# Show the plot
plt.show()

Hinzufügen von Markierungen zu Liniendiagrammen

Markierungen können verwendet werden, um bestimmte Punkte im Liniendiagramm hervorzuheben. Es gibt verschiedene Arten von Symbolen, die als Marker verwendet werden können und die du in der matplotlib-Dokumentation nachschlagen kannst.

Hier ist ein Beispiel für die Verwendung von Markern in einem Liniendiagramm:

# Add a cross marker for each point
plt.plot(df['Date'], df['Close'], marker='x')

# Show the plot
plt.show()

Im obigen Code verwenden wir Kreuzmarkierungen (x), um die Close Preise der DJIA-Aktien zu markieren (siehe unten): 

Hinzufügen von Etiketten und Titeln

Um die Darstellung informativer zu gestalten, können wir Achsenbeschriftungen und einen Titel hinzufügen. Wir können dies mit den Funktionen plt.xlabel(), plt.ylabel() und plt.title() erreichen. 

Hier ist ein Beispiel:

plt.plot(dates, closing_price, color='red', linewidth=2)
plt.xlabel('Date')
plt.ylabel('Closing Price')
plt.title('DJIA Stock Price')

# Show the plot
plt.show()

Mit diesem Code wird eine rote Linie mit einer Breite von 2 gezeichnet, wobei die x-Achse mit "Datum", die y-Achse mit "Schlusskurs" und der Titel mit "DJIA-Aktienkurs" beschriftet ist. 

Hinzufügen von Gitternetzlinien

Wir können auch Gitternetzlinien zu unserem Diagramm hinzufügen, um es besser lesbar zu machen. Dies können wir mit der Funktion plt.grid() erreichen. Die Funktion plt.grid() nimmt einen booleschen Wert an, der angibt, ob das Raster angezeigt werden soll. 

Hier ist ein Beispiel: 

plt.plot(dates, closing_price, color='red', linewidth=2)
plt.xlabel('Date')
plt.ylabel('Closing Price')
plt.title('DJIA Stock Price')

# Add the grid
plt.grid(True)

# Show the plot
plt.show()

Du würdest sehen, dass dem Plot Raster hinzugefügt werden: 

Matplotlib Linienplots mit mehreren Linien

In manchen Fällen möchtest du vielleicht mehrere Linien in ein und demselben Diagramm darstellen. Zu diesem Zweck kannst du die Funktion plt.plot() mehrmals mit unterschiedlichen Daten für jeden Aufruf aufrufen. Hier ist ein Beispiel:

# Line plot of Open and Close prices

plt.plot(df['Date'], df['Open'])
plt.plot(df['Date'], df['Close'])
plt.title('DJIA Open and Close Prices')
plt.xlabel('Date')
plt.ylabel('Price')

plt.show()

Im obigen Code stellen wir sowohl die Open als auch die Close Kurse der DJIA-Aktie in einem Diagramm dar. 

Matplotlib Liniendiagramme mit zwei Achsen

Es gibt Fälle, in denen du zwei Variablen mit unterschiedlichen Skalen auf demselben Diagramm darstellen möchtest. In solchen Situationen ist die Verwendung von Zwillingsachsen eine effektive Methode, um die Beziehung zwischen den Variablen zu visualisieren, ohne die Klarheit der einzelnen Skalen zu verlieren. 

Um ein Liniendiagramm mit zwei Achsen zu erstellen, müssen wir die Funktion twinx() verwenden. Diese Funktion erstellt eine neue y-Achse, die dieselbe x-Achse hat wie die ursprüngliche Darstellung. 

Hier ist ein Beispiel:

# Create a new variable for demonstration purposes
df['High_minus_Low'] = df['High'] - df['Low']

# Create a basic line plot for the Close prices
fig, ax1 = plt.subplots()
ax1.plot(df['Date'], df['Close'], color='blue', label='Close Price')
ax1.set_xlabel('Date')
ax1.set_ylabel('Closing Price', color='blue')
ax1.tick_params(axis='y', labelcolor='blue')

# Create a twin axis for the High_minus_Low variable
ax2 = ax1.twinx()
ax2.plot(df['Date'], df['High_minus_Low'], color='green', label='High - Low')
ax2.set_ylabel('High minus Low', color='green')
ax2.tick_params(axis='y', labelcolor='green')

# Add a title and show the plot
plt.title('DJIA Stock Price and High-Low Difference with Twin Axes')
plt.show()

Und die resultierende Grafik mit zwei Achsen: 

Hinzufügen von statistischen Informationen zu Matplotlib-Liniendiagrammen

Mit Liniendiagrammen lassen sich nicht nur Trends und Muster in Daten visualisieren, sondern auch statistische Informationen wie Regressionslinien und Fehlerbalken anzeigen. 

Hinzufügen einer Matplotlib-Regressionszeile

Eine Regressionslinie ist eine Linie, die am besten zu den Datenpunkten in einem Diagramm passt und zur Modellierung und Vorhersage zukünftiger Werte verwendet werden kann. Wir können eine Regressionslinie zu unserem Liniendiagramm hinzufügen, indem wir die Funktion polyfit() aus der NumPy-Bibliothek verwenden, die eine polynomiale Regressionslinie an unsere Datenpunkte anpasst. 

import matplotlib.dates as mdates

# Convert Date column to numeric value
df['Date'] = mdates.date2num(df['Date'])

# Add regression line to plot
coefficients_open = np.polyfit(df['Date'], df['Open'], 1)
p_open = np.poly1d(coefficients_open)

coefficients_close = np.polyfit(df['Date'], df['Close'], 1)
p_close = np.poly1d(coefficients_close)

fig, ax = plt.subplots()
ax.plot(df['Date'], df['Open'], '.', label='Open Price')
ax.plot(df['Date'], p_open(df['Date']), '-', label='Open Regression Line')
ax.plot(df['Date'], df['Close'], '.', label='Close Price')
ax.plot(df['Date'], p_close(df['Date']), '-', label='Close Regression Line')
ax.set_title('DIJA Stock Prices')
ax.set_xlabel('Date')
ax.set_ylabel('Price')
ax.legend()

# Format x-axis labels as dates
date_form = mdates.DateFormatter("%Y-%m-%d")
ax.xaxis.set_major_formatter(date_form)
plt.gcf().autofmt_xdate()

plt.show()

In diesem Code wandeln wir zunächst Daten mit der Funktion date2num() in numerische Werte um und verwenden dann die Funktionpolyfit(), um die Koeffizienten für die Regressionslinie zu erhalten. Wir verwenden die Funktion poly1d(), um die Linie zu zeichnen. Wir stellen die ursprünglichen Datenpunkte als Punkte dar und die Regressionslinie als durchgezogene Linie. 

Hinzufügen von Fehlerbalken

Fehlerbalken sind eine grafische Darstellung der Variabilität der Daten und können verwendet werden, um die Unsicherheit der Messungen anzuzeigen.

Das ist besonders nützlich, wenn du mit Fehlern bei der Datenerfassung rechnest, z. B. bei Temperaturdaten, Luftqualitätsdaten und so weiter. Obwohl wir uns bei den Aktienkursen sicher sind, nehmen wir einen potenziellen Fehler von einer Standardabweichung an und stellen ihn mit der Funktion errorbar in matplotlib dar.

# Calculate standard deviation of data
std = df['Close'].std()

# Add error bars to plot
plt.errorbar(df['Date'], df['Close'], yerr=std/2, fmt='.', label='Close Price')
plt.title('DIJA Stock Prices')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.show()

In diesem Code berechnen wir zunächst die Standardabweichung der Close Preise in unserem Datensatz. Anschließend verwenden wir die Funktion errorbar(), um dem Liniendiagramm Fehlerbalken hinzuzufügen, wobei die Größe der Fehlerbalken auf die Hälfte der Standardabweichung eingestellt ist .

Mit diesen Techniken können wir statistische Informationen zu unseren Liniendiagrammen hinzufügen und tiefere Einblicke in unsere Daten gewinnen.

Fazit

Liniendiagramme sind ein mächtiges Werkzeug, um Trends und Muster in Daten zu visualisieren, und Matplotlib bietet eine benutzerfreundliche Oberfläche, um sie zu erstellen. 

Als nächsten Schritt könntest du unseren Python-Kurs für Fortgeschrittene besuchen, in dem du das Gelernte auf eine Fallstudie zur Hackerstatistik anwendest. 

Wir hoffen, dass dieses Tutorial dir geholfen hat, mit Matplotlib Linienplots zu erstellen. Wir haben auch die anderen Matplotlib-Plots in einem anderen Tutorial ausführlich behandelt, das dir kurz zeigen kann, was du sonst noch mit Matplotlib machen kannst. 

Erforsche und experimentiere weiter, um beeindruckende Visualisierungen zu erstellen und Erkenntnisse aus deinen Daten zu gewinnen!