Trading algoritmico con Python - pagina 15
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Calcola i rendimenti, crea una matrice di correlazione, traccia le prestazioni || Analisi delle scorte con Python Parte 5
Calcola i rendimenti, crea una matrice di correlazione, traccia le prestazioni || Analisi delle scorte con Python Parte 5
Benvenuti alla quinta parte della mia serie sull'utilizzo di Python per l'analisi delle azioni. Nella descrizione del video troverai collegamenti alle quattro parti precedenti e un collegamento al repository GitHub dove puoi accedere al codice.
Nella quarta parte, abbiamo ottenuto i prezzi di chiusura dei titoli selezionati e li abbiamo salvati in un file. Ora, nella quinta parte, ci concentreremo sul calcolo dei rendimenti sulla base di questi prezzi di chiusura. Prima di procedere, dobbiamo importare la libreria NumPy.
Creeremo una funzione chiamata "calculate_returns" che accetta una cartella e un nome di file come input. Per gestire potenziali errori, useremo un blocco try-except. All'interno della funzione, useremo i panda per leggere i dati da un file CSV. Imposteremo la colonna dell'indice sulla data e restituiremo il DataFrame dei ritorni.
Possiamo testare la funzione stampando il risultato, passando il nome della cartella e il nome del file. Nell'esempio mostrato, calcola correttamente i rendimenti per i titoli selezionati.
Da qui, ci sono diversi possibili passaggi successivi. Un compito comune è calcolare le correlazioni tra i titoli. Sebbene non mi addentrerò nell'implementazione specifica, è possibile utilizzare il risultato della funzione precedente per creare una funzione per il calcolo delle correlazioni. È possibile esplorare diverse opzioni, come la lettura dei dati da un file (ad esempio, Excel o CSV) per migliorare la flessibilità.
Un'altra funzione utile che possiamo scrivere è quella per tracciare i prezzi di chiusura. Per questo, dobbiamo importare la libreria matplotlib. La funzione "plot_closes" accetta le chiusure come input, che possono essere un file CSV o Excel. Inoltre, possiamo scegliere di tracciare i prezzi rispetto al prezzo di partenza.
All'interno della funzione, leggiamo i dati utilizzando i panda e, in base al parametro relativo, tracciamo i prezzi così come sono o tracciamo la performance relativa al prezzo di partenza. Possiamo personalizzare la trama con opzioni come linee della griglia e una linea orizzontale a zero (o uno, a seconda della rappresentazione desiderata).
Testando la funzione, possiamo vedere il grafico risultante per i titoli selezionati. Impostando il parametro relativo a true, possiamo osservare la performance relativa al prezzo di partenza.
Nella sesta parte, continueremo a lavorare con i prezzi di chiusura e le modifiche, concentrandoci sul salvataggio dei dati in un file separato.Scarica, trasforma e scrivi dati in Excel con Python || Analisi delle scorte con Python Parte 6
Scarica, trasforma e scrivi dati in Excel con Python || Analisi delle scorte con Python Parte 6
Benvenuti alla sesta parte della mia serie sull'analisi delle azioni con Python. Nella descrizione del video troverai collegamenti ai cinque video precedenti, oltre a un collegamento al repository GitHub contenente il codice.
Nella parte precedente, abbiamo esplorato diversi modi per tracciare i prezzi di chiusura per azioni selezionate. Ora, nella sesta parte, adotteremo un approccio diverso per ottenere dati e lavorare con i file Excel. Creeremo una funzione chiamata "get_return_data" che accetta almeno un ticker come input (più ticker possono essere separati da virgole o archiviati in un oggetto di raccolta Python). Inoltre, la funzione consente agli utenti di specificare una data e scegliere tra i prezzi di chiusura o di chiusura rettificati. I dati verranno salvati in un file Excel e possono anche essere memorizzati in una variabile.
Per iniziare, dobbiamo configurare il client API. Come prima, utilizzeremo l'API "dati storici di fine giornata". Dovrai sostituire la variabile "key" con la tua chiave API.
Successivamente, creiamo un DataFrame temporaneo per archiviare i dati scaricati. Eseguiamo il ciclo dei ticker passati alla funzione e utilizziamo un blocco try-except per gestire eventuali errori potenziali. A seconda che l'utente desideri prezzi di chiusura o di chiusura rettificati, aggiungiamo la colonna corrispondente dal risultato della chiamata API alla colonna ticker nel DataFrame.
Dopo aver scaricato e archiviato i dati, possiamo eseguire le trasformazioni desiderate. In questo caso, calcoliamo il tasso di rendimento istantaneo utilizzando NumPy e scartiamo la prima riga. Calcoliamo anche la variazione percentuale regolare utilizzando un metodo integrato.
Infine, scriviamo i dati in un file Excel utilizzando l'oggetto di scrittura panda Excel all'interno di un gestore di contesto. Questo passaggio richiede di fornire il nome del file e il formato della data facoltativo. Ogni variabile viene inserita nel file "returns" e viene stampato un messaggio per indicare il completamento dell'attività. La funzione restituisce i prezzi di chiusura e può essere espansa per restituire anche altri dati.
Testando la funzione con quattro ticker, possiamo vedere il file generato contenente i dati scaricati. Il file può essere aperto in Excel per visualizzare i dati.
Questo conclude la sesta parte della serie. Nella settima parte, esploreremo come tracciare le performance di più azioni in una singola cifra.
Python per l'analisi delle azioni: tracciare la griglia delle prestazioni di più titoli w\matplotlib || Parte 7
Python per l'analisi delle azioni: tracciare la griglia delle prestazioni di più titoli w\matplotlib || Parte 7
Benvenuti alla settima parte della mia serie sull'utilizzo di Python per l'analisi delle azioni. Nella descrizione del video troverai collegamenti ai sei video precedenti e al repository GitHub contenente il codice.
Nella sesta parte, abbiamo sviluppato una funzione per scaricare dati, eseguire trasformazioni e salvarli in un file Excel. Ora, nella settima parte, ci concentreremo sul tracciare le performance relative di più azioni su un singolo grafico.
Per iniziare, leggeremo tutti i file in una cartella specifica. In questo caso, cercheremo nella cartella "energia". Salteremo tutti i file che iniziano con zero.
Usando la libreria matplotlib, creeremo un oggetto sottotrama. Il numero di righe sarà determinato dal massimale della lunghezza dei file diviso per quattro, in quanto vogliamo visualizzare quattro grafici per riga. Renderemo la cifra grande per ospitare potenzialmente molti grafici.
Successivamente, terremo traccia del numero di grafici aggiunti e utilizzeremo un ciclo for nidificato per scorrere le righe e le colonne della figura. Se raggiungiamo l'ultima riga e non è piena, gestiremo l'eccezione incrementando il conteggio.
All'interno del ciclo, leggeremo i prezzi di chiusura di ciascun file e trasformeremo i dati in prestazioni relative. Tracceremo le prestazioni relative negli assi corrispondenti e aggiungeremo una linea orizzontale a 0. Per formattare i dati come percentuale, importeremo il modulo ticker da matplotlib.
Nel blocco delle eccezioni, non intraprenderemo alcuna azione, poiché sappiamo di aver esaurito i dati da tracciare. Passeremo semplicemente e incrementeremo il conteggio per passare al file successivo.
Una volta che tutti i dati sono stati tracciati, mostreremo il grafico.
Testando il codice con i file presenti nella cartella "energy", possiamo vedere il grafico risultante che mostra le performance relative di 21 titoli nell'arco di circa un anno.
Questo conclude la settima parte della serie. Nel prossimo video, esploreremo ulteriori tagli di dati dall'API dei dati storici di fine giornata.Scarica l'elenco delle azioni in procinto di annunciare guadagni o dividendi || Analisi delle scorte con Python Parte 8
Scarica l'elenco delle azioni in procinto di annunciare guadagni o dividendi || Analisi delle scorte con Python Parte 8
Benvenuti all'ottava parte della mia serie sull'utilizzo di Python per l'analisi delle azioni. In questo video, approfondiremo l'API dei dati storici di fine giornata ed esploreremo funzionalità aggiuntive oltre al recupero dei prezzi. L'API è completa e, sebbene non tratteremo tutto, ti mostrerò un paio di esempi che potresti trovare utili. La documentazione fornita dall'API è ampia e può guidarti nell'esplorazione di diversi set di dati.
In primo luogo, ci concentreremo sull'ottenimento dei dati sugli utili per le società che segnalano questa settimana. Per iniziare, inizializzeremo il nostro client API passando la nostra chiave API (sostituirla con la tua). Quindi scaricheremo i dati e li memorizzeremo in un DataFrame.
La funzione che useremo per questa attività non richiede alcun parametro. Una volta ottenuto il DataFrame, estraiamo i simboli delle aziende che riportano i guadagni questa settimana e li memorizzeremo in un elenco.
Per filtrare i dati per uno scambio specifico, come gli Stati Uniti, eseguiremo un ciclo su ogni riga nel DataFrame e verificheremo se il simbolo termina con "noi". I simboli azionari sono indicati come codici nei dati storici di fine giornata e le loro terminazioni corrispondono alla borsa a cui appartengono. Aggiungeremo i simboli pertinenti al nostro elenco, escludendo le informazioni di scambio.
Dopo aver passato in rassegna tutte le righe, stamperemo il numero di società che riportano gli utili questa settimana e restituiremo l'elenco dei simboli per ulteriori analisi.
Andando avanti, esploriamo come recuperare i dividendi per una specifica data di scadenza. Inizieremo con la data di oggi. L'impostazione della funzione sarà simile alla precedente, dove creiamo un client API e scarichiamo i dati in un DataFrame.
La funzione che useremo questa volta si chiama get_bulk_market. Da questa funzione è possibile ottenere vari punti dati, inclusi i prezzi di chiusura per un intero mercato. Per i dividendi, specificheremo i dati che ci interessano come "dividendi".
Dopo aver effettuato la chiamata, restituiremo il DataFrame risultante.
Testando questa funzione, recupereremo i dividendi con la data di stacco odierna. Il codice stamperà i dividendi, assumendo i valori di default per il mercato statunitense e la data odierna.
Il DataFrame risultante visualizzerà i dividendi con i rispettivi tassi. Dal momento che stiamo guardando al mercato statunitense, i dividendi saranno in dollari USA. Inoltre, il DataFrame fornisce informazioni sulla frequenza dei pagamenti dei dividendi.
Questo conclude l'ottava parte. Nella parte nove, concluderemo la sezione uno costruendo un semplice screener.Come creare un Stock Screener utilizzando un'API || Analisi delle scorte con Python Parte 9
Come creare un Stock Screener utilizzando un'API || Analisi delle scorte con Python Parte 9
Questa è la parte 9 della nostra serie sull'analisi delle azioni con Python. Puoi trovare i collegamenti ai video precedenti nella descrizione, così come il codice su GitHub.
In questo segmento finale della sezione 1, esploreremo un esempio di stock screener. L'obiettivo è creare un semplice screener che analizzi il massimo di 52 settimane, il prezzo corrente e il rapporto prezzo/utili di più titoli. Questo ci aiuterà a identificare i titoli per ulteriori analisi.
Per fare ciò, utilizzeremo il feed fondamentale dei dati storici di fine giornata. Iniziamo esaminando i dati che otteniamo da una chiamata a questo feed. Creeremo un oggetto client e recupereremo i dati fondamentali per una sicurezza specifica, come Apple. Questo ci darà un ampio frame di dati con varie informazioni, inclusi dati finanziari, bilanci e altro. Possiamo esplorare sezioni specifiche utilizzando le posizioni dell'indice.
Successivamente, ci concentreremo sugli aspetti tecnici dell'indice e utilizzeremo sia la libreria di dati storici di fine giornata che un endpoint per scaricare in blocco i prezzi di chiusura per il giorno più recente. Memorizzeremo i dati in un frame di dati e resetteremo l'indice. Questa chiamata recupera i prezzi di chiusura per tutti i titoli sulla borsa statunitense. Possiamo quindi filtrare i dati per includere solo i titoli che ci interessano.
Per creare il nostro stock screener, creeremo un client e passeremo in rassegna i simboli che vogliamo analizzare. Popoleremo un dizionario con il massimo di 52 settimane per ogni titolo. Se un titolo non dispone di queste informazioni, lo salteremo e continueremo il ciclo.
Dopo aver ottenuto i dati necessari, uniremo i prezzi di chiusura, i massimi di 52 settimane e calcoleremo il rapporto prezzo/utili. Restituiremo il frame di dati risultante contenente i titoli, i loro prezzi di chiusura, massimi e rapporti.
Per testare il nostro screener, recupereremo i simboli dall'S&P 500 utilizzando la funzione get_sp e stamperemo il risultato. Questo mostrerà i prezzi di chiusura, i massimi di 52 settimane e i rapporti per i primi 10 titoli dell'S&P 500.
Nella Parte 10, approfondiremo l'analisi dei singoli titoli mentre iniziamo a creare una classe a tale scopo. Unisciti a noi per la parte successiva per saperne di più sull'analisi dei titoli a livello individuale.
Stock Analysis Python: come analizzare automaticamente le azioni con Python || Parte 10
Stock Analysis Python: come analizzare automaticamente le azioni con Python || Parte 10
Questa sarà la parte 10 della mia serie su Python per l'analisi delle azioni. Puoi trovare i collegamenti ai video precedenti nella descrizione sottostante, nonché un collegamento al repository GitHub dove è disponibile tutto il codice. In questa parte, inizieremo a concentrarci sui singoli titoli anziché su intere borse valori o grandi elenchi di simboli azionari.
Per iniziare, ho già incluso le importazioni necessarie per questa parte, come datetime, matplotlib, numpy, pandas e seaborn. Ho anche definito una costante simbolica che rappresenta una data di circa un anno fa, che può essere modificata dall'utente utilizzando una data in formato ISO.
Successivamente, scriverò una classe chiamata "Stock" che gestirà i singoli titoli. La classe verrà inizializzata con i parametri per il simbolo azionario, la chiave API e la data (con un valore predefinito). Inoltre, consentirà all'utente di specificare una cartella in cui i dati possono essere salvati, con un valore predefinito di Nessuno.
All'interno della classe, definirò un metodo chiamato "get_data" che recupererà i dati di borsa. Verificherà innanzitutto se i dati sono già disponibili nella cartella specificata confrontando il simbolo con i file disponibili. Se i dati vengono trovati, verranno letti in un DataFrame e standardizzati. In caso contrario, recupererà i dati utilizzando l'API e li restituirà come DataFrame.
Inizializzando un'istanza Stock, il simbolo, la chiave API, la data e i dati verranno archiviati come variabili di istanza. Per testare la funzionalità, creerò un oggetto Stock e stamperò i dati.
Questo conclude la parte 10 della serie. Nella Parte 11, aggiungeremo altre trasformazioni di dati alla classe Stock.Python per l'analisi delle azioni: calcola automaticamente e rappresenta graficamente i rendimenti e la volatilità delle azioni || Parte 11
Python per l'analisi delle azioni: calcola automaticamente e rappresenta graficamente i rendimenti e la volatilità delle azioni || Parte 11
Benvenuti nella parte 11 della mia serie su Python per l'analisi delle azioni. Puoi trovare i collegamenti ai video precedenti e al repository GitHub nella descrizione qui sotto.
Nella parte 10, abbiamo creato una semplice classe per inizializzare un simbolo di borsa e recuperare i suoi dati da una cartella locale o tramite un'API. In questa parte, approfondiremo ulteriormente le trasformazioni dei dati e inizieremo a tracciare i dati.
Innanzitutto, aggiungerò un nuovo metodo chiamato "calculate_volatility" che accetta un DataFrame come input. Per integrare questo metodo con il metodo "get_data", lo modificherò di conseguenza. All'interno del metodo "calculate_volatility", aggiungerò diverse colonne al DataFrame. La prima colonna saranno i rendimenti, calcolati come differenza logaritmica dei prezzi di chiusura con precisione al quarto decimale.
Successivamente, calcolerò la volatilità mobile, che rappresenta la deviazione standard dei rendimenti su un periodo di 21 giorni. Arrotondo il risultato a quattro decimali. Inoltre, includerò le colonne di variazione assoluta, spread alto-basso e variazione prevista, con l'arrotondamento appropriato.
Per analizzare l'entità del movimento del titolo, calcolerò una colonna chiamata "magnitudine" che rappresenta la variazione effettiva divisa per la variazione prevista, arrotondata a due decimali. Infine, includerò una colonna di valore assoluto per potenziali scopi grafici.
Lascerò cadere le righe iniziali che contengono i valori NaN risultanti dai calcoli, quindi chiamerò il metodo "calculate_volatility" all'interno del metodo "get_data".
Testiamo il codice inizializzando un'istanza Stock e stampando il DataFrame.
Ora tracciamo la distribuzione dei rendimenti creando un istogramma. Determinare le date di inizio e di fine, quindi tracciare l'istogramma con 20 bin e un colore del bordo. Per migliorare il titolo, userò un sopratitolo con due righe, specificando l'intervallo di date. Infine, mostrerò la trama.
Eseguiamo il codice ed esaminiamo l'istogramma, che fornisce una panoramica della distribuzione dei rendimenti del titolo nell'ultimo anno.
Questo conclude la Parte 11. Nella Parte 12, continueremo a lavorare su grafici aggiuntivi prima di passare ad altre trasformazioni di dati.Come calcolare e normalizzare i rendimenti azionari attesi || Analisi delle azioni Python Parte 12
Come calcolare e normalizzare i rendimenti azionari attesi || Analisi delle azioni Python Parte 12
Benvenuti alla parte 12 della mia serie su Python per l'analisi delle azioni. Puoi trovare il codice e i link ad altri video nella descrizione qui sotto.
Nella Parte 11, abbiamo eseguito trasformazioni di dati di base nella nostra classe Stock aggiungendo colonne al DataFrame e tracciando la distribuzione dei rendimenti. In questo video, continueremo con altre opzioni di tracciamento che potrebbero essere utili per l'analisi delle azioni.
Per iniziare, tracciamo la volatilità del titolo. La configurazione sarà simile a quella che abbiamo fatto prima, incluso il super titolo e le date di inizio e fine. Creeremo un grafico a dispersione, dove l'asse x rappresenta i rendimenti e l'asse y rappresenta l'entità assoluta della variazione delle deviazioni standard. Aggiungeremo linee orizzontali e verticali come riferimento.
Eseguiamo il codice ed esaminiamo il grafico a dispersione della volatilità. Possiamo osservare l'intervallo di variazioni percentuali e il numero di deviazioni standard. Ad esempio, nell'ultimo anno non ci sono stati cambiamenti oltre le tre deviazioni standard e mezzo.
Successivamente, tracciamo la performance del titolo. Ancora una volta, la maggior parte del codice rimane la stessa, quindi possiamo copiarlo e apportare alcune modifiche. Invece di un grafico a dispersione, creeremo un grafico a linee per tenere traccia delle prestazioni relative nel tempo. Divideremo i prezzi di chiusura per il prezzo di chiusura del primo giorno, sottraiamo 1 per ottenere la variazione percentuale, moltiplichiamo per 100 e formattiamola come percentuale sull'asse y. Manterremo la linea orizzontale come riferimento.
L'esecuzione del codice visualizzerà il grafico a linee della performance del titolo. Possiamo vedere come si è comportato il titolo nel periodo di tempo specificato, confrontandolo con il prezzo di partenza. In questo caso, possiamo osservare un trend positivo seguito da un calo negli ultimi mesi.
Sentiti libero di personalizzare le dimensioni della figura ed esplorare altre opzioni di trama in base alle tue esigenze.
Questo conclude la Parte 12. Nella Parte 13, ci immergeremo in ulteriori trasformazioni dei dati.Python per l'analisi delle azioni: filtra i dati per scadenza e volatilità delle opzioni || Parte 13
Python per l'analisi delle azioni: filtra i dati per scadenza e volatilità delle opzioni || Parte 13
Benvenuti alla parte 13 della mia serie su Python per l'analisi delle azioni. Puoi trovare il codice e i link ad altri video su GitHub nella descrizione qui sotto.
Nella Parte 12, abbiamo esplorato vari grafici che potrebbero essere utili per l'analisi delle azioni. In questo video, estenderemo la nostra classe Stock aggiungendo un paio di metodi per esaminare diverse porzioni di dati.
Innanzitutto, scriviamo un metodo per identificare i giorni in cui le opzioni scadono. Questi sono i terzi venerdì di ogni mese. Chiameremo questo metodo "option_expiration". Per fare ciò, creeremo una maschera usando la funzione np.where di NumPy. Specifichiamo tre condizioni: l'indice dei dati deve essere maggiore del 14° (primo terzo venerdì possibile), minore del 21° (ultimo terzo venerdì possibile) e corrispondere ad un venerdì (giorno della settimana 4). Restituiremo i dati con questa maschera applicata, risultando in un DataFrame che include solo i venerdì di scadenza.
Successivamente, scriveremo il nostro metodo finale, che determina per quanto tempo è durata la bassa volatilità dalle ultime due deviazioni standard. Chiameremo questo metodo "low_vol_duration". Per implementare ciò, aggiungeremo una colonna ai dati denominata "giorni inferiori a 2 deviazioni standard" e la inizializzeremo con zeri. Quindi, itereremo sui dati e controlleremo la grandezza di ogni riga. Se la magnitudine è inferiore a due, incrementeremo il conteggio e aggiorneremo la riga corrispondente nella colonna "giorni inferiori a 2 deviazioni standard". Se la magnitudine è pari o superiore a due, reimposteremo il conteggio a zero. Infine, restituiremo il DataFrame contenente solo le righe con due spostamenti di deviazione standard, mostrando il numero di giorni tra ogni spostamento.
Eseguiamo il codice ed esaminiamo i risultati. Possiamo vedere i giorni di scadenza dell'opzione, che cadono tra il 15 e il 21 di ogni mese. Inoltre, abbiamo la durata della bassa volatilità, che indica il numero di giorni trascorsi dalle due deviazioni standard precedenti. Ad esempio, circa un anno fa, erano trascorsi due giorni dal precedente spostamento delle due deviazioni standard, seguiti da periodi di 32, 41 e così via.
Questo conclude la Parte 13 e conclude la Sezione 2. Ti incoraggio a continuare a sviluppare ed espandere la classe Stock in base alle tue esigenze. Nella Parte 14, esploreremo come impacchettare le nostre funzioni in un pacchetto Python che può essere installato usando pip.Analisi delle azioni Python: crea e pubblica i tuoi pacchetti Python personalizzati con Pip in VS Code
Analisi delle azioni Python: crea e pubblica i tuoi pacchetti Python personalizzati con Pip in VS Code
In questo video, ti guiderò attraverso il processo di impacchettamento del tuo codice Python in una libreria che può essere installata usando pip. Questo è il video finale della mia serie su Python per l'analisi delle azioni, in cui abbiamo trattato argomenti come il recupero dei dati, la trasformazione dei dati, la visualizzazione e lo screening dei dati. Puoi trovare collegamenti ai video precedenti nella descrizione di seguito, nonché un collegamento al repository GitHub.
L'obiettivo di impacchettare il nostro codice è renderlo più comodo da usare e riutilizzare in specifici progetti Python. Anche se dimostrerò il processo come se stessimo pubblicando il codice su PyPI (Python Package Index), è importante notare che il codice potrebbe non essere pronto per PyPI immediatamente. Per prima cosa lo configureremo e lo installeremo localmente per comprendere il processo. Tuttavia, in futuro, potresti modificare il codice e creare qualcosa che vorresti condividere con un pubblico più ampio.
Il processo di confezionamento può variare a seconda della complessità del progetto. Nel nostro caso, poiché il nostro codice è composto da due moduli, il processo è relativamente semplice. Ecco una panoramica dei passaggi:
Dopo aver impostato le cartelle e i file di configurazione, è possibile installare la libreria in locale utilizzando pip. Apri la riga di comando, vai alla cartella principale ed esegui il comando "pip install .". Questo installerà la libreria, rendendola accessibile da qualsiasi ambiente Python.
Dopo l'installazione, puoi testare la libreria avviando Python e importando il modulo "analyze". Puoi anche utilizzare la funzione "help" per visualizzare i metadati relativi al pacchetto.
Tenere presente che il processo di creazione del pacchetto può evolvere nel tempo e che esistono diversi modi per creare un pacchetto del codice per l'installazione. I passaggi che ho delineato qui sono un punto di partenza e puoi esplorare opzioni aggiuntive man mano che i tuoi progetti diventano più complessi.
Spero che questo tutorial ti aiuti a iniziare a creare i tuoi pacchetti Python.