Analyser les marchés de crypto-monnaie avec Python

Comment se comportent les marchés Bitcoin? Quelles sont les raisons de la hausse et de la chute soudaines des prix des crypto-monnaies? Existe-t-il un lien inséparable étroit entre les marchés de l'altcoin ou sont-ils pour la plupart indépendants les uns des autres? Comment prédire ce qui se passera à l'avenir?

Approche analytique de l'information pour le raisonnement par crypto-monnaie

Les articles dédiés aux crypto-monnaies comme Bitcoin et Ethereum regorgent de raisonnements et de théories. Des centaines d'experts autoproclamés plaident pour des tendances qui, selon eux, se manifesteront bientôt. Ce que bon nombre de ces analyses manquent à coup sûr, c'est d'une base solide sous la forme de données et de statistiques pouvant étayer certaines affirmations.

Le but de cet article est de fournir une introduction simple à l'analyse de crypto-monnaie à l'aide de Python. Dans ce document, nous examinerons étape par étape un simple script Python pour recevoir, analyser et visualiser des données sur diverses crypto-monnaies. Au cours des travaux, nous découvrirons une tendance intéressante dans le comportement des marchés volatils et découvrirons les changements qui s'y sont produits.



Ce message ne sera pas consacré à expliquer ce que sont les crypto-monnaies (si vous avez besoin d'une telle explication, je vous recommanderais cette excellente critique ). Il n'y aura pas de discussion sur les devises spécifiques qui augmenteront ou diminueront en valeur. Au lieu de cela, le guide se concentrera sur l'accès à des données brutes et brutes et sur la recherche de l'historique caché sous des couches de nombres.

Étape 1. Nous équipons notre laboratoire

Ce guide est destiné à un large éventail de passionnés, d'ingénieurs et de professionnels de l'informatique, quel que soit leur niveau de professionnalisme. À partir des compétences, vous n'aurez besoin que d'une compréhension de base de Python et des compétences minimales en ligne de commande nécessaires pour configurer le projet.

La version complète du travail effectué et tous ses résultats sont disponibles ici .

1.1 Installer Anaconda

La façon la plus simple d'installer des dépendances à partir de zéro pour ce projet est d'utiliser Anaconda, un écosystème python et un gestionnaire de dépendances qui contient tous les packages nécessaires pour travailler avec des données et les analyser.

Pour installer Anaconda, je recommanderais d'utiliser les instructions officielles disponibles ici .

Si vous êtes un utilisateur avancé et qu'Anaconda ne vous convient pas, l'installation n'est pas nécessaire. Dans ce cas, je pense que vous n'avez pas besoin d'aide pour installer les dépendances nécessaires, et vous pouvez passer directement à la deuxième étape.

1.2 Configuration de l'environnement de projet dans Anaconda

Dès qu'Anaconda sera installé, nous voudrons créer un nouvel environnement pour organiser le travail avec les dépendances.

Entrez la commande conda create --name cryptocurrency-analysis python=3 pour créer un nouvel environnement Anaconda pour notre projet.

Ensuite, entrez source activate cryptocurrency-analysis et (sous Linux / macOS) ou activate cryptocurrency-analysis (sous Windows) pour activer l'environnement.

Et enfin, la commande conda install numpy pandas nb_conda jupyter plotly quandl installera les dépendances nécessaires dans l'environnement. Ce processus peut prendre plusieurs minutes.

Pourquoi utilisons-nous l'environnement? Si vous prévoyez de travailler simultanément avec de nombreux projets Python sur votre ordinateur, il est utile de placer les dépendances (bibliothèques de logiciels et packages) séparément pour éviter les conflits. Dans chaque projet, Anaconda crée un répertoire spécial pour les dépendances dans l'environnement, qui vous permet de les séparer des dépendances des autres projets et d'organiser le travail avec eux.

1.3 Lancement du bloc-notes interactif Jupyter Notebook

Une fois l'environnement et les dépendances installés, tapez jupyter notebook dans la console pour démarrer le noyau iPython et ouvrez le lien http: // localhost: 8888 / dans le navigateur. Créez un nouveau bloc-notes Python, en vérifiant qu'il utilise le noyau Python [conda env:cryptocurrency-analysis] .

1.4 Importation de dépendances en haut du bloc-notes

Dès que vous voyez un journal Jupyter propre, vous devez d'abord importer les dépendances nécessaires.

 import os import numpy as np import pandas as pd import pickle import quandl from datetime import datetime 

De plus, vous devez importer Plotly et activer le mode hors ligne pour celui-ci.

 import plotly.offline as py import plotly.graph_objs as go import plotly.figure_factory as ff py.init_notebook_mode(connected=True) 

Étape 2. Obtention des données de prix Bitcoin

Maintenant que tous les paramètres sont terminés, nous sommes prêts à recevoir des informations pour analyse. Tout d'abord, nous devons demander les données de prix Bitcoin en utilisant l' API Bitcoin gratuite Quandl .

2.1 Définir une fonction d'assistance Quandl

Pour aider à l'acquisition de données, nous allons définir une fonction qui télécharge et met en cache les ensembles de données de Quandl.

 def get_quandl_data(quandl_id): '''Download and cache Quandl dataseries''' cache_path = '{}.pkl'.format(quandl_id).replace('/','-') try: f = open(cache_path, 'rb') df = pickle.load(f) print('Loaded {} from cache'.format(quandl_id)) except (OSError, IOError) as e: print('Downloading {} from Quandl'.format(quandl_id)) df = quandl.get(quandl_id, returns="pandas") df.to_pickle(cache_path) print('Cached {} at {}'.format(quandl_id, cache_path)) return df 

Pour convertir les données téléchargées et les enregistrer dans un fichier, nous utiliserons des pickle . Cela empêchera le téléchargement des mêmes données à chaque fois que nous exécuterons le script. La fonction renverra les données sous forme de trame de données Pandas . Si vous n'êtes pas familier avec les blocs de données, vous pouvez les présenter sous forme de feuilles de calcul très puissantes.

2.2 Nous prenons les données de prix de la bourse Kraken

Pour commencer, récupérons les données historiques sur le taux de change Bitcoin de l'échange Kraken .

 # Pull Kraken BTC price exchange data btc_usd_price_kraken = get_quandl_data('BCHARTS/KRAKENUSD') 

Nous pouvons vérifier les 5 premières lignes du bloc de données en utilisant la méthode head() .

 btc_usd_price_kraken.head() 

Générons ensuite un graphique simple pour une vérification visuelle rapide de l'exactitude des données.

 # Chart the BTC pricing data btc_trace = go.Scatter(x=btc_usd_price_kraken.index, y=btc_usd_price_kraken['Weighted Price']) py.iplot([btc_trace]) 

Pour la visualisation, Plotly est utilisé ici . Il s'agit d'une approche moins traditionnelle que les bibliothèques de visualisation python les plus fiables telles que Matplotlib , mais à mon avis, Plotly est un excellent choix, car il vous permet de créer des graphiques entièrement interactifs grâce à l'utilisation de D3.js. En conséquence, vous pouvez obtenir de beaux diagrammes visuels à la sortie sans aucun paramètre. De plus, Plotly est facile à apprendre et ses résultats sont facilement insérés dans les pages Web.

Bien sûr, vous devez toujours vous rappeler la nécessité de comparer les visualisations résultantes avec les graphiques de prix des crypto-monnaies accessibles au public (par exemple, sur Coinbase) pour une vérification de base de la fiabilité des données téléchargées.

2.3 Demander des données de prix à d'autres bourses BTC

Vous avez peut-être remarqué des écarts dans cet ensemble: le graphique s'affaisse à plusieurs endroits à zéro, en particulier à la fin de 2014 et au début de 2016. Ces baisses se trouvent dans l'ensemble de données Kraken, et nous ne voulons évidemment pas qu'elles soient reflétées dans notre analyse finale des prix.

La nature des échanges de bitcoins est telle que les prix sont déterminés par l'offre et la demande, et par conséquent aucun des échanges existants ne peut prétendre que ses cotations reflètent le seul vrai prix «de référence» du Bitcoin. Afin de prendre en compte cet inconvénient, ainsi que d'éliminer l'affaissement de prix sur le graphique, qui est probablement dû à des erreurs techniques ou de jeu de données, nous collecterons en outre des données de trois autres grands échanges de bitcoins pour calculer l'indice de prix global pour le bitcoin.

Pour commencer, téléchargeons les données de chaque échange dans un dictionnaire de trames de données.

 # Pull pricing data for 3 more BTC exchanges exchanges = ['COINBASE','BITSTAMP','ITBIT'] exchange_data = {} exchange_data['KRAKEN'] = btc_usd_price_kraken for exchange in exchanges: exchange_code = 'BCHARTS/{}USD'.format(exchange) btc_exchange_df = get_quandl_data(exchange_code) exchange_data[exchange] = btc_exchange_df 

2.4 Combiner toutes les données de prix dans une seule trame de données

Ensuite, nous définirons une fonction simple qui combine les colonnes similaires de chaque trame de données dans une nouvelle trame combinée.

 def merge_dfs_on_column(dataframes, labels, col): '''Merge a single column of each dataframe into a new combined dataframe''' series_dict = {} for index in range(len(dataframes)): series_dict[labels[index]] = dataframes[index][col] return pd.DataFrame(series_dict) 

Maintenant, combinons tous les blocs de données en fonction de la colonne Prix pondéré.

 # Merge the BTC price dataseries' into a single dataframe btc_usd_datasets = merge_dfs_on_column(list(exchange_data.values()), list(exchange_data.keys()), 'Weighted Price') 

Enfin, jetez un œil aux cinq dernières lignes en utilisant la méthode tail() pour vous assurer que le résultat de notre travail semble normal.

 btc_usd_datasets.tail() 

Les prix semblent comme prévu: ils sont dans des limites similaires, mais il y a de légères différences basées sur le rapport offre / demande sur chaque échange individuel.

2.5 Visualiser les ensembles de données de prix

L'étape logique suivante consiste à visualiser la comparaison des ensembles de données résultants. Pour ce faire, nous définissons une fonction auxiliaire qui permet de générer un graphique basé sur une trame de données à l'aide d'une commande sur une seule ligne.

 def df_scatter(df, title, seperate_y_axis=False, y_axis_label='', scale='linear', initial_hide=False): '''Generate a scatter plot of the entire dataframe''' label_arr = list(df) series_arr = list(map(lambda col: df[col], label_arr)) layout = go.Layout( title=title, legend=dict(orientation="h"), xaxis=dict(type='date'), yaxis=dict( title=y_axis_label, showticklabels= not seperate_y_axis, type=scale ) ) y_axis_config = dict( overlaying='y', showticklabels=False, type=scale ) visibility = 'visible' if initial_hide: visibility = 'legendonly' # Form Trace For Each Series trace_arr = [] for index, series in enumerate(series_arr): trace = go.Scatter( x=series.index, y=series, name=label_arr[index], visible=visibility ) # Add seperate axis for the series if seperate_y_axis: trace['yaxis'] = 'y{}'.format(index + 1) layout['yaxis{}'.format(index + 1)] = y_axis_config trace_arr.append(trace) fig = go.Figure(data=trace_arr, layout=layout) py.iplot(fig) 

Par souci de concision, je n'entrerai pas dans les détails du fonctionnement d'une fonction auxiliaire. Si vous souhaitez en savoir plus à ce sujet, consultez la documentation Pandas et Plotly .

Nous pouvons facilement générer un graphique pour les données de prix du bitcoin.

 # Plot all of the BTC exchange prices df_scatter(btc_usd_datasets, 'Bitcoin Price (USD) By Exchange') 

2.6 Nettoyage et combinaison des données de prix

Nous pouvons voir que malgré le fait que les 4 séries de données se comportent approximativement de la même manière, il y a plusieurs écarts par rapport à la norme qui doivent être éliminés.

Supprimons toutes les valeurs nulles de la trame, car nous savons que le prix du bitcoin n'a jamais été nul au cours de la période considérée.

 # Remove "0" values btc_usd_datasets.replace(0, np.nan, inplace=True) 

Après avoir à nouveau construit le graphique, nous obtenons une courbe plus nette, sans aucune forte baisse.

 # Plot the revised dataframe df_scatter(btc_usd_datasets, 'Bitcoin Price (USD) By Exchange') 

Et maintenant, nous pouvons calculer une nouvelle colonne contenant le prix quotidien moyen du bitcoin sur la base des données de tous les échanges.

 # Calculate the average BTC price as a new column btc_usd_datasets['avg_btc_price_usd'] = btc_usd_datasets.mean(axis=1) 

Cette nouvelle colonne est notre indice de prix Bitcoin! Tracons-le pour nous assurer qu'il semble normal.

 # Plot the average BTC price btc_trace = go.Scatter(x=btc_usd_datasets.index, y=btc_usd_datasets['avg_btc_price_usd']) py.iplot([btc_trace]) 

Oui, ça a l'air bien. Nous utiliserons la série de prix combinés à l'avenir pour convertir les taux de change d'autres crypto-monnaies en dollar américain.

Étape 3. Obtention des données de prix altcoin

Maintenant que nous avons une série chronologique fiable de prix pour le bitcoin, demandons des données pour les crypto-monnaies non-bitcoin, qui sont souvent appelées altcoins.

3.1 Définition des fonctions auxiliaires pour travailler avec l'API Poloniex

Pour obtenir des données altcoin, nous utiliserons l'API Poloniex . Deux fonctions auxiliaires qui téléchargent et mettent en cache les données JSON transmises à cette API nous aideront à cela.

Tout d'abord, nous définissons get_json_data , qui téléchargera et mettra en cache les données JSON à l'URL fournie.

 def get_json_data(json_url, cache_path): '''Download and cache JSON data, return as a dataframe.''' try: f = open(cache_path, 'rb') df = pickle.load(f) print('Loaded {} from cache'.format(json_url)) except (OSError, IOError) as e: print('Downloading {}'.format(json_url)) df = pd.read_json(json_url) df.to_pickle(cache_path) print('Cached {} at {}'.format(json_url, cache_path)) return df 

Ensuite, nous définissons une fonction qui génère des requêtes HTTP vers l'API Poloniex, puis appelle get_json_data , qui, à son tour, stocke les données demandées.

 base_polo_url = 'https://poloniex.com/public?command=returnChartData&currencyPair={}&start={}&end={}&period={}' start_date = datetime.strptime('2015-01-01', '%Y-%m-%d') # get data from the start of 2015 end_date = datetime.now() # up until today pediod = 86400 # pull daily data (86,400 seconds per day) def get_crypto_data(poloniex_pair): '''Retrieve cryptocurrency data from poloniex''' json_url = base_polo_url.format(poloniex_pair, start_date.timestamp(), end_date.timestamp(), pediod) data_df = get_json_data(json_url, poloniex_pair) data_df = data_df.set_index('date') return data_df 

Elle prend une chaîne indiquant la paire de crypto-monnaies (par exemple, BTC_ETH) et renvoie une trame de données contenant des données historiques à son taux de change.

3.2 Téléchargement des données commerciales avec Poloniex

La plupart des altcoins ne peuvent pas être achetés directement en dollars américains. Pour les acquérir, les gens achètent souvent des bitcoins et les échangent contre des altcoins sur les échanges. Par conséquent, nous téléchargeons les taux de change BTC pour chaque pièce et utilisons les données au prix BTC pour calculer le coût des altcoins en USD.

Nous téléchargeons des données boursières pour les neuf crypto-monnaies les plus populaires - Ethereum , Litecoin , Ripple , Ethereum Classic , Stellar , Dashcoin , Siacoin , Monero et NEM .

 altcoins = ['ETH','LTC','XRP','ETC','STR','DASH','SC','XMR','XEM'] altcoin_data = {} for altcoin in altcoins: coinpair = 'BTC_{}'.format(altcoin) crypto_price_df = get_crypto_data(coinpair) altcoin_data[altcoin] = crypto_price_df 

Nous avons maintenant un dictionnaire de 9 trames de données, chacune contenant des données historiques sur les paires de prix de change quotidiens moyens des altcoins et des bitcoins.
Encore une fois, nous allons vérifier les cinq dernières lignes du tableau des prix Ethereum pour nous assurer que tout est en ordre.

 altcoin_data['ETH'].tail() 

3.3 Conversion des prix en dollars américains

Nous pouvons maintenant comparer les données sur les paires de prix avec notre indice de prix bitcoin pour obtenir directement des données historiques sur la valeur des altcoins en dollars américains.

 # Calculate USD Price as a new column in each altcoin dataframe for altcoin in altcoin_data.keys(): altcoin_data[altcoin]['price_usd'] = altcoin_data[altcoin]['weightedAverage'] * btc_usd_datasets['avg_btc_price_usd'] 

En utilisant ce code, nous avons créé une nouvelle colonne dans le bloc de données de chaque altcoin avec les prix des pièces en dollars.

De plus, nous pouvons réutiliser la fonction précédemment définie merge_dfs_on_column pour créer un merge_dfs_on_column de données contenant les prix en dollars pour chaque crypto-monnaie.

 # Merge USD price of each altcoin into single dataframe combined_df = merge_dfs_on_column(list(altcoin_data.values()), list(altcoin_data.keys()), 'price_usd') 

Comme ça. Maintenant, ajoutons également les prix du bitcoin à la dernière colonne de la trame de données combinée.

 # Add BTC price to the dataframe combined_df['BTC'] = btc_usd_datasets['avg_btc_price_usd'] 

Et maintenant, nous avons une seule trame contenant les prix quotidiens en dollars pour les dix crypto-monnaies que nous étudions.

Réutilisons la fonction df_scatter précédemment définie pour dessiner un graphique comparatif des changements de prix des crypto-monnaies.

 # Chart all of the altocoin prices df_scatter(combined_df, 'Cryptocurrency Prices (USD)', seperate_y_axis=False, y_axis_label='Coin Value (USD)', scale='log') 

Super! Le graphique vous permet d'évaluer assez clairement la dynamique des taux de change de chaque crypto-monnaie au cours des dernières années.

Veuillez noter que nous utilisons l'échelle des ordonnées logarithmiques, car elle nous permet de regrouper toutes les devises sur un même graphique. Mais si vous le souhaitez, vous pouvez essayer différentes valeurs de paramètres (telles que scale='linear' ) pour examiner les données sous un angle différent.

3.4 Analyse de corrélation

Vous avez peut-être remarqué que les taux de change des crypto-monnaies, malgré leurs valeurs et leur volatilité complètement différentes, semblent avoir une certaine corrélation entre eux. Surtout si vous regardez l'intervalle après la vague d'août, même de petites fluctuations se produisent avec différents jetons comme si elles étaient synchrones.

Mais une prémonition basée sur une ressemblance externe n'est pas meilleure qu'une simple supposition jusqu'à ce que nous puissions la sauvegarder avec des données statistiques.

Nous pouvons tester notre hypothèse de corrélation en utilisant la méthode corr() de la collection Pandas, en l'utilisant pour calculer le coefficient de corrélation de Pearson de toutes les colonnes du cadre les unes par rapport aux autres.

Correction du 22/08/2017 - Cette partie des travaux a été révisée. Maintenant, pour calculer les coefficients de corrélation, au lieu des valeurs de prix absolues, les valeurs en pourcentage de leurs variations quotidiennes sont utilisées.

Le calcul des corrélations directement entre les séries chronologiques non stationnaires (telles que les données de prix brutes) peut conduire à des résultats biaisés. Nous corrigerons ce défaut en appliquant la méthode pct_change() , qui convertit la valeur de chaque cellule de trame d'une valeur absolue en un pourcentage de sa variation quotidienne.

Pour commencer, nous calculons la corrélation en 2016.

 # Calculate the pearson correlation coefficients for cryptocurrencies in 2016 combined_df_2016 = combined_df[combined_df.index.year == 2016] combined_df_2016.pct_change().corr(method='pearson') 

Maintenant, nous avons des chances partout. Des valeurs proches de 1 ou -1 indiquent que, entre les séries chronologiques, il existe une forte corrélation directe ou inverse, respectivement. Des coefficients proches de zéro signifient que les valeurs ne sont pas corrélées et varient indépendamment les unes des autres.

Pour visualiser les résultats, nous devons créer une autre fonction de visualisation auxiliaire.

 def correlation_heatmap(df, title, absolute_bounds=True): '''Plot a correlation heatmap for the entire dataframe''' heatmap = go.Heatmap( z=df.corr(method='pearson').as_matrix(), x=df.columns, y=df.columns, colorbar=dict(title='Pearson Coefficient'), ) layout = go.Layout(title=title) if absolute_bounds: heatmap['zmax'] = 1.0 heatmap['zmin'] = -1.0 fig = go.Figure(data=[heatmap], layout=layout) py.iplot(fig) 

 correlation_heatmap(combined_df_2016.pct_change(), "Cryptocurrency Correlations in 2016") 

Les cellules rouges foncées sur le graphique indiquent une forte corrélation (et chacune des monnaies sera évidemment corrélée à elle-même autant que possible), bleu foncé - une forte corrélation inverse. Toutes les couleurs bleu, orange, gris et sable entre elles indiquent différents degrés de faible corrélation ou son absence.

Que nous apprend ce tableau? En fait, cela montre que la relation statistiquement significative entre les fluctuations de prix de diverses crypto-monnaies en 2016 est faible.

Et maintenant, pour tester notre hypothèse que les crypto-monnaies sont devenues plus corrélées ces derniers mois, répétons le même test en utilisant des données déjà pour 2017.

 combined_df_2017 = combined_df[combined_df.index.year == 2017] combined_df_2017.pct_change().corr(method='pearson') 

Les coefficients obtenus indiquent la présence d'une corrélation plus significative. Est-elle assez forte pour profiter de ce fait pour investir? Certainement pas.

Mais nous devons cependant prêter attention au fait que presque toutes les crypto-monnaies dans leur ensemble sont devenues plus corrélées les unes avec les autres.

 correlation_heatmap(combined_df_2017.pct_change(), "Cryptocurrency Correlations in 2017") 

Et c'est une observation assez intéressante.

Pourquoi cela se produit-il?

Bonne question. Je ne peux pas dire avec certitude.

La première pensée qui vient à l'esprit: la raison en est que les fonds spéculatifs ont récemment commencé à négocier ouvertement sur les marchés des crypto-monnaies. [ 1 ] [ 2 ] Ces fonds ont des montants de capital beaucoup plus importants que les traders moyens, et s'ils se protègent contre les risques en répartissant leurs fonds sur une variété de crypto-monnaies et utilisent des stratégies de trading similaires pour chacun d'eux, basées sur des variables indépendantes (comme ils le font , par exemple, en bourse), alors une conséquence logique de cette approche peut être l'émergence d'une tendance à l'augmentation des corrélations.

Analyse approfondie: XRP et STR

Par exemple, l'une des tendances confirme indirectement le raisonnement ci-dessus. XRP (Ripple token) est le moins corrélé avec d'autres altcoins. Mais il y a une exception notable - STR (le jeton Stellar, celui officiel est appelé «Lumens»), dont le coefficient de corrélation avec XRP est de 0,62.

Il est intéressant de noter que Stellar et Ripple sont des plateformes fintech assez similaires dont les activités visent à simplifier le processus de paiements interbancaires internationaux.

Je vois une situation très réelle dans laquelle certains acteurs riches et fonds spéculatifs utilisent des stratégies similaires pour négocier des fonds investis dans Stellar et Ripple, car les deux services derrière ces jetons sont de nature très similaire. Cette hypothèse peut expliquer pourquoi XRP est beaucoup plus corrélé avec STR qu'avec d'autres crypto-monnaies.

Votre tour

Cependant, cette explication est en grande partie une conclusion spéculative. Mais peut-être pouvez-vous faire mieux? Les bases que nous avons posées dans ce travail nous permettent de poursuivre l'étude des données dans différentes directions.

Voici quelques idées à vérifier:

• Ajoutez des données pour plus de crypto-monnaies à l'analyse.
• Corriger le calendrier et le degré de détail de l'analyse de corrélation, en considérant les tendances plus en détail, ou vice versa, en termes plus généraux.
• Recherchez les tendances des volumes d'échange et / ou des ensembles de données pour l'extraction de la blockchain. Les ratios ventes / achats conviennent mieux pour prévoir les fluctuations de prix que les données brutes sur les prix.
• Ajoutez des données sur les prix des actions, des matières premières et des matières premières, des monnaies fiduciaires pour savoir lesquels de ces actifs sont en corrélation avec les crypto-monnaies. (Mais souvenez-vous toujours du bon vieux dicton: «La corrélation n'implique pas encore la causalité.»)
• Quantifiez la quantité de battage médiatique autour des crypto-monnaies individuelles en utilisant Event Registry , GDELT et Google Trends .
• À l'aide de l'apprentissage automatique, formez un programme pour analyser les données afin de prédire les tendances des prix. Si l'ambition le permet, vous pouvez même essayer de le faire avec un réseau neuronal récurrent.
• Utilisez votre analyse pour créer un trading de bot trader automatisé sur des sites comme Poloniex et Coinbase en utilisant les API appropriées. Mais attention: un bot de trading mal optimisé peut rapidement vous priver de tous les fonds disponibles.
• Partagez vos trouvailles! La meilleure caractéristique du Bitcoin et des autres crypto-monnaies en général est que leur nature décentralisée les rend plus libres et démocratiques, par rapport à presque tous les autres actifs. , , , -.

HTML- python- .

, , - , , , .

, , , - , . - , Github- .

, , , . , , , .