Dessin de bougie avec python

Pied de bougie avec matplotlib.finance

Créer des données

Créez un tableau d'échange fictif avec une marche aléatoire.

import numpy as np
import pandas as pd


def randomwalk(periods=None, start=None, end=None, freq='B', tz=None,
               normalize=False, name=None, closed=None, tick=1, **kwargs):
    """Returns random up/down pandas Series.

    Usage:
        ```
        import datetime
        randomwalk(100)  # Returns +-1up/down 100days from now.
        randomwalk(100, freq='H')  # Returns +-1up/down 100hours from now.
        randomwalk(100, ,tick=0.1 freq='S')  # Returns +-0.1up/down 100seconds from now.
        randomwalk(100, start=datetime.datetime.today())  # Returns +-1up/down 100days from now.
        randomwalk(100, end=datetime.datetime.today())
            # Returns +-1up/down back to 100 days from now.
        randomwalk(start=datetime.datetime(2000,1,1), end=datetime.datetime.today())
            # Returns +-1up/down from 2000-1-1 to now.
        randomwalk(100, freq='H').resample('D').ohlc()  # random OHLC data
        ```

    Args:
        periods: int
        start: start time (default datetime.now())
        end: end time
        freq: ('M','W','D','B','H','T','S') (default 'B')
        tz: time zone
        tick: up/down unit size (default 1)

    Returns:
        pandas Series with datetime index
    """
    if not start and not end:
        start = pd.datetime.today().date()  # default arg of `start`
    index = pd.DatetimeIndex(start=start, end=end, periods=periods, freq=freq, tz=tz,
                             normalize=normalize, name=name, closed=closed, **kwargs)
    bullbear = pd.Series(tick * np.random.randint(-1, 2, len(index)),
                         index=index, name=name, **kwargs)  # tick * (-1,0,L'un des 1)
    price = bullbear.cumsum()  #Somme cumulée
    return price

np.random.seed(1)  #Réinitialisation de l'état aléatoire. La même marche aléatoire est toujours créée
rw = randomwalk(60*24*90, freq='T', tick=0.01)
rw.head(5)

2017-03-19 00:00:00    0.00
2017-03-19 00:01:00   -0.01
2017-03-19 00:02:00   -0.02
2017-03-19 00:03:00   -0.02
2017-03-19 00:04:00   -0.02
Freq: T, dtype: float64

rw.plot()

Générez une barre d'une minute avec un tick minimum de 0,01 yen pendant 30 jours

df = rw.resample('B').ohlc() + 115  #La valeur initiale est de 115 yens
df.head()

En utilisant la méthode de rééchantillonnage, je l'ai changé en une barre quotidienne (option how = 'B') uniquement les jours de la semaine, et je l'ai résumé en 4 valeurs (ohcl) d'ouverture, de haut, de bas et de fermeture.

df.plot()

Le graphique à 4 valeurs est difficile à voir comme indiqué ci-dessus, alors fixez-le à un chandelier.

Référence 1

Référence: stack over flow - how to plot ohlc candlestick with datetime in matplotlib?

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.finance as mpf
from matplotlib import ticker
import matplotlib.dates as mdates
import pandas as pd

def candlechart(ohlc, width=0.8):
    """Renvoie un graphique en chandeliers pour le bloc de données d'entrée
argument:
            * ohlc:
                *Trame de données
                *Dans le nom de la colonne'open'", 'close', 'low', 'high'Mettre
                *Dans aucun ordre particulier"
            * widrh:Largeur de ligne de bougie
Valeur de retour: ax: subplot"""
    fig, ax = plt.subplots()
    #Pied de bougie
    mpf.candlestick2_ohlc(ax, opens=ohlc.open.values, closes=ohlc.close.values,
                          lows=ohlc.low.values, highs=ohlc.high.values,
                          width=width, colorup='r', colordown='b')

    #Faire le temps de l'axe des x
    xdate = ohlc.index
    ax.xaxis.set_major_locator(ticker.MaxNLocator(6))

    def mydate(x, pos):
        try:
            return xdate[int(x)]
        except IndexError:
            return ''

    ax.xaxis.set_major_formatter(ticker.FuncFormatter(mydate))
    ax.format_xdata = mdates.DateFormatter('%Y-%m-%d')

    fig.autofmt_xdate()
    fig.tight_layout()

    return fig, ax

candlechart(df)

(<matplotlib.figure.Figure at 0x207a86dd080>,
 <matplotlib.axes._subplots.AxesSubplot at 0x207a6a225c0>)

Référence 2

Référence: Qiita - Afficher le graphique en chandeliers en Python (édition matplotlib)

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.finance as mpf
from matplotlib import ticker
import matplotlib.dates as mdates
import pandas as pd

fig = plt.figure()
ax = plt.subplot()

ohlc = np.vstack((range(len(df)), df.values.T)).T #données de l'axe des x en nombre entier
mpf.candlestick_ohlc(ax, ohlc, width=0.8, colorup='r', colordown='b')

xtick0 = (5-df.index[0].weekday())%5 #Index du premier lundi

plt.xticks(range(xtick0,len(df),5), [x.strftime('%Y-%m-%d') for x in df.index][xtick0::5])
ax.grid(True) #Affichage de grille
ax.set_xlim(-1, len(df)) #plage de l'axe des x
fig.autofmt_xdate() #mise en forme automatique sur l'axe des x

Ajout de SMA (moyenne mobile simple)

import matplotlib.pyplot as plt
import matplotlib.finance as mpf
from randomwalk import *

fig = plt.figure()
ax = plt.subplot()

# candle
ohlc = np.vstack((range(len(df)), df.values.T)).T  #données de l'axe des x en nombre entier
mpf.candlestick_ohlc(ax, ohlc, width=0.8, colorup='r', colordown='b')

# sma
sma = df.close.rolling(5).mean()
vstack = np.vstack((range(len(sma)), sma.values.T)).T  #données de l'axe des x en nombre entier
ax.plot(vstack[:, 0], vstack[:, 1])

# xticks
xtick0 = (5 - df.index[0].weekday()) % 5  #Index du premier lundi
plt.xticks(range(xtick0, len(df), 5), [x.strftime('%Y-%m-%d') for x in df.index][xtick0::5])
ax.grid(True)  #Affichage de grille
ax.set_xlim(-1, len(df))  #plage de l'axe des x
fig.autofmt_xdate()  #mise en forme automatique sur l'axe des x
plt.show()

import matplotlib.pyplot as plt
import matplotlib.finance as mpf

def sma(ohlc, period):
    sma = ohlc.close.rolling(period).mean()
    vstack = np.vstack((range(len(sma)), sma.values.T)).T  #données de l'axe des x en nombre entier
    return vstack

fig = plt.figure()
ax = plt.subplot()

# candle
ohlc = np.vstack((range(len(df)), df.values.T)).T  #données de l'axe des x en nombre entier
mpf.candlestick_ohlc(ax, ohlc, width=0.8, colorup='r', colordown='b')

# sma
sma5 = sma(df, 5)
sma25 = sma(df, 25)
ax.plot(sma5[:, 0], sma5[:, 1])
ax.plot(sma25[:, 0], sma25[:, 1])


# xticks
xtick0 = (5 - df.index[0].weekday()) % 5  #Index du premier lundi
plt.xticks(range(xtick0, len(df), 5), [x.strftime('%Y-%m-%d') for x in df.index][xtick0::5])
ax.grid(True)  #Affichage de grille
ax.set_xlim(-1, len(df))  #plage de l'axe des x
fig.autofmt_xdate()  #mise en forme automatique sur l'axe des x
plt.show()

Pieds de bougie avec complot

pratiquer complotement

Référence: Qiita- [Python] Créez un graphe qui peut être déplacé avec Plotly

J'utilise complotement pour la première fois, alors comment le faire

conda install plotly

Installez et importez comme suit.

Il y a beaucoup d'informations dont vous avez besoin pour créer un compte, mais il semble que vous pouvez faire ce que vous voulez gratuitement dans une certaine mesure maintenant que la réglementation a été assouplie.

import plotly as py
py.offline.init_notebook_mode(connected=False) 

Créez des exemples de données appropriés.

fo = [[2000,1190547,1.36],
    [2001,1170662,1.33],
    [2002,1153855,1.32],
    [2003,1123610,1.29],
    [2004,1110721,1.29],
    [2005,1062530,1.26],
    [2006,1092674,1.32],
    [2007,1089818,1.34],
    [2008,1091156,1.37],
    [2009,1070035,1.37],
    [2010,1071304,1.39],
    [2011,1050806,1.39],
    [2012,1037101,1.41],
    [2013,1029816,1.43],
    [2014,1003532,1.42],
    [2015,1005656,1.46]]
raw = pd.DataFrame(fo, columns=['year', 'births', 'birth rate'])
raw

data = [
    py.graph_objs.Scatter(y=raw["births"], name="births"),
]
layout = py.graph_objs.Layout(
    title="title",
    legend={"x":0.8, "y":0.1},
    xaxis={"title":""},
    yaxis={"title":""},
)
fig = py.graph_objs.Figure(data=data, layout=layout)
py.offline.iplot(fig, show_link=False)

data = [
    py.graph_objs.Bar(x=raw["year"], y=raw["births"], name="Births"),
    py.graph_objs.Scatter(x=raw["year"], y=raw["birth rate"], name="Birth Rate", yaxis="y2")
]
layout = py.graph_objs.Layout(
    title="Births and Birth Rate in Japan",
    legend={"x":0.8, "y":0.1},
    xaxis={"title":"Year"},
    yaxis={"title":"Births"},
    yaxis2={"title":"Birth Rate", "overlaying":"y", "side":"right"},
)
fig = py.graph_objs.Figure(data=data, layout=layout)
py.offline.iplot(fig)
#py.offline.plot(fig)

Mode opératoire

• Afficher la valeur numérique en survolant la souris
• Faites glisser pour agrandir
• Double-cliquez pour revenir à la vue d'origine

Graphique d'échange

Référence: Qiita - Afficher le graphique en chandeliers en Python (édition Plotly)

from plotly.offline import init_notebook_mode, iplot
from plotly.tools import FigureFactory as FF
init_notebook_mode(connected=True) #Paramètres du bloc-notes Jupyter

Graphique normal

Puisque la fonction de graphique en bougies est préparée, il est facile de créer un graphique à barres en bougies si des données ouvertes, élevées, basses et fermées sont préparées.

Cependant, il ne peut pas être affiché uniquement en semaine. Les samedis et dimanches sont également affichés.

fig = FF.create_candlestick(df.open, df.high, df.low, df.close, dates=df.index)
py.offline.iplot(fig)

Tracé en semaine uniquement

La destination de référence corrigeait l'index uniquement les jours de semaine.

fig = FF.create_candlestick(df.open, df.high, df.low, df.close)

xtick0 = (5-df.index[0].weekday())%5 #Index du premier lundi
fig['layout'].update({
    'xaxis':{
        'showgrid': True,↔
        'ticktext': [x.strftime('%Y-%m-%d') for x in df.index][xtick0::5],
        'tickvals': np.arange(xtick0,len(df),5)
    }
})

py.offline.iplot(fig)

Ajout d'indicateurs

def sma(data, window, columns='close'):
    return data[columns].rolling(window).mean()

sma5 = sma(df, 5)

fig = FF.create_candlestick(df.open, df.high, df.low, df.close, dates=df.index)

add_line = Scatter( x=df.index,  y=df.close,  name= 'close values',
                   line=Line(color='black'))
fig['data'].extend([add_line])
↔
py.offline.iplot(fig, filename='candlestick_and_trace', validate=False)

from plotly.graph_objs import *
fig = FF.create_candlestick(df.open, df.high, df.low, df.close, dates=df.index)
add_line = [Scatter(x=df.index, y=df.close.rolling(5).mean(), name='SMA5', line=Line(color='r')),
            Scatter(x=df.index, y=df.close.rolling(15).mean(), name='SMA15', line=Line(color='b')),
            Scatter(x=df.index, y=df.close.rolling(25).mean(), name='SMA25', line=Line(color='g'))]
↔
fig['data'].extend(add_line)
fig['layout'].update({'xaxis':{'showgrid': True}})

py.offline.iplot(fig, filename='candlestick_and_trace', validate=False)

Comparaison SMA, EMA

Créer un nouveau graphique

np.random.seed(10)
ra = randomwalk(60*24*360, freq='T', tick=0.01) + 115
df1 = ra.resample('B').ohlc()

import plotly.graph_objs as go
fig = FF.create_candlestick(df1.open, df1.high, df1.low, df1.close, dates=df1.index)
add_line = [go.Scatter(x=df1.index, y=df1.close.rolling(75).mean(), name='SMA75', line=Line(color='r')),
            go.Scatter(x=df1.index, y=df1.close.ewm(75).mean(), name='EMA75', line=Line(color='b'))]

fig['data'].extend(add_line)
fig['layout'].update({'xaxis':{'showgrid': True}})
    
py.offline.iplot(fig, filename='candlestick_and_trace', validate=False)

Pour une raison quelconque, la moyenne mobile est cliquetante, alors développons-la.

import plotly.graph_objs as pyg
from datetime import datetime

def to_unix_time(*dt):
    """Convertir datetime en secondes Unix
argument:Liste avec datetime
Valeur de retour:Liste fixée aux secondes Unix"""
    epoch =  datetime.utcfromtimestamp(0)
    ep = [(i - epoch).total_seconds() * 1000 for i in list(*dt)]
    return ep

fig = FF.create_candlestick(df1.open, df1.high, df1.low, df1.close, dates=df1.index)
add_line = [pyg.Scatter(x=df1.index, y=df1.close.rolling(75).mean(), name='SMA75', line=Line(color='r')),
            pyg.Scatter(x=df1.index, y=df1.close.ewm(75).mean(), name='EMA75', line=Line(color='b')),
            pyg.Scatter(x=df1.index, y=df1.close.rolling(75).mean(), name='SMA75', mode='markers'),
            pyg.Scatter(x=df1.index, y=df1.close.ewm(75).mean(), name='EMA75', mode='markers')]

fig['data'].extend(add_line)  #Ajouter des données au tracé
fig['layout'].update(xaxis = {'showgrid': True,
                               'type': 'date',
                               'range':to_unix_time([datetime(2017,9,1), datetime(2018,1,1)])})  #Changement de disposition
    
py.offline.iplot(fig, filename='candlestick_and_trace', validate=False)

Les jours fériés sont dessinés sur l'axe horizontal, mais la valeur de vacances dans les données de ligne de moyenne mobile est NaN. Par conséquent, une ligne droite reliant vendredi et lundi est créée et la ligne qui aurait dû être lissée semble cliquetante.

À propos, SAM et EMA ne sont plus tracés lorsque xaxis est forcé d'être défini uniquement les jours de la semaine avec la mise en page comme l'a fait la personne de référence. C'est probablement parce que xaxis est forcé d'être string et float afin d'éliminer les jours fériés, donc il ne correspond pas à l'indice de SMA et EMA. Si l'index de SMA et EMA est également un index mixte de chaîne et de flottant, il peut ne pas être possible de le définir sur xaxis uniquement les jours de la semaine, mais comme il est supposé que la période sera modifiée à une longueur arbitraire à l'avenir, le type de date / heure est modifié de force. Je ne veux pas le casser.

Par conséquent, il est un peu difficile à voir en raison des vacances, mais nous accepterons l'API de complot en l'état. Veuillez commenter si quelqu'un connaît un bon moyen de créer des xaxis uniquement en semaine. Je ne sais toujours pas grand-chose de l'intrigue.

Next Graphique en bougie avec plotly