Python und Finanzen – Verbessern Sie Ihre Tabellenkalkulationen

Zusammenfassung

Für Berufe, die sich lange auf das Durchsuchen von Tabellenkalkulationen verlassen haben, ist Python besonders wertvoll. Citigroup, eine amerikanische Bank, hat für ihre angehenden Analysten einen Crashkurs in Python eingeführt. - Der Ökonom

Finanzfachleute haben seit langem Zugriff auf VBA (Visual Basic for Applications) in Excel, um benutzerdefinierte Funktionen zu erstellen und Workflows zu automatisieren. Mit dem Aufkommen von Google Sheets in den letzten Jahren als ernsthafter Konkurrent im Tabellenkalkulationsbereich bietet Google Apps Script jetzt eine zusätzliche Auswahl.

Ich möchte jedoch auf eine dritte Option aufmerksam machen, die Programmiersprache Python, die in einer Reihe von Bereichen enorm populär geworden ist.

In diesem Artikel werde ich einige Beispiele dafür geben, was Sie mit Python erreichen können, beginnend mit einem Überblick über die Sprache selbst und warum sie in so vielen Bereichen so beliebt geworden ist, von der Webentwicklung über maschinelles Lernen bis hin zu Finanzen, Wissenschaft und Bildung, um nur einige zu nennen. Die zweite Hälfte besteht dann aus einem Schritt-für-Schritt-Tutorial.

Das Ziel meines Schreibens ist es, Ihnen bei der Entscheidung zu helfen, ob Python so faszinierend aussieht, dass Sie es in Betracht ziehen, es Ihrer Finanz-Toolbox hinzuzufügen. Wenn Sie den Sprung wagen, gibt es viele Apps, Kurse, Videos, Artikel, Bücher und Blogbeiträge, um die Sprache zu lernen. Am Ende des Stücks habe ich einige Ressourcen aufgelistet, die mir auf dem Weg geholfen haben.

Anwendungsfälle: Beispiele dafür, wofür ich Python verwendet habe

Mein Einstieg in die Programmierung war das Erlernen von BASIC auf einer Oric 1 Mitte der 1980er Jahre. BASIC war damals die am weitesten verbreitete Anfängersprache. Andere Sprachen, mit denen ich mich Ende der 80er bis Mitte der 90er beschäftigte, waren Pascal und C, aber ich habe sie nie in irgendeiner professionellen Funktion verwendet, und ich hatte nicht erwartet, Programmierkenntnisse zu benötigen oder einzusetzen. Meines Wissens waren Finanzen und Programmieren damals Ende der 90er Jahre sehr unterschiedliche Bereiche, als ich mich für eine Karriere im Finanzbereich entschied.

Spulen wir vor bis 2012, und ich wollte das Programmieren wieder als Hobby aufgreifen, also begann ich, die damals verfügbaren Sprachen zu recherchieren. Es stellte sich heraus, dass einiges passiert war, und als ich auf Python stieß, war ich süchtig, aus vielen der Gründe, die ich im nächsten Abschnitt erläutern werde. Seitdem habe ich Python für eine Vielzahl von Aufgaben eingesetzt, von kleinen Skripten bis hin zu größeren Projekten, sowohl privat als auch beruflich. Viele, aber nicht alle, haben mit Tabellenkalkulationen gearbeitet, der Werkbank vieler Finanzexperten.

Hier sind ein paar Beispiele dafür, wie gut Tabellenkalkulationen und Python zusammenpassen können:

1. Verfolgung von Hunderten von Aktivitäten im Laufe der Zeit in einem M&A-Integrations-PMO-Setup

Ich arbeite mit allen Aspekten von M&A-Transaktionen, nicht nur mit der Durchführung, sondern auch mit der Integration. In einem kürzlichen Fall entschied sich das PMO-Team für einen hybriden Programm- und Projektmanagementansatz, bei dem Wasserfallplanung und Gantt-Diagramme für allgemeine Pläne für jeden der zwölf Integrationsworkstreams verwendet wurden, zusätzlich zu einem Kanban-Board zur Verfolgung der Hunderte von laufenden Aktivitäten zu einem beliebigen Zeitpunkt, im ersten 100-Tage-Plan und darüber hinaus. Das ausgewählte Kanban-Tool MeisterTask verfügt über eine Reihe von Statistik- und Berichtsfunktionen, aber unsere Anforderungen an Analyse und Präsentation gingen darüber hinaus, was eine kundenspezifische Lösung erforderte. Dies ist der Workflow, den ich mit Python automatisiert habe:

1. Status des gesamten Boards wöchentlich als CSV-Datei speichern.
2. Lesen Sie alle historischen CSV-Dateien in einen Pandas DataFrame ein.
3. Sortieren, filtern, gruppieren und manipulieren Sie die Daten in vereinbarten Formaten, wie wir den Fortschritt verfolgen möchten (nach Aktivitätsstatus, Workstream usw.).
4. Schreiben Sie die Ausgabe in eine Excel-Datei mit den Daten aus jeder Analyse in einem eigenen Blatt, das so formatiert ist, dass es einfach kopiert und in think-cell Diagramme eingefügt werden kann.
5. Erstellen Sie Tabellen und Diagramme für das Berichtspaket für die monatliche Sitzung des Lenkungsausschusses.

Die Entwicklung des Skripts erforderte eine Vorabinvestition von einigen Stunden, aber jetzt dauert die Aktualisierung des Berichtspakets für Lenkungsausschusssitzungen oder Ad-hoc-Analysen eine Sache von Minuten. Buchstäblich etwa 30 Sekunden, um zum richtigen Ordner zu wechseln und das Skript mit einem einzeiligen Befehl auszuführen, und dann ein paar Minuten, um die Ausgabe zu kopieren und in das Foliendeck einzufügen. Mit etwa 500 Aktivitäten (Karten) in zwölf Workstreams, die bereits etwa einen Monat nach der Ausführung und wöchentlicher Verfolgung ihrer Bewegung innerhalb eines Programmzeitplans von zwei Jahren vorhanden sind, müssen Sie sich schnell mit Tausenden und schließlich Zehntausenden von Datenpunkten über Dutzende hinweg auseinandersetzen von Dateien. Ohne Automatisierung sprechen wir hier über einige sehr mühsame Aufgaben.

Der „Zeit-Wert-des-Geld“-Kompromisses zwischen einfachem Erledigen der Dinge oder dem Hinzufügen von mehr anfänglicher Arbeitsbelastung durch die Einrichtung von Automatisierung ist ein häufiges Thema im Finanzwesen. Ich habe im ersten Schritt dieses Prozesses eine ähnliche Entscheidung getroffen, indem ich die Daten als CSV-Dateien exportiert habe. MeisterTask verfügt wie viele moderne Webanwendungen über eine API, die mit Ihrer Python-Anwendung verbunden werden kann, aber der Zeitaufwand für die Einrichtung würde die Zeitersparnis für unseren Anwendungsfall hier bei weitem aufwiegen.

Wie Sie also sehen, besteht die optimale Lösung häufig darin, bestimmte Schritte eines Workflows zu automatisieren und andere manuell zu belassen.

2. Hauspreisstatistiken mit Web Scraping, Google Maps API und Excel analysieren

Ein weiteres Beispiel ist etwas, das ich aus persönlichem Interesse gemacht habe, aber ich möchte es hervorheben, weil es einige andere interessante Elemente von Pythons Dienstprogramm enthält:

1. Scraping-Daten von Immobilienangeboten, einschließlich Adresse, Größe, Anzahl der Zimmer, Preisvorstellung und anderer Merkmale, für ein bestimmtes Gebiet; ein paar hundert bis vielleicht tausend Zeilen insgesamt.
2. Speichern Sie in einer Python-Datenstruktur.
3. Verbinden Sie sich mit der Google Maps API und rufen Sie für jeden Eintrag die Entfernung zwischen der Unterkunft und wichtigen Sehenswürdigkeiten wie dem Meer, dem Stadtzentrum, dem nächsten Bahnhof, dem nächsten Flughafen usw. ab.
4. Exportieren Sie die Daten in eine Excel-Datei.
5. Verwenden Sie die standardmäßige Excel-Funktionalität, um Regressionen auszuführen, Statistiken zu berechnen und Diagramme zu Standardmetriken wie Preis pro Quadratmeter und Entfernung zu Sehenswürdigkeiten zu erstellen.

Die hier erzielten Ergebnisse könnten mit Ihren ganz persönlichen Gewichtungen hinsichtlich Präferenzen und finanziellen Einschränkungen bei der Immobiliensuche kombiniert werden.

Dies sind nur zwei Beispiele, die sich auf die Automatisierung von Tabellenkalkulationsarbeiten und das Hinzufügen von Funktionen konzentrieren, aber die Möglichkeiten mit Python sind nahezu unbegrenzt. Im nächsten Abschnitt werde ich die Gründe skizzieren, warum es so beliebt geworden ist, bevor ich zu einem schrittweisen Monte-Carlo-Simulations-Tutorial in Python übergehe.

Warum Python eine gute Wahl für Finanzexperten ist

Die Programmiersprache Python gibt es seit 1990, aber erst in den letzten Jahren ist ihre Popularität explodiert.

Dafür gibt es mehrere Gründe, schauen wir uns diese der Reihe nach an.

1. Python ist eine höhere Programmiersprache

Eine höhere Programmiersprache ist eine Programmiersprache, die viele der Details des Innenlebens des Computers abstrahiert. Ein gutes Beispiel ist die Speicherverwaltung. Niedrigere Programmiersprachen erfordern ein detailliertes Verständnis der Komplexität, wie der Speicher des Computers ausgelegt, zugewiesen und freigegeben wird, zusätzlich zu der aufgewendeten Zeit und den Codezeilen, die für die Bearbeitung von Aufgaben erforderlich sind. Python abstrahiert und verarbeitet viele dieser Details automatisch, sodass Sie sich auf das konzentrieren können, was Sie erreichen möchten.

2. Es ist prägnant

Da Python eine höhere Programmiersprache ist, ist der Code prägnanter und konzentriert sich fast ausschließlich auf die Geschäftslogik dessen, was Sie erreichen möchten, und nicht auf technische Implementierungsdetails. Sprachdesign-Entscheidungen tragen dazu bei: Beispielsweise erfordert Python nicht die Verwendung von geschweiften Klammern oder Semikolons, um Funktionen, Schleifen und Zeilen abzugrenzen, wie es viele andere Sprachen tun, was es prägnanter macht und, wie einige argumentieren, verbessert Lesbarkeit.

3. Leicht zu erlernen und zu verstehen

Eine Beobachtung, die die Wahl des Sprachdesigns in Python beeinflusst hat, ist, dass Programme häufiger gelesen als geschrieben werden. Python zeichnet sich hier aus, da sein Code dem einfachen Englisch sehr nahe kommt, insbesondere wenn Sie die verschiedenen Komponenten Ihres Skripts oder Programms sinnvoll benennen.

4. Geeignet für schnelle, iterative Entwicklung

Erleuchtetes Trial-and-Error übertrifft die Planung eines makellosen Intellekts. -David Kelly

Python ist ideal für das Prototyping und die schnelle, iterative Entwicklung (und, ja, Trial-and-Error), da interaktive Interpreter-Tools wie die Python-Shell, IPython und Jupyter-Notebooks im Mittelpunkt der Python-Toolchain stehen. In diesen interaktiven Umgebungen können Sie jede Codezeile isoliert schreiben und ausführen und die Ergebnisse (oder eine hilfreiche Fehlermeldung) sofort sehen. Andere Sprachen haben dies auch, aber in den meisten Fällen nicht im gleichen Maße wie Python.

5. Kann sowohl für Prototyping als auch für Produktionscode verwendet werden

Python eignet sich nicht nur hervorragend für das Prototyping, sondern ist auch eine hervorragende und leistungsstarke Sprache für große Produktionsanwendungen. Einige der größten Softwareunternehmen der Welt nutzen Python intensiv in einer Vielzahl von Anwendungen und Anwendungsfällen.

6. Kommt mit „Batterien enthalten:“ Die Python-Standardbibliothek

Alles, was für grundlegende Operationen benötigt wird, ist direkt in die Sprache integriert, aber darüber hinaus verfügt die Python-Standardbibliothek über Tools zum Arbeiten mit Dateien, Medien, Netzwerken, Datums- und Zeitinformationen und vielem mehr. Auf diese Weise können Sie eine Vielzahl von Aufgaben erledigen, ohne nach Paketen von Drittanbietern suchen zu müssen.

7. Großartige Bibliotheken von Drittanbietern für die Finanzanalyse

Für Finanzexperten sind Pandas mit seinen DataFrame- und Series- Objekten und Numpy mit seinem ndarray die Arbeitspferde der Finanzanalyse mit Python. In Kombination mit Matplotlib und anderen Visualisierungsbibliotheken stehen Ihnen großartige Tools zur Verfügung, um die Produktivität zu steigern.

8. Python ist kostenlos!

Python wird unter einer Open-Source-Lizenz entwickelt, wodurch es auch für die kommerzielle Nutzung kostenlos ist.

Schritt-für-Schritt-Anleitung zur gemeinsamen Verwendung von Python und Finanzen

Was folgt, ist ein Schritt-für-Schritt-Tutorial, das zeigt, wie Sie eine vereinfachte Version der Monte-Carlo-Simulation erstellen, die in meinem vorherigen Blogbeitrag beschrieben wurde, aber mit Python anstelle des @RISK-Plugins für Excel.

Monte-Carlo-Methoden beruhen auf Zufallsstichproben, um numerische Ergebnisse zu erhalten. Eine solche Anwendung besteht darin, zufällige Stichproben aus einer Wahrscheinlichkeitsverteilung zu ziehen, die ungewisse potenzielle zukünftige Zustände der Welt darstellen, wobei Variablen oder Annahmen eine Reihe von Werten annehmen können.

Es ist hilfreich, die Monte-Carlo-Simulation auf einem vereinfachten DCF-Bewertungsmodell durchzuführen, anstatt auf den häufigeren Beispielen, die Sie sehen, die die Bewertung von Optionen oder anderen Derivaten zeigen, da wir dafür keine Mathematik über die Grundlagen der Berechnung des Jahresabschlusses hinaus benötigen Diskontieren von Cashflows, sodass wir uns auf die Python-Konzepte und -Tools konzentrieren können. Bitte beachten Sie jedoch, dass dieses grundlegende Tutorial-Modell die Schlüsselkonzepte veranschaulichen soll und für praktische Zwecke nicht nützlich ist. Ich werde auch keinen der eher akademischen Aspekte von Monte-Carlo-Simulationen ansprechen.

Das Tutorial setzt voraus, dass Sie mit den Grundbausteinen der Programmierung wie Variablen und Funktionen vertraut sind. Wenn nicht, kann es hilfreich sein, sich 10 Minuten Zeit zu nehmen, um die Schlüsselkonzepte beispielsweise in dieser Einführung zu überprüfen.

Der Ausgangspunkt und das gewünschte Ergebnis

Ich beginne mit demselben sehr vereinfachten DCF-Bewertungsmodell, das im Monte-Carlo-Simulations-Tutorial verwendet wird. Es enthält einige wichtige Einzelposten aus den drei Jahresabschlüssen und drei hervorgehobene Eingabezellen, die in der Excel-Version Punktschätzungen enthalten, die wir jetzt durch Wahrscheinlichkeitsverteilungen ersetzen möchten, um mit der Untersuchung potenzieller Ergebnisbereiche zu beginnen.

Ein zweistufiger Ansatz zur Entwicklung eines kleinen Skripts

Machen Sie es zum Laufen, machen Sie es richtig, machen Sie es schnell – Kent Beck

Die Absicht dieses Tutorials ist es, Finanzfachleuten, die neu bei Python sind, eine Einführung zu geben, nicht nur, wie ein nützliches Programm aussehen könnte, sondern auch eine Einführung in den iterativen Prozess, den Sie verwenden können, um es zu entwickeln. Es besteht daher aus zwei Teilen:

1. Zuerst entwickle ich einen funktionierenden Prototyp mit einem unkomplizierten Ansatz, der meiner Meinung nach leicht zu befolgen ist und dem Prozess nicht ganz unähnlich ist, den man verwenden könnte, um dieses Projekt zu starten, wenn man bei Null anfangen würde.
2. Nachdem ich den funktionierenden Prototyp entwickelt habe, gehe ich durch den Prozess des Refactorings – das Ändern der Codestruktur ohne Änderung seiner Funktionalität. Vielleicht möchten Sie bei diesem Teil bleiben - es ist eine elegantere Lösung als die erste und als Bonus ist es in Bezug auf die Ausführungszeit etwa 75-mal schneller.

1. Entwicklung eines funktionierenden Prototyps

Einrichten des Jupyter-Notebooks

Das Jupyter-Notebook ist ein großartiges Tool für die interaktive Arbeit mit Python. Es ist ein interaktiver Python-Interpreter mit Zellen, die Code, Markdown-Text, Bilder oder andere Daten enthalten können. Für dieses Tutorial habe ich die Python Quant Platform verwendet, aber ich kann auch Colaboratory von Google empfehlen, das kostenlos ist und in der Cloud läuft. Wählen Sie dort einfach „New Python 3 Notebook“ im Menü „File“ und schon kann es losgehen.

Nachdem Sie dies getan haben, besteht der nächste Schritt darin, die Pakete von Drittanbietern zu importieren, die wir für die Datenmanipulation und Visualisierung benötigen, und dem Programm mitzuteilen, dass wir Diagramme inline in unserem Notizbuch sehen möchten, anstatt in separaten Fenstern:

 import numpy as np import pandas as pd import matplotlib.pyplot as plt %matplotlib inline

Eine Anmerkung, bevor wir mit der Benennung unserer ersten Variablen beginnen. Wie ich bereits betont habe, ist die Lesbarkeit eine der Stärken von Python. Sprachdesign leistet einen großen Beitrag dazu, aber jeder, der Code schreibt, ist dafür verantwortlich, ihn lesbar und verständlich zu machen, nicht nur für andere, sondern auch für sich selbst. Wie das Gesetz von Eagleson besagt: „Jeder eigene Code, den Sie sich sechs oder mehr Monate lang nicht angesehen haben, könnte genauso gut von jemand anderem geschrieben worden sein.“

Eine gute Faustregel ist, die Komponenten Ihres Programms so zu benennen, dass Sie die Notwendigkeit separater Kommentare minimieren, die erklären, was Ihr Programm tut.

Lassen Sie uns in diesem Sinne weitermachen.

Erstellung des Jahresabschlusses

Es gibt viele Möglichkeiten, wie wir mit vorhandenen Tabellenkalkulationsdaten in Python arbeiten können. Wir könnten zum Beispiel ein Blatt mit einer Codezeile mit dem Befehl read_excel in einen Pandas DataFrame einlesen. Wenn Sie eine engere Integration und Echtzeitverbindung zwischen Ihrer Tabellenkalkulation und Ihrem Python-Code wünschen, stehen Ihnen sowohl kostenlose als auch kommerzielle Optionen zur Verfügung, um diese Funktionalität bereitzustellen.

Da das Modell hier sehr einfach ist und um uns auf die Python-Konzepte zu konzentrieren, werden wir es in unserem Skript von Grund auf neu erstellen. Am Ende des ersten Teils werde ich zeigen, wie Sie das, was wir erstellt haben, in eine Tabelle exportieren können.

Als ersten Schritt zur Erstellung einer Python-Darstellung des Jahresabschlusses benötigen wir eine geeignete Datenstruktur. Es stehen viele zur Auswahl, einige sind in Python integriert, andere aus verschiedenen Bibliotheken, oder wir können unsere eigenen erstellen. Lassen Sie uns zunächst eine Serie aus der Pandas-Bibliothek verwenden, um einen Blick auf ihre Funktionalität zu werfen:

 years = ['2018A', '2019B', '2020P', '2021P', '2022P', '2023P'] sales = pd.Series(index=years) sales['2018A'] = 31.0 sales

Diese Eingabe und die entsprechende Ausgabe sind unten dargestellt:

Mit den ersten drei Zeilen haben wir eine Datenstruktur mit einem Index erstellt, der aus Jahren (jeweils markiert, um anzuzeigen, ob es Ist, Budget oder Voraussichtlich ist), einem Startwert (in Millionen Euro, wie im ursprünglichen DCF-Modell) und leere (NaN, „Not a Number“) Zellen für die Projektionen. Die vierte Zeile gibt eine Darstellung der Daten aus - im Allgemeinen erhalten Sie durch die Eingabe des Namens einer Variablen oder anderer Objekte im interaktiven Interpreter eine vernünftige Darstellung davon.

Als Nächstes deklarieren wir eine Variable, die das prognostizierte jährliche Umsatzwachstum darstellt. In diesem Stadium ist es eine Punktschätzung, die gleiche Zahl wie in unserem ursprünglichen DCF-Modell. Wir möchten zuerst dieselben Eingaben verwenden und bestätigen, dass unsere Python-Version die gleiche Leistung erbringt und das gleiche Ergebnis liefert wie die Excel-Version, bevor wir uns mit dem Ersetzen von Punktschätzungen durch Wahrscheinlichkeitsverteilungen befassen. Mit dieser Variable erstellen wir eine Schleife, die den Umsatz in jedem Jahr der Prognosen basierend auf dem Vorjahr und der Wachstumsrate berechnet:

 growth_rate = 0.1 for year in range(1, 6): sales[year] = sales[year - 1] * (1 + growth_rate) sales

Wir haben jetzt projizierte Verkäufe anstelle von NaN:

Unter Verwendung des gleichen Ansatzes fahren wir mit dem Jahresabschluss fort, deklarieren Variablen nach Bedarf und führen die notwendigen Berechnungen durch, um schließlich zum freien Cashflow zu gelangen. Sobald wir dort angekommen sind, können wir überprüfen, ob das, was wir haben, mit dem übereinstimmt, was die Excel-Version des DCF-Modells sagt.

 ebitda_margin = 0.14 depr_percent = 0.032 ebitda = sales * ebitda_margin depreciation = sales * depr_percent ebit = ebitda - depreciation nwc_percent = 0.24 nwc = sales * nwc_percent change_in_nwc = nwc.shift(1) - nwc capex_percent = depr_percent capex = -(sales * capex_percent) tax_rate = 0.25 tax_payment = -ebit * tax_rate tax_payment = tax_payment.apply(lambda x: min(x, 0)) free_cash_flow = ebit + depreciation + tax_payment + capex + change_in_nwc free_cash_flow

Dies gibt uns die freien Cashflows:

Die eine Zeile darüber, die zu diesem Zeitpunkt vielleicht noch kommentiert werden muss, ist die zweite tax_payment Referenz. Hier wenden wir eine kleine Funktion an, um sicherzustellen, dass wir in Szenarien, in denen das Ergebnis vor Steuern negativ wird, keine positive Steuerzahlung haben. Dies zeigt, wie effektiv Sie benutzerdefinierte Funktionen auf alle Zellen in einer Pandas-Serie oder einem DataFrame anwenden können. Die tatsächlich angewendete Funktion ist natürlich eine Vereinfachung. Ein realistischeres Modell für einen größeren Bewertungsvorgang hätte ein separates Steuermodell, das die tatsächlich gezahlten Barsteuern auf der Grundlage einer Reihe von unternehmensspezifischen Faktoren berechnet.

Durchführung der DCF-Bewertung

Nachdem wir zu den prognostizierten Cashflows gelangt sind, können wir nun einen einfachen Endwert berechnen und alle Cashflows auf die Gegenwart diskontieren, um das DCF-Ergebnis zu erhalten. Der folgende Code führt Indizierung und Aufteilung ein, wodurch wir auf ein oder mehrere Elemente in einer Datenstruktur zugreifen können, z. B. das Pandas Series-Objekt.

Wir greifen auf Elemente zu, indem wir eckige Klammern direkt hinter den Namen der Struktur schreiben. Einfache Indizierung greift auf Elemente nach ihrer Position zu, beginnend mit Null, was bedeutet, dass free_cash_flow[1] uns das zweite Element liefern würde. [-1] ist eine Abkürzung für den Zugriff auf das letzte Element (der Cashflow des letzten Jahres wird zur Berechnung des Endwerts verwendet), und die Verwendung eines Doppelpunkts gibt uns einen Slice, was bedeutet, dass [1:] uns alle Elemente außer dem ersten gibt, da wir das historische Jahr 2018A nicht in unsere DCF-Bewertung einbeziehen wollen.

 cost_of_capital = 0.12 terminal_growth = 0.02 terminal_value = ((free_cash_flow[-1] * (1 + terminal_growth)) / (cost_of_capital - terminal_growth)) discount_factors = [(1 / (1 + cost_of_capital)) ** i for i in range (1,6)] dcf_value = (sum(free_cash_flow[1:] * discount_factors) + terminal_value * discount_factors[-1]) dcf_value 

Damit ist der erste Teil unseres Prototyps abgeschlossen – wir haben jetzt ein funktionierendes DCF-Modell, wenn auch ein sehr rudimentäres, in Python.

Exportieren der Daten

Bevor Sie mit der eigentlichen Monte-Carlo-Simulation fortfahren, ist dies möglicherweise ein guter Zeitpunkt, um die im Pandas-Paket verfügbaren Exportfunktionen zu erwähnen. Wenn Sie ein Pandas DataFrame-Objekt haben, können Sie dieses mit einer Zeile in eine Excel-Datei schreiben, indem Sie die Methode to_excel verwenden. Es gibt ähnliche Funktionen zum Exportieren in mehr als ein Dutzend anderer Formate und Ziele.

 output = pd.DataFrame([sales, ebit, free_cash_flow], index=['Sales', 'EBIT', 'Free Cash Flow']).round(1) output.to_excel('Python DCF Model Output.xlsx') output 

Erstellen von Wahrscheinlichkeitsverteilungen für unsere Monte-Carlo-Simulation

Jetzt sind wir bereit, die nächste Herausforderung anzugehen: einige der Punktschätzungseingaben durch Wahrscheinlichkeitsverteilungen zu ersetzen. Während die Schritte bis zu diesem Punkt im Vergleich zum Erstellen desselben Modells in Excel etwas umständlich erscheinen mögen, geben Ihnen die nächsten Zeilen einen Eindruck davon, wie leistungsfähig Python sein kann.

Unser erster Schritt besteht darin, zu entscheiden, wie viele Iterationen wir in der Simulation ausführen möchten. Die Verwendung von 1.000 als Ausgangspunkt schafft ein Gleichgewicht zwischen dem Erhalten von genügend Datenpunkten, um vernünftige Ausgabediagramme zu erhalten, und dem Abschluss der Simulation innerhalb eines vernünftigen Zeitrahmens. Als nächstes generieren wir die eigentlichen Verteilungen. Der Einfachheit halber habe ich hier drei Normalverteilungen generiert, aber die NumPy-Bibliothek hat eine große Anzahl von Verteilungen zur Auswahl, und es gibt auch andere Orte, an denen Sie suchen können, einschließlich der Python-Standardbibliothek. Nachdem wir entschieden haben, welche Verteilung verwendet werden soll, müssen wir die Parameter angeben, die zur Beschreibung ihrer Form erforderlich sind, wie z. B. Mittelwert und Standardabweichung, und die Anzahl der gewünschten Ergebnisse.

 iterations = 1000 sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations) ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations) nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations) plt.hist(sales_growth_dist, bins=20) plt.show() 

Hier könnte man argumentieren, dass das EBITDA keine separate, vom Umsatz unabhängige Zufallsvariable sein sollte, sondern in gewissem Maße mit dem Umsatz korreliert. Ich stimme dem zu und füge hinzu, dass es auf einem soliden Verständnis der Dynamik der Kostenstruktur (variable, semivariable und fixe Kosten) und der wichtigsten Kostentreiber (von denen einige ihre eigenen Wahrscheinlichkeitsverteilungen haben können, wie zum Beispiel Input-Rohstoffpreise), aber ich lasse diese Komplexität hier aus Gründen der Übersichtlichkeit und des Platzes beiseite.

Je weniger Daten Sie für Ihre Wahl der Verteilung und Parameter haben, desto mehr müssen Sie sich auf die Ergebnisse Ihrer verschiedenen Due-Diligence-Workstreams in Kombination mit Ihrer Erfahrung verlassen, um sich eine übereinstimmende Meinung über die Bandbreite wahrscheinlicher Szenarien zu bilden. In diesem Beispiel wird es bei Cashflow-Prognosen eine große subjektive Komponente geben, was bedeutet, dass die Visualisierung der Wahrscheinlichkeitsverteilungen wichtig wird. Hier können wir mit nur zwei kurzen Codezeilen eine einfache Visualisierung erhalten, die die Verteilung des Umsatzwachstums zeigt. Auf diese Weise können wir schnell jede Verteilung in Augenschein nehmen, die die kollektive Ansicht des Teams am besten widerspiegelt.

Jetzt haben wir alle Bausteine, die wir zum Ausführen der Simulation benötigen, aber sie haben kein geeignetes Format zum Ausführen der Simulation. Hier ist derselbe Code, mit dem wir bisher gearbeitet haben, aber alle in einer Zelle gesammelt und der Einfachheit halber in einer Funktion neu angeordnet:

 def run_mcs(): # Create probability distributions sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations) ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations) nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations) # Calculate DCF value for each set of random inputs output_distribution = [] for i in range(iterations): for year in range(1, 6): sales[year] = sales[year - 1] * (1 + sales_growth_dist[0]) ebitda = sales * ebitda_margin_dist[i] depreciation = (sales * depr_percent) ebit = ebitda - depreciation nwc = sales * nwc_percent_dist[i] change_in_nwc = nwc.shift(1) - nwc capex = -(sales * capex_percent) tax_payment = -ebit * tax_rate tax_payment = tax_payment.apply(lambda x: min(x, 0)) free_cash_flow = ebit + depreciation + tax_payment + capex + change_in_nwc # DCF valuation terminal_value = (free_cash_flow[-1] * 1.02) / (cost_of_capital - 0.02) free_cash_flow[-1] += terminal_value discount_factors = [(1 / (1 + cost_of_capital)) ** i for i in range (1,6)] dcf_value = sum(free_cash_flow[1:] * discount_factors ) output_distribution.append(dcf_value) return output_distribution

Wir können jetzt die gesamte Simulation ausführen und die Ausgabeverteilung, die der diskontierte Cashflowwert dieses Unternehmens in jeder der 1.000 Iterationen ist, mit dem folgenden Code darstellen. Der %time -Befehl ist kein Python-Code, sondern eine Notizbuch-Kurzschrift, die die Zeit misst, um etwas auszuführen (Sie könnten stattdessen die Python-Funktion aus der Standardbibliothek verwenden). Es hängt vom Computer ab, auf dem Sie es ausführen, aber diese Version benötigt 1-2 Sekunden, um die 1.000 Iterationen auszuführen und das Ergebnis zu visualisieren.

 %time plt.hist(run_mcs(), bins=20, color='r') plt.show() 

2. Verfeinerung des Prototyps

Der lauernde Verdacht, dass etwas vereinfacht werden könnte, ist die weltweit reichste Quelle lohnender Herausforderungen. -Edsger Dijkstra

Refactoring bezieht sich auf den Prozess des Umschreibens von vorhandenem Code, um seine Struktur zu verbessern, ohne seine Funktionalität zu ändern, und es kann eines der unterhaltsamsten und lohnendsten Elemente des Codierens sein. Dafür kann es mehrere Gründe geben. Es könnte sein:

1. Organisieren Sie die verschiedenen Teile sinnvoller.
2. Benennen Sie Variablen und Funktionen um, um ihren Zweck und ihre Funktionsweise klarer zu machen.
3. Zukünftige Funktionen zulassen und vorbereiten.
4. Verbessern Sie die Ausführungsgeschwindigkeit, den Speicherbedarf oder die Nutzung anderer Ressourcen.

Um zu zeigen, wie ein Schritt in diesem Prozess aussehen könnte, habe ich den Prototyp, den wir gerade durchlaufen haben, aufgeräumt, indem ich alle anfänglichen Variablen an einem Ort gesammelt habe, anstatt wie im Prototyp-Skript überall verstreut zu sein, und seine Ausführungsgeschwindigkeit durch einen aufgerufenen Prozess optimiert Vektorisierung .

Die Verwendung von NumPy-Arrays ermöglicht es Ihnen, viele Arten von Datenverarbeitungsaufgaben als prägnante Array-Ausdrücke auszudrücken, die andernfalls Schreibschleifen erfordern würden. Diese Praxis, explizite Schleifen durch Array-Ausdrücke zu ersetzen, wird allgemein als Vektorisierung bezeichnet. Wes McKinney

Es sieht jetzt sauberer und einfacher zu verstehen aus:

 # Key inputs from DCF model years = 5 starting_sales = 31.0 capex_percent = depr_percent = 0.032 sales_growth = 0.1 ebitda_margin = 0.14 nwc_percent = 0.24 tax_rate = 0.25 # DCF assumptions r = 0.12 g = 0.02 # For MCS model iterations = 1000 sales_std_dev = 0.01 ebitda_std_dev = 0.02 nwc_std_dev = 0.01

 def run_mcs(): # Generate probability distributions sales_growth_dist = np.random.normal(loc=sales_growth, scale=sales_std_dev, size=(years, iterations)) ebitda_margin_dist = np.random.normal(loc=ebitda_margin, scale=ebitda_std_dev, size=(years, iterations)) nwc_percent_dist = np.random.normal(loc=nwc_percent, scale=nwc_std_dev, size=(years, iterations)) # Calculate free cash flow sales_growth_dist += 1 for i in range(1, len(sales_growth_dist)): sales_growth_dist[i] *= sales_growth_dist[i-1] sales = sales_growth_dist * starting_sales ebitda = sales * ebitda_margin_dist ebit = ebitda - (sales * depr_percent) tax = -(ebit * tax_rate) np.clip(tax, a_min=None, a_max=0) nwc = nwc_percent_dist * sales starting_nwc = starting_sales * nwc_percent prev_year_nwc = np.roll(nwc, 1, axis=0) prev_year_nwc[0] = starting_nwc delta_nwc = prev_year_nwc - nwc capex = -(sales * capex_percent) free_cash_flow = ebitda + tax + delta_nwc + capex # Discount cash flows to get DCF value terminal_value = free_cash_flow[-1] * (1 + g) / (r - g) discount_rates = [(1 / (1 + r)) ** i for i in range (1,6)] dcf_value = sum((free_cash_flow.T * discount_rates).T) dcf_value += terminal_value * discount_rates[-1] return dcf_value

Der Hauptunterschied, den Sie zwischen dieser Version und der vorherigen bemerken werden, ist das Fehlen der for i in range(iterations) -Schleife. Unter Verwendung der Array-Operation von NumPy läuft diese Version in 18 Millisekunden im Vergleich zu den 1,35 Sekunden für die Prototypversion – ungefähr 75-mal schneller.

 %time plt.hist(run_mcs(), bins=20, density=True, color="r") plt.show() 

Ich bin mir sicher, dass eine weitere Optimierung möglich ist, da ich allein für dieses Tutorial in kurzer Zeit sowohl den Prototyp als auch die verfeinerte Version zusammengebaut habe.

Es weiter bringen

Dieses Tutorial zeigte einige der leistungsstarken Funktionen von Python, und wenn Sie dies weiterentwickeln, sind die Möglichkeiten nahezu unbegrenzt. Sie könnten zum Beispiel:

• Scrapen oder laden Sie relevante Unternehmens- oder Branchenstatistiken von Webseiten oder anderen Datenquellen herunter, um Ihre Auswahl von Annahmen und Wahrscheinlichkeitsverteilungen zu unterstützen.
• Verwenden Sie Python in quantitativen Finanzanwendungen, z. B. in einem automatisierten Handelsalgorithmus, der auf fundamentalen und/oder makroökonomischen Faktoren basiert.
• Erstellen Sie Exportfunktionen, die Ausgaben in einem Tabellenkalkulations- und/oder Präsentationsformat generieren, die als Teil Ihres internen Transaktionsprüfungs- und Genehmigungsprozesses oder für externe Präsentationen verwendet werden können.

Ich habe noch nicht einmal angesprochen, was Sie mit den verschiedenen Web-, Datenwissenschafts- und maschinellen Lernanwendungen tun könnten, die zum Erfolg von Python beigetragen haben.

Zusammenfassend: Eine nützliche Sprache für Ihre Finanz-Toolbox

Dieser Artikel gab eine Einführung in die Programmiersprache Python, listete einige der Gründe auf, warum sie im Finanzwesen so beliebt geworden ist, und zeigte, wie man ein kleines Python-Skript erstellt. In einem Schritt-für-Schritt-Tutorial ging ich durch, wie Python für iteratives Prototyping, interaktive Finanzanalysen und für Anwendungscode für Bewertungsmodelle, algorithmische Handelsprogramme und mehr verwendet werden kann.

Letztendlich ist für mich das Killer-Feature der Python-Technologie, dass es einfach Spaß macht, damit zu arbeiten! Wenn Sie gerne Probleme lösen, Dinge bauen und Arbeitsabläufe effizienter gestalten, dann ermutige ich Sie, es auszuprobieren. Ich würde gerne hören, was Sie damit gemacht haben oder damit machen möchten.

Empfohlene Ressourcen für Finanzexperten zum Erlernen von Python

• Bücher von O’Reilly. Besonders empfehlen kann ich:
  • Python for Finance by Yves Hilpisch
  • Learning Python by Mark Lutz
  • Fluent Python by Luciano Ramalho
• The Python Quants
• PyCon talks on YouTube
• Udemy