Visualisation du flux d'options avec Python : un guide étape par étape

Dans le monde de la finance en constante évolution, la visualisation des données peut offrir des informations sans précédent sur les tendances du marché. Dans cet article, nous explorerons comment tirer parti de Python pour une tâche d'analyse financière spécifique : visualiser le flux d'options pour une action donnée à l'aide des données historiques de Yahoo Finance. Nous utiliserons un extrait de code qui récupère les données d'options, les traite et génère un nuage de points pour illustrer le flux des options d'achat et de vente. Entrons dans les détails.

Commencer

Notre objectif est d'analyser les données d'options pour un titre particulier et de les visualiser dans un nuage de points. Pour cet exemple, nous utiliserons le symbole boursier LLY (Eli Lilly and Company). L'extrait de code accomplit les tâches suivantes :

1. Récupère les dernières données d'options pour le stock spécifié.
2. Filtre et nettoie les données.
3. Crée un nuage de points pour représenter les options d'achat et de vente au fil du temps.

Répartition étape par étape

1. Importation de bibliothèques

Tout d'abord, nous devons importer les bibliothèques nécessaires :

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

• yfinance est utilisé pour récupérer des données boursières historiques.
• os gère les opérations sur les répertoires et les fichiers.
• datetime et timedelta servent à gérer les dates.
• matplotlib.pyplot sert à créer des visualisations.
• pandas est destiné à la manipulation et à l'analyse des données.

2. Configuration des répertoires et des fichiers

Nous configurons le répertoire de sortie et le fichier où nous enregistrerons nos données :

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

Ici, nous nous assurons que le répertoire de sortie existe et spécifions le chemin du fichier de données.

3. Récupération et traitement des données d'options

Pour obtenir les données d'options pour le ticker LLY, nous utilisons yfinance :

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

Si populate_data est défini sur « Y », le code récupère de nouvelles données d'options. Si 'N', il utilisera le fichier de données existant.

Voici comment la récupération et le traitement des données sont effectués :

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}")

Ce code récupère les données des options d'appel et de vente, filtre les lignes contenant des données de volume indésirables et les écrit dans un fichier.

4. Nettoyage et préparation des données pour la visualisation

Ensuite, nous lisons les données et les nettoyons :

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()]

Nous nous assurons que notre ensemble de données est exempt de valeurs NaN et que Last_Trade_Date est au format datetime correct.

5. Création du nuage de points

Nous sommes prêts à créer notre nuage de points :

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}")

Ce segment crée un nuage de points d'options d'achat et de vente, avec les prix d'exercice sur l'axe des y et les dates de négociation sur l'axe des x. La taille des points représente le volume des transactions, le vert indiquant les appels et le rouge indiquant les options de vente. Nous ajoutons également des filigranes à des fins de personnalisation et enregistrons l'intrigue dans un fichier.

Conclusion

La visualisation des données sur les options aide les traders et les analystes à comprendre le sentiment du marché et l'activité de trading. Ce guide a montré comment récupérer, traiter et visualiser les données d'options à l'aide de Python. En suivant ces étapes, vous pouvez adapter ce code à n'importe quelle action et analyser son flux d'options, fournissant ainsi des informations précieuses sur les tendances du marché.

N'hésitez pas à modifier le code pour l'adapter à vos besoins spécifiques et explorer différentes façons de visualiser les données financières.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!