Visualisieren des Optionsflusses mit Python: Eine Schritt-für-Schritt-Anleitung

In der sich ständig weiterentwickelnden Finanzwelt kann die Visualisierung von Daten beispiellose Einblicke in Markttrends bieten. In diesem Artikel untersuchen wir, wie Sie Python für eine bestimmte Finanzanalyseaufgabe nutzen können: Visualisierung des Optionsflusses für eine bestimmte Aktie mithilfe historischer Daten von Yahoo Finance. Wir verwenden einen Codeausschnitt, der Optionsdaten abruft, verarbeitet und ein Streudiagramm generiert, um den Fluss von Call- und Put-Optionen zu veranschaulichen. Lassen Sie uns in die Details eintauchen.

Erste Schritte

Unser Ziel ist es, die Optionsdaten für eine bestimmte Aktie zu analysieren und in einem Streudiagramm darzustellen. Für dieses Beispiel verwenden wir den Börsenticker LLY (Eli Lilly and Company). Das Code-Snippet bewirkt Folgendes:

1. Ruft die neuesten Optionsdaten für die angegebene Aktie ab.
2. Filtert und bereinigt die Daten.
3. Erstellt ein Streudiagramm, um Call- und Put-Optionen im Zeitverlauf darzustellen.

Schritt-für-Schritt-Aufschlüsselung

1. Bibliotheken importieren

Zuerst müssen wir die notwendigen Bibliotheken importieren:

import yfinance as yf
import os
from datetime import datetime, timedelta
import matplotlib.pyplot as plt
import pandas as pd

• yfinance wird verwendet, um historische Bestandsdaten abzurufen.
• Das Betriebssystem übernimmt Verzeichnis- und Dateivorgänge.
• datetime und timedelta dienen der Verwaltung von Daten.
• matplotlib.pyplot dient zum Erstellen von Visualisierungen.
• Pandas dient der Datenmanipulation und -analyse.

2. Verzeichnisse und Dateien einrichten

Wir richten das Ausgabeverzeichnis und die Datei ein, in der wir unsere Daten speichern:

output_directory = 'output'
os.makedirs(output_directory, exist_ok=True)
output_file = os.path.join(output_directory, 'output.data')

Hier stellen wir sicher, dass das Ausgabeverzeichnis existiert und geben den Pfad für die Datendatei an.

3. Abrufen und Verarbeiten von Optionsdaten

Um Optionsdaten für den Ticker LLY zu erhalten, verwenden wir yfinance:

ticker = 'LLY'
days = 21
populate_data = 'Y'  # Set 'N' to use existing file, 'Y' to create new file

Wenn populate_data auf „Y“ gesetzt ist, ruft der Code neue Optionsdaten ab. Bei „N“ wird die vorhandene Datendatei verwendet.

So erfolgt das Abrufen und Verarbeiten der Daten:

if populate_data == 'Y':
    stock = yf.Ticker(ticker)
    options_dates = stock.options

    today = datetime.now()
    fourteen_days_later = today + timedelta(days)

    with open(output_file, 'w') as file:
        for date in options_dates:
            date_dt = datetime.strptime(date, '%Y-%m-%d')
            if today <= date_dt <= fourteen_days_later:
                calls = stock.option_chain(date).calls
                puts = stock.option_chain(date).puts

                for _, row in calls.iterrows():
                    if not filter_volume(row['volume']):
                        file.write(f"Call,{date},{row['strike']},{row['volume']}\n")

                for _, row in puts.iterrows():
                    if not filter_volume(row['volume']):
                        file.write(f"Put,{date},{row['strike']},{row['volume']}\n")

    print(f"Data has been written to {output_file}")

Dieser Code ruft Call- und Put-Optionsdaten ab, filtert Zeilen mit unerwünschten Volumendaten heraus und schreibt sie in eine Datei.

4. Bereinigen und Vorbereiten von Daten für die Visualisierung

Als nächstes lesen wir die Daten und bereinigen sie:

data = pd.read_csv(output_file, names=['Type', 'Last_Trade_Date', 'Strike', 'Volume'])
data.dropna(inplace=True)
data['Last_Trade_Date'] = pd.to_datetime(data['Last_Trade_Date'])
data = data[data['Volume'].notna()]

Wir stellen sicher, dass unser Datensatz frei von NaN-Werten ist und dass das Last_Trade_Date im richtigen Datum-Uhrzeit-Format vorliegt.

5. Erstellen des Streudiagramms

Wir sind bereit, unser Streudiagramm zu erstellen:

extra_days_before = 5
extra_days_after = 5

min_date = data['Last_Trade_Date'].min() - timedelta(days=extra_days_before)
max_date = data['Last_Trade_Date'].max() + timedelta(days=extra_days_after)

plt.figure(figsize=(12, 8))

calls_data = data[data['Type'] == 'Call']
plt.scatter(calls_data['Last_Trade_Date'], calls_data['Strike'],
            s=calls_data['Volume'], c='green', alpha=0.6, label='Call')

puts_data = data[data['Type'] == 'Put']
plt.scatter(puts_data['Last_Trade_Date'], puts_data['Strike'],
            s=puts_data['Volume'], c='red', alpha=0.6, label='Put')

plt.xlabel('\nLast Trade Date')
plt.ylabel('Strike Price\n')
plt.title(f'Options Flow for {ticker} ({days} days)\n', fontsize=16)
plt.xticks(rotation=45, ha='right')
plt.gca().xaxis.set_major_formatter(plt.matplotlib.dates.DateFormatter('%Y-%m-%d'))
plt.xlim(min_date, max_date)
plt.subplots_adjust(bottom=0.2)
plt.grid(True)

plt.text(0.5, 0.5, f'{ticker}', color='gray', fontsize=80, alpha=0.5,
         ha='center', va='center', rotation=15, transform=plt.gca().transAxes)
plt.text(0.95, 0.95, 'medium.com/@dmitry.romanoff', color='gray', fontsize=20, alpha=0.5,
         ha='right', va='top', transform=plt.gca().transAxes)
plt.text(0.05, 0.05, 'medium.com/@dmitry.romanoff', color='gray', fontsize=20, alpha=0.5,
         ha='left', va='bottom', transform=plt.gca().transAxes)

plot_file = os.path.join(output_directory, 'options_scatter_plot.png')
plt.savefig(plot_file)

print(f"Scatter plot has been saved to {plot_file}")

Dieses Segment erstellt ein Streudiagramm von Call- und Put-Optionen mit Ausübungspreisen auf der y-Achse und Handelsdaten auf der x-Achse. Die Größe der Punkte stellt das Handelsvolumen dar, wobei Grün für Calls und Rot für Puts steht. Wir fügen auch Wasserzeichen für Branding-Zwecke hinzu und speichern den Plot in einer Datei.

Abschluss

Die Visualisierung von Optionsdaten hilft Händlern und Analysten, die Marktstimmung und Handelsaktivität zu verstehen. In dieser Anleitung wurde gezeigt, wie Optionsdaten mit Python abgerufen, verarbeitet und visualisiert werden. Wenn Sie diese Schritte befolgen, können Sie diesen Code für jede Aktie anpassen und deren Optionsfluss analysieren, um wertvolle Einblicke in Markttrends zu erhalten.

Fühlen Sie sich frei, den Code an Ihre spezifischen Bedürfnisse anzupassen und verschiedene Möglichkeiten zur Visualisierung von Finanzdaten zu erkunden.

Das obige ist der detaillierte Inhalt vonVisualisieren des Optionsflusses mit Python: Eine Schritt-für-Schritt-Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!