Python dans le Trading Algorithmique - page 15
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Télécharger, transformer et écrire des données dans Excel avec Python || Analyse des stocks avec Python Partie 6
Télécharger, transformer et écrire des données dans Excel avec Python || Analyse des stocks avec Python Partie 6
Bienvenue dans la sixième partie de ma série sur l'analyse des stocks avec Python. Dans la description de la vidéo, vous trouverez des liens vers les cinq vidéos précédentes, ainsi qu'un lien vers le référentiel GitHub contenant le code.
Dans la partie précédente, nous avons exploré différentes façons de tracer les cours de clôture pour les actions sélectionnées. Maintenant, dans la sixième partie, nous adopterons une approche différente pour obtenir des données et travailler avec des fichiers Excel. Nous allons créer une fonction appelée "get_return_data" qui prend au moins un ticker en entrée (plusieurs tickers peuvent être séparés par des virgules ou stockés dans un objet de collection Python). De plus, la fonction permet aux utilisateurs de spécifier une date et de choisir entre les prix de clôture ou ajustés. Les données seront enregistrées dans un fichier Excel et peuvent également être stockées dans une variable.
Pour commencer, nous devons configurer le client API. Comme précédemment, nous utiliserons l'API "données historiques de fin de journée". Vous devrez remplacer la variable "key" par votre propre clé API.
Ensuite, nous créons un DataFrame temporaire pour stocker les données téléchargées. Nous effectuons une boucle sur les tickers transmis à la fonction et utilisons un bloc try-except pour gérer les erreurs potentielles. Selon que l'utilisateur souhaite des prix de clôture ou de clôture ajustés, nous ajoutons la colonne correspondante du résultat de l'appel d'API à la colonne du ticker dans le DataFrame.
Une fois que nous avons téléchargé et stocké les données, nous pouvons effectuer toutes les transformations souhaitées. Dans ce cas, nous calculons le taux de rendement instantané à l'aide de NumPy et supprimons la première ligne. Nous calculons également la variation régulière en pourcentage à l'aide d'une méthode intégrée.
Enfin, nous écrivons les données dans un fichier Excel à l'aide de l'objet d'écriture pandas Excel dans un gestionnaire de contexte. Cette étape nécessite de fournir le nom du fichier et le format de date facultatif. Chaque variable est insérée dans le fichier "retours", et un message est imprimé pour indiquer l'achèvement de la tâche. La fonction renvoie les cours de clôture et peut être étendue pour renvoyer également d'autres données.
En testant la fonction avec quatre tickers, nous pouvons voir le fichier généré contenant les données téléchargées. Le fichier peut être ouvert dans Excel pour visualiser les données.
Cela conclut la sixième partie de la série. Dans la septième partie, nous verrons comment tracer les performances de plusieurs actions en un seul chiffre.
Python pour l'analyse des actions : grille de performances de traçage de plusieurs titres w\matplotlib || Partie 7
Python pour l'analyse des actions : grille de performances de traçage de plusieurs titres w\matplotlib || Partie 7
Bienvenue dans la septième partie de ma série sur l'utilisation de Python pour l'analyse des stocks. Dans la description de la vidéo, vous trouverez des liens vers les six vidéos précédentes ainsi que le référentiel GitHub contenant le code.
Dans la sixième partie, nous avons développé une fonction pour télécharger des données, effectuer des transformations et les enregistrer dans un fichier Excel. Maintenant, dans la septième partie, nous allons nous concentrer sur le traçage des performances relatives de plusieurs actions sur un seul graphique.
Pour commencer, nous allons lire tous les fichiers dans un dossier spécifique. Dans ce cas, nous allons chercher dans le dossier "énergie". Nous allons ignorer tous les fichiers commençant par zéro.
À l'aide de la bibliothèque matplotlib, nous allons créer un objet sous-intrigue. Le nombre de lignes sera déterminé par le plafond de la longueur des fichiers divisé par quatre, car nous voulons afficher quatre graphiques par ligne. Nous allons agrandir la figure pour accueillir potentiellement de nombreux graphiques.
Ensuite, nous garderons une trace du nombre de graphiques ajoutés et utiliserons une boucle for imbriquée pour parcourir les lignes et les colonnes de la figure. Si nous atteignons la dernière ligne et qu'elle n'est pas pleine, nous gérerons l'exception en incrémentant le nombre.
Dans la boucle, nous lirons les cours de clôture de chaque fichier et transformerons les données en performances relatives. Nous allons tracer les performances relatives dans les axes correspondants et ajouter une ligne horizontale à 0. Pour formater les données en pourcentage, nous allons importer le module ticker de matplotlib.
Dans le bloc d'exception, nous n'entreprendrons aucune action, car nous savons que nous n'avons plus de données à tracer. Nous allons simplement passer et incrémenter le décompte pour passer au fichier suivant.
Une fois que toutes les données ont été tracées, nous afficherons le graphique.
En testant le code avec les fichiers du dossier "energy", nous pouvons voir le graphique résultant affichant les performances relatives de 21 titres sur environ un an.
Cela conclut la septième partie de la série. Dans la vidéo suivante, nous explorerons des coupes de données supplémentaires à partir de l'API de données historiques de fin de journée.Télécharger la liste des actions sur le point d'annoncer des bénéfices ou des dividendes || Analyse des stocks avec Python Partie 8
Télécharger la liste des actions sur le point d'annoncer des bénéfices ou des dividendes || Analyse des stocks avec Python Partie 8
Bienvenue dans la huitième partie de ma série sur l'utilisation de Python pour l'analyse des stocks. Dans cette vidéo, nous approfondirons l'API de données historiques de fin de journée et explorerons des fonctionnalités supplémentaires au-delà de la récupération des prix. L'API est complète, et même si nous ne couvrirons pas tout, je vais vous montrer quelques exemples qui pourraient vous être utiles. La documentation fournie par l'API est complète et peut vous guider dans l'exploration de différents ensembles de données.
Tout d'abord, nous nous concentrerons sur l'obtention de données sur les bénéfices des entreprises déclarant cette semaine. Pour commencer, nous allons initialiser notre client API en transmettant notre clé API (remplacez-la par la vôtre). Nous téléchargerons ensuite les données et les stockerons dans un DataFrame.
La fonction que nous allons utiliser pour cette tâche ne nécessite aucun paramètre. Une fois que nous aurons le DataFrame, nous extrairons les symboles des entreprises déclarant leurs bénéfices cette semaine et les stockerons dans une liste.
Pour filtrer les données d'un échange spécifique, tel que les États-Unis, nous allons parcourir chaque ligne du DataFrame et vérifier si le symbole se termine par "nous". Les symboles boursiers sont appelés codes dans les données historiques de fin de journée et leurs terminaisons correspondent à la bourse à laquelle ils appartiennent. Nous ajouterons les symboles pertinents à notre liste, à l'exclusion des informations sur l'échange.
Après avoir parcouru toutes les lignes, nous imprimerons le nombre d'entreprises déclarant des bénéfices cette semaine et renverrons la liste des symboles pour une analyse plus approfondie.
Passons à autre chose, explorons comment récupérer les dividendes pour une date de détachement spécifique. Nous allons commencer par la date d'aujourd'hui. La configuration de la fonction sera similaire à la précédente, où nous créons un client API et téléchargeons les données dans un DataFrame.
La fonction que nous utiliserons cette fois-ci s'appelle get_bulk_market. À partir de cette fonction, vous pouvez obtenir divers points de données, y compris les cours de clôture pour l'ensemble d'un marché. Pour les dividendes, nous spécifierons les données qui nous intéressent en tant que "dividendes".
Après avoir effectué l'appel, nous renverrons le DataFrame résultant.
En testant cette fonction, nous allons récupérer les dividendes avec la date ex d'aujourd'hui. Le code imprimera les dividendes, en supposant les valeurs par défaut pour le marché américain et la date du jour.
Le DataFrame résultant affichera les dividendes avec leurs taux respectifs. Puisque nous regardons le marché américain, les dividendes seront en dollars américains. De plus, le DataFrame fournit des informations sur la fréquence des paiements de dividendes.
Cela conclut la huitième partie. Dans la neuvième partie, nous conclurons la première section en construisant un simple filtre.Comment créer un filtre de stock à l'aide d'une API || Analyse des stocks avec Python Partie 9
Comment créer un filtre de stock à l'aide d'une API || Analyse des stocks avec Python Partie 9
Ceci est la partie 9 de notre série sur l'analyse des stocks avec Python. Vous pouvez trouver des liens vers les vidéos précédentes dans la description, ainsi que le code sur GitHub.
Dans ce dernier segment de la section 1, nous allons explorer un exemple d'un stock screener. L'objectif est de créer un filtre simple qui analyse le plus haut sur 52 semaines, le prix actuel et le ratio cours/bénéfice de plusieurs titres. Cela nous aidera à identifier les titres pour une analyse plus approfondie.
Pour ce faire, nous utiliserons le flux fondamental de données historiques de fin de journée. Commençons par examiner les données que nous obtenons d'un appel à ce flux. Nous allons créer un objet client et récupérer des données fondamentales pour une sécurité spécifique, comme Apple. Cela nous donnera une grande base de données avec diverses informations, y compris des données financières, des bilans, etc. Nous pouvons explorer des sections spécifiques en utilisant des emplacements d'index.
Ensuite, nous nous concentrerons sur les aspects techniques de l'indice et utiliserons à la fois la bibliothèque d'aide aux données historiques de fin de journée et un point de terminaison pour télécharger en masse les cours de clôture du jour le plus récent. Nous allons stocker les données dans un bloc de données et réinitialiser l'index. Cet appel récupère les cours de clôture de tous les titres de la bourse américaine. Nous pouvons ensuite filtrer les données pour n'inclure que les titres qui nous intéressent.
Pour construire notre stock screener, nous allons créer un client et parcourir les symboles que nous voulons analyser. Nous remplirons un dictionnaire avec le maximum sur 52 semaines pour chaque titre. Si un titre ne dispose pas de cette information, nous l'ignorons et continuons la boucle.
Après avoir obtenu les données nécessaires, nous fusionnerons les cours de clôture, les plus hauts sur 52 semaines, et calculerons le ratio cours/bénéfice. Nous renverrons la trame de données résultante contenant les titres, leurs cours de clôture, leurs sommets et leurs ratios.
Pour tester notre filtre, nous allons récupérer les symboles du S&P 500 à l'aide de la fonction get_sp et imprimer le résultat. Cela montrera les cours de clôture, les sommets sur 52 semaines et les ratios pour les 10 premiers titres du S&P 500.
Dans la partie 10, nous approfondirons l'analyse des titres individuels alors que nous commençons à créer une classe à cette fin. Rejoignez-nous pour la prochaine partie pour en savoir plus sur l'analyse des titres au niveau individuel.
Stock Analysis Python : Comment analyser automatiquement les actions avec Python || Partie 10
Stock Analysis Python : Comment analyser automatiquement les actions avec Python || Partie 10
Cela va être la partie 10 de ma série sur Python pour l'analyse des stocks. Vous pouvez trouver les liens vers les vidéos précédentes dans la description ci-dessous, ainsi qu'un lien vers le référentiel GitHub où tout le code est disponible. Dans cette partie, nous commencerons à nous concentrer sur des titres individuels plutôt que sur des bourses entières ou de grandes listes de symboles boursiers.
Pour commencer, j'ai déjà inclus les importations nécessaires pour cette partie, telles que datetime, matplotlib, numpy, pandas et seaborn. J'ai également défini une constante symbolique qui représente une date il y a environ un an, qui peut être modifiée par l'utilisateur à l'aide d'une date au format ISO.
Ensuite, j'écrirai une classe appelée "Stock" qui gérera les titres individuels. La classe sera initialisée avec des paramètres pour le symbole boursier, la clé API et la date (avec une valeur par défaut). De plus, cela permettra à l'utilisateur de spécifier un dossier dans lequel les données peuvent être enregistrées, avec une valeur par défaut de Aucun.
À l'intérieur de la classe, je définirai une méthode appelée "get_data" qui récupérera les données de stock. Il vérifiera d'abord si les données sont déjà disponibles dans le dossier spécifié en comparant le symbole aux fichiers disponibles. Si les données sont trouvées, elles seront lues dans un DataFrame et normalisées. Sinon, il récupérera les données à l'aide de l'API et les renverra en tant que DataFrame.
En initialisant une instance Stock, le symbole, la clé API, la date et les données seront stockés en tant que variables d'instance. Pour tester la fonctionnalité, je vais créer un objet Stock et imprimer les données.
Cela conclut la partie 10 de la série. Dans la partie 11, nous ajouterons d'autres transformations de données à la classe Stock.Python pour l'analyse des actions : calculez et représentez automatiquement les rendements et la volatilité des actions || Partie 11
Python pour l'analyse des actions : calculez et représentez automatiquement les rendements et la volatilité des actions || Partie 11
Bienvenue dans la partie 11 de ma série sur Python pour l'analyse des stocks. Vous pouvez trouver les liens vers les vidéos précédentes et le référentiel GitHub dans la description ci-dessous.
Dans la partie 10, nous avons créé une classe simple pour initialiser un symbole boursier et récupérer ses données soit à partir d'un dossier local, soit via une API. Dans cette partie, nous allons approfondir les transformations de données et commencer à tracer les données.
Tout d'abord, je vais ajouter une nouvelle méthode appelée "calculate_volatility" qui prend un DataFrame en entrée. Pour intégrer cette méthode à la méthode "get_data", je vais la modifier en conséquence. Dans la méthode "calculate_volatility", j'ajouterai plusieurs colonnes au DataFrame. La première colonne sera les rendements, calculés comme la différence logarithmique des prix de clôture avec une précision de quatre décimales.
Ensuite, je vais calculer la volatilité glissante, qui représente l'écart type des rendements sur une période de 21 jours. J'arrondirai le résultat à quatre décimales. De plus, j'inclurai les colonnes de changement absolu, d'écart haut-bas et de changement attendu, avec les arrondis appropriés.
Pour analyser l'ampleur du mouvement du stock, je vais calculer une colonne appelée "ampleur" représentant le changement réel divisé par le changement attendu, arrondi à deux décimales. Enfin, j'inclurai une colonne de valeur absolue à des fins de représentation graphique potentielle.
Je supprimerai les lignes initiales contenant les valeurs NaN résultant des calculs, puis j'appellerai la méthode "calculate_volatility" dans la méthode "get_data".
Testons le code en initialisant une instance Stock et en imprimant le DataFrame.
Maintenant, traçons la distribution de retour en créant un histogramme. Je vais déterminer les dates de début et de fin, puis tracer l'histogramme avec 20 bacs et une couleur de bord. Pour enrichir le titre, j'utiliserai un surtitre à deux lignes, en précisant la plage de dates. Enfin, je vais afficher l'intrigue.
Exécutons le code et examinons l'histogramme, qui donne un aperçu de la distribution du rendement des actions au cours de l'année écoulée.
Cela conclut la partie 11. Dans la partie 12, nous continuerons à travailler sur des tracés supplémentaires avant de passer à d'autres transformations de données.Comment calculer et normaliser les rendements boursiers attendus || Analyse des stocks Python Partie 12
Comment calculer et normaliser les rendements boursiers attendus || Analyse des stocks Python Partie 12
Bienvenue dans la partie 12 de ma série sur Python pour l'analyse des stocks. Vous pouvez trouver le code et les liens vers d'autres vidéos dans la description ci-dessous.
Dans la partie 11, nous avons effectué des transformations de données de base dans notre classe Stock en ajoutant des colonnes au DataFrame et en traçant la distribution des rendements. Dans cette vidéo, nous continuerons avec plus d'options de traçage qui peuvent être utiles pour l'analyse des stocks.
Pour commencer, traçons la volatilité de l'action. La configuration sera similaire à ce que nous avons fait auparavant, y compris le super titre et les dates de début et de fin. Nous allons créer un nuage de points, où l'axe des x représente les rendements et l'axe des y représente l'amplitude absolue du changement des écarts-types. Nous ajouterons des lignes horizontales et verticales pour référence.
Exécutons le code et examinons le nuage de points de la volatilité. Nous pouvons observer la plage de variations en pourcentage et le nombre d'écarts-types. Par exemple, au cours de la dernière année, il n'y a pas eu de changements au-delà de trois écarts-types et demi.
Ensuite, traçons la performance de l'action. Encore une fois, la plupart du code reste le même, nous pouvons donc le copier et faire quelques ajustements. Au lieu d'un nuage de points, nous allons créer un graphique linéaire pour suivre les performances relatives au fil du temps. Nous allons diviser les cours de clôture par le cours de clôture le premier jour, soustraire 1 pour obtenir la variation en pourcentage, multiplier par 100 et le formater en pourcentage sur l'axe des ordonnées. Nous garderons la ligne horizontale pour référence.
L'exécution du code affichera le graphique linéaire de la performance de l'action. Nous pouvons voir comment l'action s'est comportée au cours de la période donnée, en la comparant au prix de départ. Dans ce cas, on peut observer une tendance positive suivie d'une baisse ces derniers mois.
N'hésitez pas à personnaliser la taille de la figure et à explorer d'autres options de tracé en fonction de vos besoins.
Cela conclut la partie 12. Dans la partie 13, nous nous plongerons dans des transformations de données supplémentaires.Python pour l'analyse des actions : filtrer les données par expiration et volatilité des options || Partie 13
Python pour l'analyse des actions : filtrer les données par expiration et volatilité des options || Partie 13
Bienvenue dans la partie 13 de ma série sur Python pour l'analyse des stocks. Vous pouvez trouver le code et des liens vers d'autres vidéos sur GitHub dans la description ci-dessous.
Dans la partie 12, nous avons exploré diverses parcelles qui pourraient être utiles pour l'analyse des stocks. Dans cette vidéo, nous allons étendre notre classe Stock en ajoutant quelques méthodes pour examiner différentes tranches de données.
Commençons par écrire une méthode pour identifier les jours où les options expirent. Ce sont les troisièmes vendredis de chaque mois. Nous appellerons cette méthode "option_expiration". Pour ce faire, nous allons créer un masque à l'aide de la fonction np.where de NumPy. Nous allons préciser trois conditions : l'indice des données doit être supérieur au 14 (troisième vendredi au plus tôt possible), inférieur au 21 (troisième vendredi au plus tard possible) et correspondre à un vendredi (jour de la semaine 4). Nous renverrons les données avec ce masque appliqué, résultant en un DataFrame qui n'inclut que les vendredis d'expiration.
Ensuite, nous écrirons notre méthode finale, qui détermine combien de temps la faible volatilité a duré depuis les deux derniers mouvements d'écart type. Nous appellerons cette méthode "low_vol_duration". Pour implémenter cela, nous allons ajouter une colonne aux données appelées "jours de moins de 2 écarts types" et l'initialiser avec des zéros. Ensuite, nous allons parcourir les données et vérifier l'ampleur de chaque ligne. Si la magnitude est inférieure à deux, nous incrémenterons le nombre et mettrons à jour la ligne correspondante dans la colonne " jours inférieurs à 2 écarts types". Si la magnitude est de deux ou plus, nous remettrons le décompte à zéro. Enfin, nous renverrons le DataFrame contenant uniquement les lignes avec deux déplacements d'écart type, indiquant le nombre de jours entre chaque déplacement.
Exécutons le code et examinons les résultats. Nous pouvons voir les jours d'expiration des options, qui se situent entre le 15 et le 21 de chaque mois. De plus, nous avons la durée de faible volatilité, indiquant le nombre de jours écoulés depuis les deux précédents mouvements d'écart type. Par exemple, il y a environ un an, nous avions passé deux jours depuis les deux précédents mouvements d'écart type, suivis de périodes de 32, 41, etc.
Cela conclut la partie 13 et conclut la section 2. Je vous encourage à continuer à développer et à étendre la classe Stock en fonction de vos besoins. Dans la partie 14, nous verrons comment regrouper nos fonctions dans un package Python pouvant être installé à l'aide de pip.Analyse des stocks Python : créez et publiez vos propres packages Python personnalisés avec Pip dans VS Code
Analyse des stocks Python : créez et publiez vos propres packages Python personnalisés avec Pip dans VS Code
Dans cette vidéo, je vais vous guider à travers le processus d'empaquetage de votre code Python dans une bibliothèque qui peut être installée à l'aide de pip. Il s'agit de la dernière vidéo de ma série sur Python pour l'analyse des stocks, où nous avons abordé des sujets tels que la récupération de données, la transformation de données, la visualisation et le filtrage de données. Vous pouvez trouver des liens vers les vidéos précédentes dans la description ci-dessous, ainsi qu'un lien vers le référentiel GitHub.
L'objectif de l'empaquetage de notre code est de le rendre plus pratique à utiliser et à réutiliser dans des projets Python spécifiques. Bien que je vais démontrer le processus comme si nous publions le code sur PyPI (Python Package Index), il est important de noter que le code peut ne pas être prêt pour PyPI tout de suite. Nous allons d'abord le configurer et l'installer localement pour comprendre le processus. Cependant, à l'avenir, vous pourrez modifier le code et créer quelque chose que vous aimeriez partager avec un public plus large.
Le processus d'emballage peut varier en fonction de la complexité du projet. Dans notre cas, puisque notre code se compose de deux modules, le processus est relativement simple. Voici un aperçu des étapes :
Une fois que vous avez configuré les dossiers et les fichiers de configuration, vous pouvez installer la bibliothèque localement à l'aide de pip. Ouvrez la ligne de commande, accédez au dossier parent et exécutez la commande "pip install .". Cela installera la bibliothèque, la rendant accessible depuis n'importe quel environnement Python.
Après l'installation, vous pouvez tester la librairie en lançant Python et en important le module "analyze". Vous pouvez également utiliser la fonction "help" pour afficher les métadonnées sur le package.
N'oubliez pas que le processus d'empaquetage peut évoluer avec le temps et qu'il existe plusieurs façons d'emballer le code pour l'installation. Les étapes que j'ai décrites ici sont un point de départ, et vous pouvez explorer des options supplémentaires à mesure que vos projets deviennent plus complexes.
J'espère que ce tutoriel vous aidera à démarrer avec la création de vos propres packages Python.
Backtesting et trading en direct avec Interactive Brokers utilisant Python.
Backtesting et trading en direct avec Interactive Brokers utilisant Python.
Le Dr Julio commence la session en présentant une introduction au trading algorithmique et à ses avantages. Il explique que le trading algorithmique permet aux traders de réduire la pression de la surveillance constante du marché, de minimiser les erreurs humaines et de créer plus de temps libre pour d'autres activités. Il met en évidence les quatre principales composantes du trading algorithmique, à savoir les courtiers, Internet, les programmes et les ordinateurs.
L'attention se porte ensuite sur Interactive Brokers (IB), qui est présenté comme la plus grande plate-forme de négociation électronique aux États-Unis. Le Dr Julio explique qu'IB propose une technologie API avancée qui permet aux commerçants d'utiliser des programmes pour négocier, offrant des prix compétitifs et un accès aux marchés mondiaux. Il souligne que les programmes Python peuvent être utilisés pour échanger de manière algorithmique avec IB.
Ensuite, le Dr Julio présente un logiciel Python appelé Hybrid Fat Pack, qui permet aux traders de mettre en place une plateforme de trading algorithmique sur leurs ordinateurs locaux ou cloud. Il souligne le principal avantage de cette plate-forme, qui est la capacité de protéger la propriété intellectuelle en n'ayant pas besoin de divulguer ou de télécharger des informations sur Internet. Les traders peuvent également effectuer des backtesting et du trading en direct en un seul endroit, gérer plusieurs comptes et négocier avec différents courtiers à l'aide de divers packages Python tels que TensorFlow et Scikit-learn. Il fournit des instructions sur la façon de télécharger et de configurer la plate-forme Hybrid Fat Pack à partir du site Web d'AI Bridge PI.
Ensuite, le Dr Julio explique les étapes nécessaires pour configurer les outils de backtesting et de trading en direct avec Interactive Brokers en utilisant Python. Il conseille aux utilisateurs de télécharger et de sauvegarder les outils nécessaires, notamment Interactive Brokers, les terminaux officiels IP et Python. Il fournit également des liens vers des didacticiels, de la documentation et un forum communautaire pour une assistance supplémentaire. Le Dr Julio montre comment configurer WS (Workstation) et IB Gateway et montre comment ouvrir un environnement Python à l'aide d'Anaconda. Il exécute un code Python pour présenter le processus de configuration et fournit des conseils sur l'organisation des fenêtres pour une meilleure productivité.
L'orateur explique ensuite les premières étapes de l'utilisation d'Interactive Brokers avec Python. Il demande aux utilisateurs d'ouvrir un fichier nommé "Romina Eva" et de localiser leur code de compte, qui doit être mis à jour dans le fichier en conséquence. L'orateur montre comment choisir et exécuter un code Python, en initialisant un trader et en affichant le solde du compte, la valeur en espèces, la valeur du portefeuille et les commandes en attente. Les utilisateurs peuvent négocier divers titres tels que des actions, des options, des contrats à terme et le Forex en utilisant Hybrid Fat Pack. L'orateur mentionne que les commandes passées ne peuvent pas être manipulées et sont répertoriées avec un identifiant de permis.
Le processus de récupération des données de prix en temps réel et historiques d'Interactive Brokers est démontré. En commentant/décommentant des lignes de code spécifiques, l'orateur montre comment récupérer des données en temps réel ou historiques et les imprimer dans un format convivial. La structure du code et trois fonctions essentielles du code Python sont expliquées, y compris la fonction "initialize" qui s'exécute au début, et la fonction "handle data" où les décisions de trading sont prises et exécutées toutes les 2 secondes par défaut.
Le Dr Julio explique comment prendre des décisions commerciales à l'aide de Python et d'Interactive Brokers. Les utilisateurs peuvent configurer le code pour prendre des décisions à des horaires fixes, que ce soit toutes les secondes, toutes les heures, tous les jours ou à des heures précises. Il introduit trois fonctions cruciales pour créer des décisions de trading : l'initialisation, la gestion des données et la passation d'une commande. Pour illustrer le processus, des exemples de codes sont fournis pour récupérer les données historiques et imprimer le cours vendeur de l'ETF I Spears. L'orateur utilise le cadre de données de Panda pour récupérer et imprimer des données historiques, montrant comment Python peut être utilisé pour les décisions commerciales.
L'orateur discute de la passation d'ordres à l'aide de variables globales et de prix en temps réel, en donnant des exemples d'achat d'actions. Interactive Brokers est utilisé pour rechercher des titres, appliquer des filtres tels que le principal marché américain et un prix supérieur à 100 $, et utiliser la fonction de résultat de cat scan pour obtenir des informations pertinentes. Les étapes pour construire une stratégie algo sont expliquées, y compris l'identification du contrat, la fréquence des décisions de négociation à l'aide de données de gestion ou de fonctions planifiées, la demande de données historiques et le choix du type de commande. Un exemple de stratégie de réversion à la clôture quotidienne est présenté, où les décisions de négociation sont prises en fonction du cours de clôture de la veille. Une fonction de planification est définie pour s'exécuter quotidiennement à une heure précise afin de déclencher le processus de prise de décision et les actions ultérieures.
La vidéo couvre deux exemples de stratégies de trading en Python. Le premier exemple illustre une stratégie de base basée sur les cours de clôture de deux jours consécutifs. Si la clôture d'aujourd'hui est supérieure à celle d'hier, toutes les positions sont vendues ; sinon, SPY est acheté. Le code est expliqué et est relativement simple. La vidéo introduit ensuite le concept de backtesting et présente un exemple plus avancé d'une stratégie de croisement de moyenne mobile. Le processus d'application d'une stratégie aux données historiques et d'évaluation de ses performances est discuté. Le code de cette stratégie est expliqué et reste simple. La vidéo couvre également la récupération et le traitement des données, ainsi que l'analyse des résultats des tests et la visualisation des valeurs du portefeuille.
Le Dr Julio discute du processus de backtesting et de trading en direct avec Interactive Brokers utilisant Python. Il explique le mode par défaut d'exécution de la fonction de gestion des données toutes les minutes à des fins de test et l'importance d'avoir un plan d'injection de données historiques. Il détaille comment fournir des données minute par minute et quotidiennes au code et comment spécifier le délai et la fréquence des backtesting avec Interactive Brokers. Un exemple de code est présenté, montrant comment exécuter un backtester, récupérer et gérer les informations de compte, et vérifier le dossier de sortie pour le solde du compte et la valeur de rachat.
L'intervenant insiste sur l'intérêt de fournir des données historiques fournies par l'utilisateur pour améliorer les performances du code. Bien que les données de simulation exactes d'Interactive Brokers soient nécessaires à des fins de débogage, demander des informations inutiles peut prendre du temps. Le Dr Julio suggère de ne fournir qu'une partie des données historiques ou d'utiliser des données aléatoires, ce qui peut améliorer considérablement les performances du code. Il montre comment fournir des données historiques à partir d'un fichier CSV local, spécifier la plage de temps et le type de données souhaités, et exécuter des tests plus rapidement et plus efficacement à l'aide d'une liste de temps personnalisée et du fournisseur de données de « rendu ».
Le Dr Julio discute de l'analyse des performances et de son importance dans l'évaluation des performances d'une stratégie de trading algorithmique. Il explique le besoin de données historiques pour tester et affiner le code, et comment un graphique d'analyse des performances peut calculer des variables telles que le ratio de Sharpe pour faciliter ce processus. Une fois à l'aise avec les résultats du backtesting, l'orateur conseille de passer à un compte papier pour exécuter la stratégie par rapport aux conditions réelles du marché. Il montre également comment utiliser iBridgePy pour gérer plusieurs comptes, ce qui est crucial pour les gestionnaires de fonds.
Le Dr Julio conclut en soulignant la flexibilité et la nature conviviale du logiciel Hybrid Fat Pack, ce qui en fait un outil puissant pour le trading algorithmique.