def _kdj(data):
k, d = talib.STOCH(data.highest_price.values,
data.lowest_price.values,
data.close_price,
fastk_period=9,
slowk_period=3,
slowd_period=3)
return k.iloc[-1]
def kdjs(self, n, array=False):
""""""
slowk, slowd = talib.STOCH(self.high, self.low, self.close, n, 3, 0, 3,
0)
slowj = list(map(lambda x, y: 3 * x - 2 * y, slowk, slowd))
if array:
return slowk, slowd, slowj
return slowk[-1], slowd[-1], slowj[-1]
def b_getKDJ(stock):
price = history(stock, ['close', 'high', 'low'], 20, '1d', False, 'pre', is_panel=1)
high = price['high']
low = price['low']
close = price['close']
K, D = talib.STOCH(np.array(high), np.array(low),np.array(close), 9, 3, 0, 3, 0)
J=3*K-2*D
return (K[-1]+D[-1]+J[-1])/3
def J(quote):
STOCH_K, STOCH_D = ta.STOCH(numpy.array(quote.High),
numpy.array(quote.Low),
numpy.array(quote.Close),
slowk_period=14,
slowd_period=3)
j = 3 * STOCH_K - 2 * STOCH_D
return j[-1]
def run_techicals(df):
'''
Preform technical anlysis calcuaitons and add to a dataframe.
Algorithms stem from the TAlib module other helper functions, including distretizing data,
using alternate series, and time shifting
TAlib docs: https://github.com/mrjbq7/ta-lib/blob/master/docs/func_groups/momentum_indicators.md
'''
days_back = 0
opn = np.roll(df['exp_smooth_open'], days_back)
high = np.roll(df['exp_smooth_high'], 0)
low = np.roll(df['exp_smooth_low'], 0)
close = np.roll(df['exp_smooth_close'], days_back)
volume = np.roll(df['exp_smooth_volume'], 0)
# series = df['close'].values
series = close
# df['roc'] = talib.ROCP(series, timeperiod=1)
df['roc'] = rate_of_change(df['close'], 1) # > 0.04
df['roc_d'] = discrete_series_pos_neg(df['roc']) # > 80.638
df['rsi'] = talib.RSI(series, timeperiod=14) # > 80.638
df['rsi_d'] = continuous_to_discrete_w_bounds(df['rsi'], 30,
70) # > 80.638
df['willr'] = talib.WILLR(high, low, series, timeperiod=14) # > -11
df['willr_d'] = discrete_trend(df['willr']) # > -11
df['cci'] = talib.CCI(high, low, series, timeperiod=14) # > -11
df['cci_d'] = continuous_to_discrete_w_bounds(df['cci'], -200,
200) # > -11
df['obv'] = talib.OBV(series, volume)
df['mom'] = talib.MOM(series)
df['mom_d'] = discrete_series_pos_neg(df['mom'])
df['sma20'] = discrete_series_compare(close, talib.SMA(
series, 20)) # > talib.MA(series, 200)
df['sma50'] = discrete_series_compare(close, talib.SMA(
series, 50)) # > talib.MA(series, 200)
df['sma200'] = discrete_series_compare(close, talib.SMA(
series, 200)) # > talib.MA(series, 200)
df['wma10'] = discrete_series_compare(close, talib.WMA(series, 10))
df['macd'], df['macd_sig'], macdhist = talib.MACD(series,
fastperiod=12,
slowperiod=26,
signalperiod=9)
df['macd_d'] = discrete_trend(df['macd']) # > -11
df['stok'], df['stod'] = talib.STOCH(high,
low,
series,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
df['stok_d'] = discrete_trend(df['stok']) # > -11
df['stod_d'] = discrete_trend(df['stod']) # > -11
#df['sto'] = slowk #> 80
return df
def on15MinBar(self, bar):
"""收到Bar推送（必须由用户继承实现）"""
symbol = bar.vtSymbol
self.am15Dict[symbol].updateBar(
bar) # 需要将 15MinBar 数据同时推给 15MinBar 的array字典去保存，用于talib计算
am15 = self.am15Dict[symbol]
if not am15.inited:
return
# Indicator
up, mid, low = ta.BBANDS(am15.close, self.bBandPeriod,
matype=0) # parameter1
sigma = (up - mid) / (2 * mid)
kHigh = ta.MAX(sigma, self.minMaxPeriod) # parameter2
kLow = ta.MIN(sigma, self.minMaxPeriod)
sigmaKdjMa = ta.MA(ta.STOCH(kHigh, kLow, sigma)[0],
self.kdjMaPeriod) # parameter3
MA = ta.MA(am15.close, self.signalMaPeriod, matype=0) # parameter4
self.writeCtaLog('%son15minBar, sigmaKdjMa%s, MA[-1]%s, MA[-3]%s' %
(symbol, sigmaKdjMa[-1], MA[-1], MA[-3]))
# signal
if (self.maTrend == 1) and (MA[-1] > MA[-3]) and (
sigmaKdjMa[-1] < self.lowVolRate): # parameter5
if self.stopLossControl == -1:
self.stopLossControl = 0
if self.posDict[symbol +
"_LONG"] == 0 and self.stopLossControl == 0:
self.buy(
symbol, # 下单交易品种
bar.close * 1.01, # 下单的价格
1, # 交易数量
priceType=
PRICETYPE_LIMITPRICE # 价格类型：[PRICETYPE_LIMITPRICE,PRICETYPE_MARKETPRICE,PRICETYPE_FAK,PRICETYPE_FOK]
) # 保证金交易可填杠杆参数，默认levelRate = 0
if (sigmaKdjMa[-1] > self.highVolRate) and (MA[-1] <
MA[-3]): # parameter6
if self.posDict[symbol + "_LONG"] > 0:
self.cancelAll()
self.sell(symbol, bar.close * 0.99,
self.posDict[symbol + "_LONG"])
if (self.maTrend == -1) and (MA[-1] < MA[-3]) and (sigmaKdjMa[-1] <
self.lowVolRate):
if self.stopLossControl == 1:
self.stopLossControl = 0
if self.posDict[symbol +
"_SHORT"] == 0 and self.stopLossControl == 0:
self.short(symbol, bar.close * 0.99, 1)
if (sigmaKdjMa[-1] > self.highVolRate) and (MA[-1] > MA[-3]):
if self.posDict[symbol + "_SHORT"] > 0:
self.cancelAll()
self.cover(symbol, bar.close * 1.01,
self.posDict[symbol + "_SHORT"])
def create_technical_indicators(df, indicators=['MA_4'], only_close_colum=False):
if only_close_colum:
if isinstance(df, pd.DataFrame):
close = np.array(df['Close']).reshape(len(df), )
else:
if isinstance(df, pd.DataFrame):
close = np.array(df['Close']).reshape(len(df), )
# OPEN = np.array(df['Open']).reshape(len(df), )
high = np.array(df['High']).reshape(len(df), )
low = np.array(df['Low']).reshape(len(df), )
df_2_return = pd.DataFrame()
for indicator in indicators:
if indicator is None:
pass
else:
if indicator.split('_')[0].strip() == 'MA':
smavg = talib.MA(close, timeperiod=int(indicator.split('_')[1]))
df_2_return[indicator] = smavg
if indicator.split('_')[0].strip() == 'BBANDS':
upperband, middleband, lowerband = talib.BBANDS(close, timeperiod=int(indicator.split('_')[1]))
df_2_return['lowerband'] = lowerband
df_2_return[indicator] = middleband
df_2_return['upperband'] = upperband
if indicator.split('_')[0].strip() == 'MACD':
indicator = indicator + '_12' + '_26' + '_9'
_, macdsignal, macdhist = talib.MACD(close,
fastperiod=int(indicator.split('_')[1]),
slowperiod=int(indicator.split('_')[2]),
signalperiod=int(indicator.split('_')[3]))
df_2_return['macdsignal'] = macdsignal
df_2_return['macdhist'] = macdhist
if indicator.split('_')[0].strip() == 'RSI':
real_RSI = talib.RSI(close, timeperiod=int(indicator.split('_')[1]))
df_2_return[indicator] = real_RSI
if indicator.split('_')[0].strip() == 'CMO':
real_CMO = talib.CMO(close, timeperiod=int(indicator.split('_')[1]))
df_2_return[indicator] = real_CMO
if indicator.split('_')[0].strip() == 'ADX':
if only_close_colum:
pass
else:
real_ADX = talib.ADX(high, low, close, timeperiod=int(indicator.split('_')[1]))
df_2_return[indicator] = real_ADX
if indicator.split('_')[0].strip() == 'STOCH':
if only_close_colum:
pass
else:
slowk, slowd = talib.STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
df_2_return[indicator] = slowd - slowk
return(df_2_return)
def updateIndicator(self, data, candles_visible):
# STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
slowK, slowD = talib.STOCH(data[2], data[3], data[4],
fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
firstNotNan = np.where(np.isnan(slowK))[0][-1] + 1
slowK[:firstNotNan] = slowK[firstNotNan]
firstNotNan = np.where(np.isnan(slowD))[0][-1] + 1
slowD[:firstNotNan] = slowD[firstNotNan]
slowK = slowK[-candles_visible:]
slowD = slowD[-candles_visible:]
self.slowK.clear()
self.slowD.clear()
for i in range(candles_visible):
self.slowK.append(i + 0.5, slowK[i])
self.slowD.append(i + 0.5, slowD[i])
self.top_line.clear()
self.bottom_line.clear()
self.top_line.append(0, 80)
self.top_line.append(candles_visible, 80)
self.bottom_line.append(0, 20)
self.bottom_line.append(candles_visible, 20)
# detach and remove old axes
for ax in self.slowK.attachedAxes():
self.slowK.detachAxis(ax)
for ax in self.slowD.attachedAxes():
self.slowD.detachAxis(ax)
for ax in self.area.attachedAxes():
self.area.detachAxis(ax)
for ax in self.axes():
self.removeAxis(ax)
# set x axes
ax = QtChart.QValueAxis()
ax.setRange(0, candles_visible)
ax.hide()
# set y axes
ay = QtChart.QValueAxis()
ay.setRange(0, 100)
ay.setGridLinePen(QtGui.QPen(QtGui.QColor(80, 80, 80), 0.5))
ay.setLinePen(QtGui.QPen(QtGui.QColor(0, 0, 0), 0.5))
ay.applyNiceNumbers()
ay.setTickCount(3)
# add and attach new axes
self.addAxis(ax, QtCore.Qt.AlignBottom)
self.addAxis(ay, QtCore.Qt.AlignRight)
self.slowK.attachAxis(ax)
self.slowK.attachAxis(ay)
self.slowD.attachAxis(ax)
self.slowD.attachAxis(ay)
self.area.attachAxis(ax)
self.area.attachAxis(ay)
def etf_should_buy(li,l2):
for i in range(len(li)):
h = ts.pro_bar(li[i],asset="FD",start_date="20200101",end_date=get_now_time(),ma=[5,10]).iloc[::-1]
n = h.shape[0]
if n > 33:
# ----------- 获取kdj值 ---------------#
slowk, slowd = tb.STOCH(h['high'].values,
h['low'].values,
h['close'].values,
fastk_period=9,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
slowj = 3 * slowk - 2 * slowd
# ------------- 获取ma5 ma10 --------------- #
ma5 = h["ma5"].tolist()
ma10 = h["ma10"].tolist()
# -------------- 获取macd值 ----------------- #
macd,signal,hist = tb.MACD(h["close"].values, 12, 26, 9)
# -------------- 获取adx值 ----------------- #
adx = tb.ADX(h["high"].values,
h["low"].values,
h["close"].values,
timeperiod=14)
# -------------- 获取当前价格 ----------------- #
price = h["close"].tolist()
# ---------------- 格式化数据 ---------------------#
slowj[-1] = round(slowj[-1],3)
ma5[-1] = round(ma5[-1], 3)
ma10[-1] = round(ma10[-1],3)
macd[-1] = round(macd[-1],3)
adx[-1] = round(adx[-1],3)
if slowj[-1] > slowk[-1] > slowd[-1] and \
macd[-2] < macd[-1]:
if price[-1] < 10:
print(li[i],if_price_increase(price),if_ma5_big_ma10(ma5,ma10),if_macd_increase(macd),if_slowj_big_slowkd(slowj,slowk,slowd))
# 56#符合特征的
# if slowj[n-2] < 20 < slowj[n-1] and slowj[n-1] > slowk[n-1] > slowd[n-1]:
# print(li[i],"BUY++",get_now_time())
# if slowj[n-2] > 80 > slowj[n-1] and slowj[n-1] < slowk[n-1] < slowd[n-1] and slowj[n-2] > slowk[n-2] > slowd[n-2]:
# print(li[i],"SELL--",get_now_time())
#
# if slowj[n-1] > 80 > slowj[n - 2] and slowj[n-1] > slowk[n-1] > slowd[n-1] and slowj[n-2] < slowk[n-2] > slowd[n-2]:
# print(li[i],"BUY+",get_now_time())
#
# if 50 > slowj[n-1] and slowj[n-1] < slowk[n-1] < slowd[n-1] and slowj[n-2] > slowk[n-2] > slowd[n-2]:
# print(li[i], "SELL--",get_now_time())
time.sleep(0.2)
def getMomentumIndicators(df):
high = df['High']
low = df['Low']
close = df['Close']
open = df['Open']
volume = df['Volume']
df['ADX'] = ta.ADX(high, low, close, timeperiod=14)
df['SMA'] = ta.ADXR(high, low, close, timeperiod=14)
df['APO'] = ta.APO(close, fastperiod=12, slowperiod=26, matype=0)
df['AROONDOWN'], df['AROOONUP'] = ta.AROON(high, low, timeperiod=14)
df['AROONOSC'] = ta.AROONOSC(high, low, timeperiod=14)
df['BOP'] = ta.BOP(open, high, low, close)
df['CCI'] = ta.CCI(high, low, close, timeperiod=14)
df['CMO'] = ta.CMO(close, timeperiod=14)
df['DX'] = ta.DX(high, low, close, timeperiod=14)
df['MACD'], df['MACDSIGNAL'], df['MACDHIST'] = ta.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
df['MFI'] = ta.MFI(high, low, close, volume, timeperiod=14)
df['MINUS_DI'] = ta.MINUS_DI(high, low, close, timeperiod=14)
df['MINUS_DM'] = ta.MINUS_DM(high, low, timeperiod=14)
df['MOM'] = ta.MOM(close, timeperiod=10)
df['PLUS_DM'] = ta.PLUS_DM(high, low, timeperiod=14)
df['PPO'] = ta.PPO(close, fastperiod=12, slowperiod=26, matype=0)
df['ROC'] = ta.ROC(close, timeperiod=10)
df['ROCP'] = ta.ROCP(close, timeperiod=10)
df['ROCR'] = ta.ROCR(close, timeperiod=10)
df['ROCR100'] = ta.ROCR100(close, timeperiod=10)
df['RSI'] = ta.RSI(close, timeperiod=14)
df['SLOWK'], df['SLOWD'] = ta.STOCH(high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
df['FASTK'], df['FASTD'] = ta.STOCHF(high,
low,
close,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
df['FASTK2'], df['FASTD2'] = ta.STOCHRSI(close,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
df['TRIX'] = ta.TRIX(close, timeperiod=30)
df['ULTOSC'] = ta.ULTOSC(high,
low,
close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
df['WILLR'] = ta.WILLR(high, low, close, timeperiod=14)
def handle_data(self, kl):
self.kl = kl #.copy()
self.data['t'] = kl['t']
self.data['slowk'], self.data['slowd'] = ta.STOCH(
kl['h'], kl['l'], kl['c'], **self.params)
self.data['up'] = pd.Series([80] * kl['c'].size)
self.data['low'] = pd.Series([20] * kl['c'].size)
self.data['mid'] = pd.Series([50] * kl['c'].size)
self.data['dif'] = (self.data['slowk'] - self.data['slowd']) + 50
def STOCH_factor(self, df, fastk_period=5, slowk_period=3,
slowk_matype=0, slowd_period=3, slowd_matype=0):
return talib.STOCH(
df.loc[:, self.map_dict['high']].values,
df.loc[:, self.map_dict['low']].values,
df.loc[:, self.map_dict['close']].values,
fastk_period, slowk_period,
slowk_matype, slowd_period,
slowd_matype)
def KD5(data_frame):
return talib.STOCH(high=normalize_list2talib(data_frame['high']),
low=normalize_list2talib(data_frame['low']),
close=normalize_list2talib(data_frame['close']),
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
def getKDJ(self):
return ta.STOCH(self.price['High'],
self.price['Low'],
self.price['Adj Close'],
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)[1]
def total(self, dfs, period=14):
# 计算参数
df0 = dfs[self.mCodes[0]]
close = df0["close"]
df0["datetime"] = df0.index
df0['mcode'] = rq.get_dominant_future(self.code,
start_date=self.startDate,
end_date=self.endDate)
df0['atr'] = ta.ATR(df0['high'], df0['low'], close, timeperiod=period)
df0['atrc'] = ta.ATR(df0['high'], df0['low'], close,
timeperiod=1) / df0['atr']
# kdj顶点
kdjK, kdjD = ta.STOCH(df0["high"],
df0["low"],
close,
fastk_period=9,
slowk_period=3,
slowk_matype=1,
slowd_period=3,
slowd_matype=1)
df0["kdj_d2"] = kdj_d2 = kdjK - kdjD
df0["kdjm"] = kdj_d2 * kdj_d2.shift(1)
df0["kdjm"] = df0.apply(
lambda row: self.turn(row['kdjm'], row['kdj_d2'], 1), axis=1)
# 循环 scale
docs = []
for conds in self.iterCond():
uid = self.uidKey % ('_'.join(self.codes), str(period),
self.klineType, str(self.bullwidth), conds)
df1 = df0.apply(lambda row: self.jump0(row), axis=1)
for key in self.pointColumns:
df0[key] = df1[key]
if self.code in self.csvList:
file = self.Rice.basePath + '%s_pre.csv' % (uid)
print(uid, '---------------------------- to_cvs', file,
df0.columns)
df0.to_csv(file, index=0)
#tot = None
tot = self.detect(df0, period=period, uid=uid)
if tot is not None and tot['amount'] != 0:
tot.update({
"method": self.method,
"code": self.code,
"period": period,
"uid": uid,
"createdate": public.getDatetime()
})
docs.append(tot)
return docs
def TALIB_STOCH(close,
fastk_period=5,
slowk_period=3,
slowk_matype=talib.MA_Type.SMA,
slowd_period=3,
slowd_matype=talib.MA_Type.SMA):
'''00382,6,2'''
return talib.STOCH(close, fastk_period, slowk_period, slowk_matype,
slowd_period, slowd_matype)
def get_stokrsi(self):
rsi = self.get_rsi(self.close)
stochrsif, stochrsis = talib.STOCH(rsi,
rsi,
rsi,
fastk_period=14,
slowk_period=3,
slowd_period=3)
return stochrsif, stochrsis
def kdj(close, high, low):
k, d = talib.STOCH(high=high,
low=low,
close=close,
fastk_period=9,
slowk_period=3,
slowd_period=3)
j = 3 * k - 2 * d
return k, d, j
def getKDJ( data ): high = data["high"] low = data["low"] close = data["close"] K, D = talib.STOCH(high, low, close, fastk_period=9, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) data['KDJ_K'] = K data['KDJ_D'] = D data['KDJ_J'] = 3*D - 2*K return data
def Get_KDJ(df):
# 参数9,3,3
slowk, slowd = ta.STOCH(np.array(df['high']),
np.array(df['low']),
np.array(df['close']),
fastk_period=9,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
slowkMA5 = ta.MA(slowk, timeperiod=5, matype=0)
slowkMA10 = ta.MA(slowk, timeperiod=10, matype=0)
slowkMA20 = ta.MA(slowk, timeperiod=20, matype=0)
slowdMA5 = ta.MA(slowd, timeperiod=5, matype=0)
slowdMA10 = ta.MA(slowd, timeperiod=10, matype=0)
slowdMA20 = ta.MA(slowd, timeperiod=20, matype=0)
# 16-17 K,D
df['slowk'] = pd.Series(slowk, index=df.index) # K
df['slowd'] = pd.Series(slowd, index=df.index) # D
dflen = df.shape[0]
MAlen = len(slowkMA5)
operate = 0
# 1.K线是快速确认线——数值在90以上为超买，数值在10以下为超卖；D大于80时，行情呈现超买现象。D小于20时，行情呈现超卖现象。
if df.iat[(dflen - 1), 16] >= 90:
operate = operate - 3
elif df.iat[(dflen - 1), 16] <= 10:
operate = operate + 3
if df.iat[(dflen - 1), 17] >= 80:
operate = operate - 3
elif df.iat[(dflen - 1), 17] <= 20:
operate = operate + 3
# 2.上涨趋势中，K值大于D值，K线向上突破D线时，为买进信号。#待修改
if df.iat[(dflen - 1), 16] > df.iat[(dflen - 1), 17] and df.iat[
(dflen - 2), 16] <= df.iat[(dflen - 2), 17]:
operate = operate + 10
# 下跌趋势中，K小于D，K线向下跌破D线时，为卖出信号。#待修改
elif df.iat[(dflen - 1), 16] < df.iat[(dflen - 1), 17] and df.iat[
(dflen - 2), 16] >= df.iat[(dflen - 2), 17]:
operate = operate - 10
# 3.当随机指标与股价出现背离时，一般为转势的信号。
if df.iat[(dflen - 1), 7] >= df.iat[(dflen - 1), 8] and df.iat[
(dflen - 1), 8] >= df.iat[(dflen - 1), 9]: # K线上涨
if (slowkMA5[MAlen - 1] <= slowkMA10[MAlen - 1] and slowkMA10[MAlen - 1] <= slowkMA20[MAlen - 1]) or \
(slowdMA5[MAlen - 1] <= slowdMA10[MAlen - 1] and slowdMA10[MAlen - 1] <= slowdMA20[MAlen - 1]): # K,D下降
operate = operate - 1
elif df.iat[(dflen - 1), 7] <= df.iat[(dflen - 1), 8] and df.iat[
(dflen - 1), 8] <= df.iat[(dflen - 1), 9]: # K线下降
if (slowkMA5[MAlen - 1] >= slowkMA10[MAlen - 1] and slowkMA10[MAlen - 1] >= slowkMA20[MAlen - 1]) or \
(slowdMA5[MAlen - 1] >= slowdMA10[MAlen - 1] and slowdMA10[MAlen - 1] >= slowdMA20[MAlen - 1]): # K,D上涨
operate = operate + 1
return (df, operate)
def KD(self):
H = self.bars_high
L = self.bars_low
C = self.bars_close
fk = self.fastkp
sk = self.slowkp
sd = self.slowdp
slowk,slowd = talib.STOCH(H[symbol[0]].values,L[symbol[0]].values,C[symbol[0]].values,fastk_period=fk,slowk_period=sk,slowd_period=sd)
return slowk,slowd
def add_kd(self):
self.stk_df['slowk'], self.stk_df['slowd'] = talib.STOCH(self.stk_df.high,
self.stk_df.low,
self.stk_df.close,
fastk_period=9,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
def technical_index(context):
#EMA,RSI指标
context.var.ts['EMA_5min'] = talib.EMA(np.array(context.var.ts.close), timeperiod=5)
context.var.ts['EMA_10min'] = talib.EMA(np.array(context.var.ts.close), timeperiod=10)
context.var.ts['EMA_15min'] = talib.EMA(np.array(context.var.ts.close), timeperiod=15)
context.var.ts['EMA_20min'] = talib.EMA(np.array(context.var.ts.close), timeperiod=20)
context.var.ts['RSI'] = talib.RSI(np.array(context.var.ts.close))
STOCHRSI_usual = talib.STOCHRSI(np.array(context.var.ts.close))
# BOLL-BAND指标
BBANDS_usual = talib.BBANDS(np.array(context.var.ts.close))
upperband, middleband, lowerband = BBANDS_usual
context.var.ts['upperband'] = upperband
context.var.ts['middleband'] = middleband
context.var.ts['lowerband'] = lowerband
arrClose = np.array(context.var.ts.close)
arrHigh = np.array(context.var.ts.high)
arrLow = np.array(context.var.ts.low)
arrVolume = np.array(context.var.ts.volume,dtype=np.float)
# MACD指标
MACD_usual = talib.MACD(arrClose)
macd, macdsignal, macdhist = MACD_usual
context.var.ts['macd'] = macd
context.var.ts['macdsignal'] = macdsignal
context.var.ts['macdhist'] = macdhist
# KDJ指标
KDJ_usual = talib.STOCH(arrHigh, arrLow, arrClose)
slowk, slowd = KDJ_usual
context.var.ts['slowk'] = slowk
context.var.ts['slowd'] = slowd
# ATR指标
ATR_usual = talib.ATR(arrHigh, arrLow, arrClose)
context.var.ts['ATR'] = ATR_usual
# WILLR指标
WILLR_usual = talib.WILLR(arrHigh, arrLow, arrClose)
context.var.ts['WILLR'] = WILLR_usual
# BOV指标
OBV_usual = talib.OBV(arrClose, arrVolume)
context.var.ts['OBV'] = OBV_usual
# SAR指标
SAR_usual = talib.SAR(arrHigh, arrLow)
context.var.ts['SAR'] = SAR_usual
# DEMA指标
DEMA_usual = talib.DEMA(arrClose)
context.var.ts['DEMA'] = DEMA_usual
#MOM指标
MOM_usual = talib.MOM(arrClose)
context.var.ts['MOM'] = MOM_usual
def handle_data(context):
# 获取历史数据, 取后longest_history根bar
hist = context.data.get_price(context.security, count=context.user_data.longest_history, frequency=context.frequency)
if len(hist.index) < context.user_data.longest_history:
context.log.warn("bar的数量不足, 等待下一根bar...")
return
# 最高价
high_prices = np.array(hist["high"])
# 最低价
low_prices = np.array(hist["low"])
# 收盘价
close_prices = np.array(hist["close"])
# matype: 0=SMA, 1=EMA, 2=WMA, 3=DEMA, 4=TEMA, 5=TRIMA, 6=KAMA, 7=MAMA, 8=T3 (Default=SMA)
# 用talib计算K，D两条线
K, D = talib.STOCH(high_prices, low_prices, close_prices, fastk_period=context.user_data.fastk_period, slowk_matype=context.user_data.slowk_matype, slowk_period=context.user_data.slowk_period, slowd_period=context.user_data.slowd_period)
current_k_value = K[-1]
current_d_value = D[-1]
previous_k_value = K[-2]
previous_d_value = D[-2]
long_signal_triggered = False
short_signal_triggered = False
context.log.info("当前 K = %s, D = %s; 前一周期 K = %s, D = %s" % (current_k_value, current_d_value, previous_k_value, previous_d_value))
# 生成买入/卖出信号
# 当D < 超卖线, K线和D线同时上升，且K线从下向上穿过D线时，买入
if current_d_value < context.user_data.over_sell_signal and current_d_value > previous_d_value and current_k_value > previous_k_value and previous_k_value < previous_d_value and current_k_value > current_d_value:
long_signal_triggered = True
# 当D > 超买线, K线和D线同时下降，且K线从上向下穿过D线时，卖出
elif current_d_value > context.user_data.over_buy_signal and current_d_value < previous_d_value and current_k_value < previous_k_value and previous_k_value > previous_d_value and current_k_value < current_d_value:
short_signal_triggered = True
# 有卖出信号，卖出全部仓位
if short_signal_triggered:
if context.account.huobi_cny_btc >= HUOBI_CNY_BTC_MIN_ORDER_QUANTITY:
context.log.info("产生卖出信号")
# 若持有仓位，则全仓卖出
if context.account.huobi_cny_btc >= HUOBI_CNY_BTC_MIN_ORDER_QUANTITY:
context.log.info("正在卖出 %s" % context.security)
context.log.info("卖出数量为 %s" % context.account.huobi_cny_btc)
context.order.sell(context.security, quantity=str(context.account.huobi_cny_btc))
else:
context.log.info("仓位不足，无法卖出")
# 有买入信号，全仓买入
elif long_signal_triggered:
context.log.info("产生买入信号")
if context.account.huobi_cny_cash >= HUOBI_CNY_BTC_MIN_ORDER_CASH_AMOUNT:
context.log.info("正在买入 %s" % context.security)
context.log.info("下单金额为 %s 元" % context.account.huobi_cny_cash)
context.order.buy(context.security, cash_amount=str(context.account.huobi_cny_cash))
else:
context.log.info("现金不足，无法下单")
else:
context.log.info("无交易信号，进入下一根bar")
def test_stoch():
"""test TA.STOCH"""
stoch = TA.STOCH(ohlc, 9)
talib_stoch = talib.STOCH(ohlc["high"], ohlc["low"], ohlc["close"], 9)
# talib_stoch[0] is "slowk"
# assert talib_stoch[0][-1] == stoch.values[-1]
# assert 76.27794470586021 == 80.7982311922445
pass # close enough
def get_stoch(self, sym):
slowk, slowd = talib.STOCH(self.highs[sym],
self.lows[sym],
self.prices[sym],
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
return slowk, slowd
def get_kdj(df):
k, d = ta.STOCH(high=df['qhigh'].values,
low=df['qlow'].values,
close=df['qclose'].values,
fastk_period=9,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
return k, d
def calculate_kdj(self):
self._slowk_list, self._slowd_list = talib.STOCH(
np.array(self._high_list),
np.array(self._low_list),
np.array(self._close_list),
fastk_period=9,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
def get_slowd(data):
data["slowk"], data["slowd"] = ta.STOCH(data["High"],
data["Low"],
data["Close"],
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
return data.slowd.iat[-1]
def stochastic(df, n):
slowk, slowd = ta.STOCH(df['High'],
df['Low'],
df['Close'],
fastk_period=n,
slowk_period=n,
slowd_period=n)
df['STOCH_SLOW_K_' + str(n)] = slowk
df['STOCH_SLOW_D_' + str(n)] = slowd
return df
