BITTE BEACHTEN SIE – DER API VON YAHOO FINANCE WURDE DAUERHAFT GESCHLOSSEN – ALS KOSTENFREIE ALTERNATIVE KÖNNEN SIE ALPHAVANTAGE ALS DATENQUELLE VERWENDEN – DIE DOKUMENTATION FINDEN SIE AUF DEREN SEITE

Investieren und Traden mit Python lernen – Erstellen von Charts und Grafiken mit Matplotlib
Nachdem im vorangegangenen Beitrag besprochen wurde, wie man sich mit Python von verschiedenen Quellen Kursdaten, sowie Fundamentaldaten für die Analysen downloaden kann, soll es sich nun vornehmlich um die Erstellung erster Charts und Grafiken drehen. Sie wollen die Daten sicher nicht nur im Zahlenformat analysieren.

Grafiken für Finanzanalysen in Python – Matplotlib

Für die grafische Analyse werden wir Matplotlib verwenden, eine Library in Python, welche eine Vielzahl von Darstellungsmöglichkeiten bietet. Darunter sind folgende Chart Typen

Balkendiagramme
Säulendiagramme
Liniencharts
Kreisdiagramme
Kerzencharts
Histogramme
Polarcharts
…

Eine Übersicht über alle verschiedenen Formen von Plots findet sich auf der Matplotlib.org Seite.
Die Möglichkeiten, die sich durch Matplotlib ergeben, sind nahezu grenzenlos.

Um Matplotlib nutzen zu können, installieren Sie dieses bitte über die Konsole mit Hilfe von pip install.

In dem folgenden Abschnitt werde ich mit Ihnen eine Klasse erstellen, die für Sie verschiedene Grafiken einfach direkt erstellen kann. Dabei werden wir eine objektorientierte Programmierweise verwenden. Diese ist etwas anspruchsvoller, jedoch können Sie alleine mit dem Code, den Sie in diesem Artikel finden, bereits ansehnliche Grafiken für beide vorgestellten Datenquellen erstellen.

Kursdaten mit Python als Linienchart darstellen

Zuerst importieren wir wie gewohnt alle notwendigen Pakete für das Programm, das wir erstellen wollen.

from pandas_datareader import data as pdr
import fix_yahoo_finance
import quandl
import matplotlib.pyplot as plt
import pandas as pd

Daraufhin definieren wir die Klasse, mit deren Hilfe wir die Daten beziehen wollen. Dieser übergeben wir den Ticker des Produkts sowie das Start Datum, also ab wann wir die Zeitreihe beziehen wollen.

class Stock_Analysis:
    #
    def __init__(self, Stock_Ticker,Start_Date,Stock_Name):    
        self.ticker = Stock_Ticker
        self.start_date = Start_Date
        self.name = Stock_Name
        self.stock_data = pdr.get_data_yahoo(self.ticker,self.start_date)

Die Init Methode ist die Methode, welche beim Aufrufen der Klasse, also dem Erstellen eines Objektes immer als erstes ausgeführt wird. Mit ihrer Hilfe werden dem Objekt die einzelnen Eigenschaften übergeben, die es trägt.
Dabei werden dem Obekt über self.xxx Werte zugeordnet. In unserem Beispiel übergeben wir also einem Objekt, das wir mit Hilfe dieser Klasse erstellen, folgende Informationen:

self.ticker

Ist der Ticker, welchen wir abfragen wollen

self.start_date

Das Startdatum, ab dem die Daten abgefragt werden sollen

self.name

Übergibt dem Objekt den als Inputwert angegebenen Namen der Aktie

self.stock_data

Bezieht mit Hilfe des pandas_datareaders die Kursdaten des von Ihnen gewünschten Unternehmens

Neben der __init__ Methode brauchen Sie nun weitere Methoden, um mit den gewonnen Daten zu arbeiten. Die erste Methode, die wir dazu einführen wollen, ist die Print_Data() Methode, welche die gespeicherten Kursdaten ausgibt.

    def Print_Data(self):
        print(self.stock_data)
        return self.stock_data

Diese Methode erhält selbst keine Inputfaktoren mehr und ist somit ausschließlich von den Informationen abhängig, die das Objekt (self) bereits gespeichert hat. Dabei macht die Methode zwei Dinge:
print(self.stock_data)
Gibt die Daten in der Konsole aus, um sie zu betrachten
return self.stock_data
Kann die Daten an eine Variable übergeben, sofern dies gewünscht ist z.B: über

AktieA = Stock_Analysis(“AktieA“,”2015-01-01”,”Name der Aktie A”)
Akktienkurse = AktieA.Print_Data()

Somit können die Daten auch für Funktionen verwendet werden, die ggf. noch nicht als Methoden in der Klasse enthalten sind.

Als nächster Schritt sollen nun die ersten Grafiken erstellt werden. Hierfür soll zuerst ein klassischer Linienchart dienen:

    def Print_Linechart(self):
        plt.plot(self.stock_data["Adj Close"],label = self.name)
        plt.title("Adj. Aktienkurs des Unternehmens %s"%self.name)
        plt.legend()
        plt.xlabel("Time")
        plt.ylabel("Price")
        plt.show()

Hier wird bereits etwas komplexere Syntax angewandt. Um diese im Detail zu verstehen und nachvollziehen zu können, empfehle ich (wie auch in unseren Beiträgen zu MQL5) die Plattform Sololearn zu verwenden.

Gehen wir aber kurz über die einzelnen Schritte der Methode Print_Linechart():
plt.plot()
Bezieht sich auf pyplot, welches wir aus Matplotlib importiert haben. Da wir keine weiteren Informationen übergeben, wird die Methode als Standard einen einfachen Linienchart ausgeben. Als Parameter übergeben wird die angepassten Schlusskurse der Kursdaten, sowie als Label (Legende) den Namen des Unternehmens
plt.title()
Ebenfalls eine Methode aus Matplotlib, die für die Anpassung des Titels zuständig ist. Dieser wird über String-Formatierung zusammengesetzt, da der Name des Unternehmens, das im Chart dargestellt wird, immer ein anderes ist -nämlich der Namen, den wir dem Objekt in self.name gegeben haben
plt.xlabel() & plt.ylabel()
Sind für die Beschriftung der Achsen zuständig
plt.plot()
Zeichnet den Chart

apple = Stock_Analysis("AAPL","2015-01-01","Apple")
apple.Print_Linechart() 

Ich gratuliere – Sie haben gerade eine Klasse erstellt, mit einer Methode, die Ihnen alle möglichen Aktiencharts zeichnen kann. Sie haben sogar bereits die Möglichkeit, den Darstellungszeitraum sowie die Beschriftung individuell zu gestalten.
Aktien-Renditen mit Python als Histogramm darstellen

Doch wir wollen mehr – schließlich könnte man eine solche Grafik auch noch einfach im Internet beziehen. Betrachten wir im Folgenden einmal die Renditeverteilung einer Aktie für die historischen Kursdaten:

    def Histogramm_Returns(self):
        stock_returns = ((self.stock_data["Close"]/self.stock_data["Open"])-1)*100
        plt.hist(stock_returns)
        plt.show()

Wieder erstellen wir eine Methode für die Aktienklasse. In dieser Methode berechnen wir unter Zuhilfenahme von pandas die täglichen Renditen der Aktie, indem wir den Tagesschlusskurs durch den Tagesöffnungskurs teilen (Wichtig: Wir wollen wirklich nur die Renditen betrachten, welche innerhalb der Handels-Sessions erzielt werden, Overnight Gaps und Kurssprünge über Feiertage und das Wochenende werden nicht beachtet).
stock_returns = ((self.stock_data[„Close“]/self.stock_data[„Open“])-1)*100
Erledigt den eben genannten Berechnungsprozess für uns
plt.hist(stock_returns)
Erzeugt wiederum das Histogramm, welches in Folge mit plt.show() angezeigt wird. plt.hist hat abgesehen von den Inputdaten noch weitere Inputparameter, wie zum Beispiel die Balkenbreite, welche nach Verfahren wie dem nach Silverman oder Scott optimal geschätzt werden kann

Aktien-Korrelationen mit Python als Scatterplot darstellen

Für viele ist ebenfalls der Zusammenhang zwischen zwei Aktienwerten interessant. Wie stark korrelieren diese?
Die Frage, die sich stellt: „Was passiert mit Aktie B, wenn Aktie A steigt?“
Um diesen Zusammenhang grafisch zu veranschaulichen, verwenden wir Scatter-Plots. Diese stellen die Rendite von Aktie B in Abhängigkeit zu der Rendite von Aktie A dar. Da dieser Prozess etwas komplizierter ist, würde ich an dieser Stelle einfach den Code präsentieren und zwei Anwendungsbeispiele bringen. Die Funktionsweise können Sie dann durch das Nachbauen der Methode, sowie den obigen Methoden selbst nachvollziehen, da einige Gemeinsamkeiten bestehen.

def Scatter_Plot(self,comparison_ticker,ref_name):
        ref_stock = pdr.get_data_yahoo(comparison_ticker,self.start_date)
        ref_stock_name = ref_name
        stock_returns = 
        pd.DataFrame(((self.stock_data["Close"]/self.stock_data["Open"])-1)*100)
        ref_returns = pd.DataFrame(((ref_stock["Close"]/ref_stock["Open"])-1)*100)
        returns_df = stock_returns.join(ref_returns,lsuffix=
        ("Returns %s"%self.name),rsuffix=("Returns %s"%ref_stock_name))
        print(returns_df)
        ax1 = plt.subplot2grid((1,1),(0,0))
        ax1.grid(True, color = "b", linestyle = "-")
        plt.xlabel(ref_stock_name)
        plt.ylabel(self.name)
        plt.scatter(returns_df[returns_df.columns[1]],returns_df[returns_df.columns[0]])
        plt.title("Scatterplot von %s und %s"%(ref_stock_name,self.name))
        plt.plot()

Um die Funktionsweise dieser Methode sowie die Intuition hinter dieser Grafik etwas zu verdeutlichen, möchte ich für Sie an dieser Stelle zwei Beispiele erstellen. Zum einen mit zwei Unternehmen aus derselben Branche, bei denen ein Zusammenhang naheliegt, sowie mit zwei Unternehmen unterschiedlicher Branchen, bei denen dieser nicht direkt gegeben ist.

apple = Stock_Analysis("AAPL","2015-01-01","Apple")
apple.Scatter_Plot("msft","Microsoft")

Die Grafik stellt die Korrelation zwischen Microsoft und Apple grafisch dar. Es ist durchaus ersichtlich, dass ein positiver Zusammenhang zwischen Microsoft und Apple besteht, das bedeutet: Steigt Microsoft, so ist die Wahrscheinlichkeit, dass Apple auch eine positive Tagesperformance aufweist, relativ hoch. Dieser Zusammenhang lässt sich aber noch besser bei den beiden Deutschen Autobauern Daimler und BMW erkennen.

apple = Stock_Analysis("DAI.DE","2015-01-01","Daimler")
apple.Scatter_Plot("BMW.DE","BMW")

In dieser Darstellung von Daimler Renditen gegen die Renditen von BMW wird der Zusammenhang von der Aktienperformance von Unternehmen aus demselben Sektor noch deutlicher. Es ist klar zu erkennen, dass die Renditen einen positiven Zusammenhang aufweisen.

Wie sieht dies nun aber für Unternehmen unterschiedlicher Sektoren aus? Und was ist mit der negativen Korrelation, von der in der Portfoliotheorie immer die Rede ist?

Betrachten wir einmal die täglichen Renditen von Tesla und Exxon mobile. Alleine von der Aufstellung der Unternehmen ist keinerlei Zusammenhang zu erwarten. Die Analyse für den Zeitraum von 2015-01-01 bis heute bestätigt diese Vermutung:

Stark negative Korrelationen zu finden, ist selbst in historischen Zeitreihen nicht unbedingt einfach, da tendenziell alle Aktien auf lange Sicht eine positive Wertentwicklung aufweisen und gerade während des aktuellen alten Bullenmarktes (Stand 2017) alle Aktien eine positive Tendenz aufzuweisen scheinen. Doch es gibt sie. So weisen zum Beispiel die Lufthansa und Pro Sieben im Zeitraum von 2016-01-01 bis heute einen negativen Zusammenhang.

Sowie gleichfalls in 2017:

Damit haben Sie das Ende der Einführung zur Erstellung von Grafiken für Finanzanalysen in Python erreicht. Der nächste Teil beschäftigt sich mit dem Backtesten von Strategien.

*Wir versuchen in unseren Codes grundsätzlich kostenfreie Datenquellen zu verwenden. Aufgrund der Tatsache, dass sie nicht kommerziell genutzt werden, kann sich die Verfügbarkeit im Laufe der Zeit verändern. Zudem kann es sein, dass Syntax sich im Laufe der Zeit verändert. (Stand Dezember 2017)

Die verwendeten Codes finden sich auch auf meinem GitHub Repository und sind frei zum Download verfügbar: https://github.com/JulianStorz/Python_Backtest