def Run(codes, task_id=0):
from pypublish import publish
pl = publish.Publish()
df_year = stock.THS().df_year
df_jll = stock.THS().df_jll
#myredis.delKeys(myredis.enum.KEY_HISDAT_NO_FUQUAN)
for code in codes:
df = df_year[df_year['code'] == code]
df_hisdat = stock.getHisdatDfRedis(code)
history_syl = calc_history_syl(df, df_hisdat, 'year')
ui.DrawTs(pl, history_syl, title=stock.GetCodeName(code).decode('utf8'))
df = df_jll[df_jll['code'] == code]
history_syl = calc_history_syl(df, df_hisdat, period='quarter')
ui.DrawTs(pl, history_syl, title=stock.GetCodeName(code).decode('utf8'))
def test_strategy(codes, strategy_name):
import backtest_runner
for code in codes:
print code, stock.GetCodeName(code)
p = backtest_runner.BackTestPolicy(backtest_runner.BackTestPolicy.enum.tick_mode)
p.SetStockCodes([code])
backtesting = Backtest()
account = backtesting.createAccount(account_type=None, username=None, pwd=None)
#p.Regist(Strategy_basesign(backtesting, is_backtesting=True))
strategy = strategy_name(backtesting, is_backtesting=True)
strategy.trade_num = 600
p.Regist(strategy)
#p.Regist(Strategy_Trade(backtesting, is_backtesting=True))
cur_day = agl.CurDay()
d1, d2 = help.MyDate.s_Dec(cur_day, -20),cur_day
def getTradeDay(d1, d2, dtype=backtest_runner.BackTestPolicy.enum.hisdat_mode):
"""确定是交易日
return: (d1, d2)"""
if dtype == backtest_runner.BackTestPolicy.enum.hisdat_mode:
df = stock.getHisdatDataFrameFromRedis(code, start_day=d1)
else:
df = stock.getFenshiDfUseRedis(code, d1, d2)
d2 = agl.datetime_to_date(df.index[-1])
if agl.DateTimeCmp(d1, agl.datetime_to_date(df.index[0])) <0:
d1 = agl.datetime_to_date(df.index[0])
return d1, d2
#for i in range(10):
#if d1 in df.index:
#return d1,d2
#else:
#d1 = help.MyDate.s_Dec(d1, 1)
d1,d2 = getTradeDay(d1,d2, backtest_runner.BackTestPolicy.enum.tick_mode)
print d1, d2
p.Run(d1, d2)
def _Report(self, policy, start_day, end_day):
policy._getAccount().Report(end_day, True)
#绘制图形
if hasattr(policy, 'Report'):
policy.Report()
#end_day = help.MyDate.s_Dec(end_day, 1)
#bars = stock.CreateFenshiPd(self.code, start_day, end_day)
if self.mode == 0:
bars = self.dict_fenshi[self.codes[0]]
if len(bars) == 0:
return
bars = bars.resample('1min').mean()
bars['c'] = bars['p']
else:
#日线
bars = self.panel_hisdat[self.codes[0]]
bars['positions'] = 0
bars = bars.dropna()
df = policy._getAccount().ChengJiao()
df_zhijing = policy._getAccount().ZhiJing()
init_money = df_zhijing.iloc[0]['资产']
df_zhijing = df_zhijing[bars.index[0]:]
df_changwei = policy._getAccount().ChengJiao()
cols = ['买卖标志', '委托数量']
df_flag = df_changwei[cols[0]].map(lambda x: x == '证券卖出' and -1 or 1)
df_changwei[cols[1]] *= df_flag
changwei = df_changwei[cols[1]].cumsum()
if self.mode == 1:
df.index = df.index.map(lambda x: agl.datetime_to_date(x))
bars.is_copy = False
for i in range(len(df)):
index = df.index[i]
bSell = bool(df.iloc[i]['买卖标志'] == '证券卖出')
if index in bars.index:
bars.at[index, 'positions'] = agl.where(bSell, -1, 1)
#同步资金到bar
df_zhijing.is_copy = False
df_zhijing['changwei'] = changwei
if self.mode == 1:
df_zhijing.index = df_zhijing.index.map(
lambda x: agl.datetime_to_date(x))
bars = bars.join(df_zhijing)
bars = bars.fillna(method='pad')
#同步价格的动态总资产
bars['资产'] = bars['可用'] + bars['changwei'] * bars['c']
zhican = (bars['资产'] - init_money) / init_money * 100
zhican = zhican.fillna(0)
title = '%s %s' % (self.codes[0], stock.GetCodeName(
self.codes[0]).decode('utf8'))
ui.TradeResult_Boll(agl.where(policy.pl, policy.pl, pl), bars, \
stock.GuiYiHua(zhican),\
stock.GuiYiHua(bars['changwei']),
title=title)
if policy.pl is not None:
if policy.pl.explicit:
#有成交才发布
if len(df) > 0:
policy.pl.publish()
def Order_At_Boll():
upper, middle, lower = stock.TDX_BOLL(df_five_hisdat['c'])
highs, lows, closes = df_five_hisdat['h'], df_five_hisdat[
'l'], df_five_hisdat['c']
adx = stock.TDX_ADX(highs, lows, closes)
self._log('boll : %.2f,%.2f,%.2f' %
(upper[-1], middle[-1], lower[-1]))
boll_w = abs(upper[-1] - lower[-1]) / middle[-1] * 100
boll_poss = [
upper[-1],
(upper[-1] - middle[-1]) / 2 + middle[-1],
middle[-1],
(middle[-1] - lower[-1]) / 2 + lower[-1],
lower[-1],
]
self._log('boll_poss: %.2f, %.2f boll_w=%.2f adx=%.2f' %
(boll_poss[0], boll_poss[1], boll_w, adx[-1]))
user_datas = mydatas[mydatas['symbol'] == code]
if price > boll_poss[1] * 1.001:
num = int(user_datas['trade1'])
if self.order(1, code, price, num):
self._log(
agl.utf8_to_ascii('一档卖出%s, %.2f, %d' %
(code, price, num)))
if price > boll_poss[0] * 0.998:
num = int(user_datas['trade2'])
if self.order(1, code, price, num):
self._log(
agl.utf8_to_ascii('二档卖出%s, %.2f, %d' %
(code, price, num)))
if price < boll_poss[-2] * 0.999:
num = int(user_datas['trade1'])
if self.order(0, code, price, num):
self._log(
agl.utf8_to_ascii('一档买入%s, %.2f, %d' %
(code, price, num)))
if price < boll_poss[-1] * 1.001:
num = int(user_datas['trade2'])
if self.order(0, code, price, num):
self._log(
agl.utf8_to_ascii('二档买入%s, %.2f, %d' %
(code, price, num)))
#信号发生时语音播报, 并通知界面回显
if not self.is_backtesting and (price > boll_poss[1]
or price < boll_poss[-2]):
codename = stock.GetCodeName(code)
s = '%s, %.2f' % (codename, price)
self.data.show(codename) #通知界面显示
self.data.speak2(s) #语音播报
def test_strategy(codes,
strategy_name,
cbfn_setparams=None,
mode=1,
start_day='',
end_day='',
datasource_mode=stock.DataSources.datafrom.livedata,
datasource_fn=None):
"""strategy_name: str 通过策略名称来构造策略
cbfn_setparams: callback function 回调函数 fn(strategy) 用该函数来重新设置参数
mode : enum/int tick=0/hisdat=1
datasource_mode : 数据源引用地 stock.DataSource.data_mode
datasource_fn: 函数, data_mode需要使用自定义
"""
import backtest_runner
if mode == 0:
mode = backtest_runner.BackTestPolicy.enum.tick_mode
stock.DataSources.data_mode = datasource_mode
stock.datasource_fn = datasource_fn
for code in codes:
print(code, stock.GetCodeName(code))
p = backtest_runner.BackTestPolicy(mode)
p.SetStockCodes([code])
backtesting = Backtest()
account = backtesting.createAccount(account_type=None,
username=None,
pwd=None)
#p.Regist(Strategy_basesign(backtesting, is_backtesting=True))
strategy = strategy_name(backtesting, is_backtesting=True, mode=mode)
#设置策略参数
if cbfn_setparams is not None:
cbfn_setparams(strategy)
else:
strategy.setParams()
print(strategy.getParams())
p.Regist(strategy)
#p.Regist(Strategy_Trade(backtesting, is_backtesting=True))
cur_day = agl.CurDay()
if end_day == '':
end_day = cur_day
#if start_day == '':
##再次修正为已有数据的20天
#start_day = help.MyDate.s_Dec(end_day, -day_num)
d1, d2 = p.initData(start_day, end_day)
if d1 != d2:
print(d1, d2)
p.Run(d1, d2)
else:
print('没有数据')
def testTradeResult_Boll():
code = '002074'
bars = stock.CreateFenshiPd(code, '2017-7-22','2017-8-4')
if len(bars)>0:
bars = bars.resample('1min').mean()
else:
return
bars['c'] = bars['p']
bars = bars.dropna()
zhijin = pd.Series(index=bars.index)
zhijin.loc[:] = 1000000
zhijin[100] = 1010000
zhijin[200] = 980000
TradeResult_Boll(pl, bars, zhijin, None, stock.GetCodeName(code).decode('utf8'))
def test_strategy(codes,
strategy_name,
cbfn_setparams=None,
day_num=20,
mode=0,
start_day='',
end_day=''):
"""strategy_name: str 通过策略名称来构造策略
cbfn_setparams: callback function 回调函数 fn(strategy) 用该函数来重新设置参数
day_num: 当前天或者数据集的最后一天向前推的天数， 同时会修正为数据集有效的第一天
mode : enum/int tick/hisdat
"""
import backtest_runner
if mode == 0:
mode = backtest_runner.BackTestPolicy.enum.tick_mode
for code in codes:
print code, stock.GetCodeName(code)
p = backtest_runner.BackTestPolicy(mode)
p.SetStockCodes([code])
backtesting = Backtest()
account = backtesting.createAccount(account_type=None,
username=None,
pwd=None)
#p.Regist(Strategy_basesign(backtesting, is_backtesting=True))
strategy = strategy_name(backtesting, is_backtesting=True, mode=mode)
#设置策略参数
if cbfn_setparams is not None:
cbfn_setparams(strategy)
else:
strategy.setParams()
print(strategy.getParams())
p.Regist(strategy)
#p.Regist(Strategy_Trade(backtesting, is_backtesting=True))
cur_day = agl.CurDay()
if end_day != '':
cur_day = end_day
d1, d2 = help.MyDate.s_Dec(cur_day, -20), cur_day
if start_day != '':
d1 = start_day
if start_day == '':
#再次修正为已有数据的20天
d1 = help.MyDate.s_Dec(d2, -day_num)
if d1 != d2:
print d1, d2
p.Run(d1, d2)
else:
print '没有数据'
def Report(self):
import time, dateutil, datetime
self._ReadData()
for code, group in self.df_chengjiao.groupby('stock_code'):
if code in myenum.allow_traded_codes:
print code, stock.GetCodeName(code)
df = self.df_chengjiao[self.df_chengjiao['stock_code'] == code]
df = df.loc[:, ['price', 'num', 'is_sell', 'stock_code', 't']]
df.columns = ['price', 'num', 'flag', 'code',
'd'] #匹配web接口里使用的字段
print df
df['d'] = df.index.astype(str)
df['d'] = df['d'].map(lambda x: str(dateutil.parser.parse(x) + \
datetime.timedelta(minutes=5)))
myredis.set_obj('backtest_trade', df)
os.system('start http://localhost/training')
time.sleep(5)
def Run(self):
"""
"""
#self._log('Strategy_Boll_Pre')
#以下为交易测试
code = self.data.get_code() #当前策略处理的股票
self.code = code
if not self.is_backtesting and not self.AllowCode(code):
return
df_hisdat = self.data.get_hisdat(code) #日k线
df_five_hisdat = self.data.get_hisdat(code, dtype='5min') #5分钟k线
df_fenshi = self.data.get_fenshi(code) #日分时
if len(df_fenshi) == 0:
self.data.log(code + u"未取到分时数据")
return
account = self._getAccount() #获取交易账户
price = float(df_fenshi.tail(1)['p']) #当前股价
closes = df_hisdat['c']
yestoday_close = closes[-2] #昨日收盘价
zhangfu = stock.ZhangFu(price, yestoday_close)
self._log(
'price=%.2f %s %s' %
(price, str(df_fenshi.index[-1]), str(df_five_hisdat.iloc[-1])))
account_mgr = ac.AccountMgr(account, price, code)
trade_num = ac.ShouShu(account_mgr.init_money() *
self.trade_num_use_money_percent / price)
trade_num = max(100, trade_num)
# 信号计算
four = stock.FOUR(closes)
four = four[-1]
upper, middle, lower = stock.TDX_BOLL(df_five_hisdat['c'])
highs, lows, closes = df_five_hisdat['h'], df_five_hisdat[
'l'], df_five_hisdat['c']
adx = stock.TDX_ADX(highs, lows, closes)
self._log('boll : %.2f,%.2f,%.2f' % (upper[-1], middle[-1], lower[-1]))
boll_w = abs(upper[-1] - lower[-1]) / middle[-1] * 100
#50个周期内最高值
is_high = abs(price - max(df_five_hisdat[-1000:]['h'])) / price < 0.005
boll_poss = [
upper[-1],
(upper[-1] - middle[-1]) / 2 + middle[-1],
middle[-1],
(middle[-1] - lower[-1]) / 2 + lower[-1],
lower[-1],
]
self._log('boll_poss: %.2f, %.2f boll_w=%.2f adx=%.2f' %
(boll_poss[0], boll_poss[1], boll_w, adx[-1]))
#上一个成交的价位
pre_price = account_mgr.last_chengjiao_price()
pre_pre_price = account_mgr.last_chengjiao_price(index=-2)
sell_count = account_mgr.queryTradeCount(1)
buy_count = account_mgr.queryTradeCount(0)
#买入均价
adx = adx[-1]
boll_up_ratio = 0.02
#信号判断
num = 0
if so.assemble(
price > boll_poss[1],
price > pre_price * (1 + self.trade_ratio),
#price > boll_poss[2],
#price > self.max_buy_price*(1+self.trade_ratio),
#boll_w > 3.5,
#adx > 60,
#sell_count < 2,
#pr.horizontal(df_five_hisdat),
0,
):
num = -trade_num
self.trade_status = self.enum.boll_up_mid
#if self.order(1, code, price, num):
#self._log(agl.utf8_to_ascii('一档卖出%s, %.2f, %d'%(code, price, num)))
if so.assemble(
price > boll_poss[0],
price > pre_price * (1 + self.trade_ratio),
#price > self.max_buy_price*(1+self.trade_ratio),
#boll_w > 3,
adx > 60,
is_high,
#four > self.trade_four[1],
#sell_count < 2,
#self.trade_status == self.enum.nothing,
#0,
):
num = -trade_num * 3
self.trade_status = self.enum.boll_up
#if self.order(1, code, price, num):
#self._log(agl.utf8_to_ascii('二档卖出%s, %.2f, %d'%(code, price, num)))
if so.assemble(
price < boll_poss[-2] * (1 + boll_up_ratio),
price < pre_price * (1 - self.trade_ratio),
#price < boll_poss[2],
#price < self.min_sell_price*(1-0.03),
#boll_w > 3.5,
#adx>60,
#buy_count < 2,
#pr.horizontal(df_five_hisdat),
0,
):
num = trade_num
self.trade_status = self.enum.boll_down_mid
#if boll_w > 6:
#num *= self.trade_num_ratio
#if self.order(0, code, price, num):
#self._log(agl.utf8_to_ascii('一档买入%s, %.2f, %d'%(code, price, num)))
if so.assemble(
price < boll_poss[-1],
price < pre_price * (1 - self.trade_ratio),
#price < self.min_sell_price*(1-0.03),
#boll_w > 3,
#buy_count < 2,
#self.trade_status == self.enum.nothing,
#adx>70,
#four < self.trade_four[0],
#0,
):
num = trade_num * 3
#num = account_mgr.last_chengjiao_num()
self.trade_status = self.enum.boll_down
#if self.order(0, code, price, num):
#self._log(agl.utf8_to_ascii('二档买入%s, %.2f, %d'%(code, price, num)))
#成本区间
if so.assemble(
price < pre_price * (1 - 0.05),
four < -0.1,
self.trade_status == self.enum.boll_up,
0,
):
num = trade_num * self.trade_num_ratio
self.trade_status = self.enum.nothing
if so.assemble(
price > pre_price * (1 + 0.05),
four > 0.1,
self.trade_status == self.enum.boll_down,
0,
):
num = -trade_num * self.trade_num_ratio
self.trade_status = self.enum.nothing
#zz顶抛出后回补
if so.assemble(
price < pre_price * (1 - 0.02),
#sell_count >= 2,
self.trade_status == self.enum.zz_up,
0,
):
#上次zz卖出的数量
num = account_mgr.last_chengjiao_num()
self.trade_status = self.enum.zz_hui_bu
if so.assemble(
price > pre_price * (1 + 0.02),
#sell_count >= 2,
self.trade_status == self.enum.zz_down,
0,
):
#上次zz卖出的数量
num = account_mgr.last_chengjiao_num()
self.trade_status = self.enum.zz_hui_bu
#计算分时zz
zz_sign = 0
closes = df_five_hisdat['c'][-200:].values
zz = stock.ZigZag(closes)
if len(zz) > 2:
zz_result = stock.analyzeZZ(zz)
zz_line_ratio = zz_result[1] / zz_result[0] #线段比率
#扑捉大涨回头的信号
if abs(zz_result[0]) > 0.05 and abs(zz_line_ratio) > 0.05 and abs(
zz_line_ratio) < 0.2 and abs(zz_result[0]) > 0.04:
zz_sign = agl.where(zz_result[1] > 0, 1, -1)
if num != 0:
bSell = agl.where(num > 0, 0, 1)
num = abs(num)
#if bSell:
#num = self._compensate(num, bSell, code)
#基本上每天的振幅都在1个点以上
if abs(stock.ZhangFu(price, yestoday_close)) > 0.01:
self.order(bSell, code, price, num)
zz_pre_price = myredis.createRedisVal('policy_basesign_zz_pre_price',
price)
if so.assemble(
zz_sign != 0,
0,
):
#print self.price, getZZPrePrice(self.price),abs(self.price-getZZPrePrice(self.price))/self.price
num = trade_num * 12
bSell = agl.where(zz_sign > 0, 0, 1)
num = self._compensate(num, bSell, code)
bCanOrder = False
if so.assemble(
bSell,
price > zz_pre_price.get() * (1 + 0.03),
#price > pre_price*(1+self.trade_ratio),
):
bCanOrder = True
self.trade_status = self.enum.zz_up
if so.assemble(
(not bSell),
price < zz_pre_price.get() * (1 - 0.03),
#price < pre_price*(1-self.trade_ratio)
):
bCanOrder = True
self.trade_status = self.enum.zz_down
if bCanOrder:
self._getAccount().Order(bSell, code, price, num)
zz_pre_price.set(price)
#信号发生时语音播报, 并通知界面回显
if not self.is_backtesting and (price > boll_poss[1]
or price < boll_poss[-2]):
codename = stock.GetCodeName(code)
s = '%s, %.2f' % (codename, price)
self.data.show(codename) #通知界面显示
self.data.speak2(s) #语音播报
#tick report
if self.is_backtesting and self.is_tick_report:
self._getAccount().TickReport(df_five_hisdat, 'win')
return
def ExePolicy(self, code):
df_source = self._getUserStrategy()
if len(df_source) == 0:
return
d = []
bHaveCode = False
for i in range(len(df_source)):
strategy_code = df_source.irow(i)['code']
strategy_id = df_source.irow(i)['id']
try:
self._checkImport(strategy_code)
#self._log("run here")
exec(strategy_code)
if initialize(None).find(code) >= 0:
bHaveCode = True
break
except Exception as e:
s = str(e)
d.append({
"strategy_id": strategy_id,
"title": code,
"code": s,
"t": datetime.datetime.now()
})
#一分钟内同一个策略不能提交
if (d[-1]["t"] - self.pre_post_runlog[strategy_id]
).total_seconds() > 60:
agl.LOG(str(e))
basesign.PostRunLog(d)
self.pre_post_runlog[strategy_id] = d[-1]['t']
continue
if bHaveCode == False:
return
live_data = LiveData()
df_hisdat = live_data.getHisdat(code)
df_fenshi = live_data.getFenshi(code)
if len(df_fenshi) == 0:
return
#return
data = {
"code": code,
"fenshi": df_fenshi,
"hisdat": df_hisdat,
'name': stock.GetCodeName(code),
'price': float(df_fenshi.tail(1)['p'])
}
# 取历史redis分时
df_fenshi_1min = df_fenshi.resample("1min")
df_fenshi_1min_pre = fenshi_redis.getOneMinFenshiFromRedis(code)
if df_fenshi_1min_pre is None:
agl.LOG("分时历史取值失败" + code)
else:
df_fenshi_1min = pd.concat([df_fenshi_1min_pre, df_fenshi_1min])
df_fenshi_1min = df_fenshi_1min.dropna()
closes = np.array(df_fenshi_1min['p'])
data['rsi'] = stock.RSI(closes)[-1]
# BOLL
df_fenshi_5min = df_fenshi_1min.resample('5min')
upper, middle, lower = stock.BOLL(np.array(df_fenshi_5min['p']))
data['boll_up'] = upper[-1]
data['boll_mid'] = middle[-1]
data['boll_down'] = lower[-1]
# ATR
atr = stock.ATR(df_fenshi_5min['p'], df_fenshi_5min['p'],
df_fenshi_5min['p'])
data['atr'] = atr[-1]
#执行用户的代码
data['msglist'] = []
for i in range(len(df_source)):
strategy_code = df_source.irow(i)['code']
#strategy_code = strategy_code.replace('\n','')
strategy_id = df_source.irow(i)['id']
agl.LOG(str(strategy_id))
data['strategy_id'] = strategy_id
try:
self._checkImport(strategy_code)
exec(strategy_code)
if initialize(None).find(code) < 0:
continue
sign = handle_data(self, data)
s = "run sussessful"
if sign:
s += " have sign"
agl.LOG(s)
except Exception as e:
s = str(e)
#s += '\n'
s += traceback.format_exc()
d.append({
"strategy_id": strategy_id,
"title": code,
"code": s,
"t": datetime.datetime.now()
})
#所有用户的策略执行完毕后再提交
agl.LOG('start post')
basesign.PostRunLog(d)
if len(data['msglist']) > 0:
agl.LOG(data['msglist'])
basesign.PostMsgList(data['msglist'])
agl.LOG('end post')
def ExePolicy(self, code):
code = agl.unicode_to_utf8(code)
live_data = LiveData()
df_hisdat = live_data.getHisdat(code)
df_fenshi = live_data.getFenshi(code)
df_five_hisdat = live_data.getFiveMinHisdat(code)
if agl.IsNone(df_five_hisdat):
#print code ,'没有5分钟'
return
if len(df_fenshi) == 0:
return
if len(df_five_hisdat) < 30:
return
price = float(agl.FloatToStr(float(df_fenshi.tail(1)['p'])))
yclose = df_hisdat.ix[df_hisdat.index[-1]]['c']
zhangfu = stock.ZhangFu(price, yclose)
rsi = stock.RSI(df_five_hisdat['c'])
#ui.DrawClosesAndVolumes(pl, df_five_hisdat['c'], rsi)
upper, middle, lower = stock.TDX_BOLL(df_five_hisdat['c'])
#ui.DrawTs(pl, df_five_hisdat['c'],mid=middle, high=upper, low=lower)
highs, lows, closes = df_five_hisdat['h'], df_five_hisdat[
'l'], df_five_hisdat['c']
#atr = stock.ATR(highs, lows, closes)
adx = stock.TDX_ADX(highs, lows, closes)
closes = np.array(df_hisdat['c'])
if help.MyDate(agl.datetime_to_date(df_hisdat.index[-1])).d < \
help.MyDate(agl.CurDay()).d:
closes = agl.array_insert(closes, len(closes), price)
four = stock.FOUR(closes)
#print code, four[-1]
self._dict_four[code] = four[-1]
#return
#ui.DrawClosesAndVolumes(pl, df_five_hisdat['c'], adx)
boll_up = (price - upper[-1]) / upper[-1]
boll_mid = (price - middle[-1]) / middle[-1]
boll_down = (lower[-1] - price) / lower[-1]
boll_width = upper[-1] - lower[-1]
if abs(zhangfu) > 0.098 or boll_width < 0.01:
return
if code == '300033':
codename = stock.GetCodeName(code)
s = 'rsi = %d %s %s' % (rsi[-1], codename, str(price))
print s
if (rsi[-1] > 65 or rsi[-1] < 35) and adx[-1] > 60:
codename = stock.GetCodeName(code)
s = '%s %s' % (codename, str(price))
sign = False
#if code in ['300033','510050']:
#sign = True
#if adx[-1] > 55:
#s += ' ADX=%d'%(adx[-1])
#sign = True
if boll_up > -0.003:
s += ' 越过布林上轨'
#sign = True
if abs(boll_mid) < 0.003:
s += ' 布林中轨'
#sign = True
if boll_down > -0.003:
s += ' 越过布林下轨'
sign = True
if four[-1] > 0.1:
sign = False
#sign = False
if sign:
#ui.DrawTs(pl, df_five_hisdat['c'],mid=middle, high=upper, low=lower)
sInfo = self.calcInfo(code, price, zhangfu)
help.myprint(s, sInfo)
help.myprint(
'[%s,%s] %.3f,%.3f,%.3f,%.2f, four=%.2f, adx=%.2f' %
(code, stock.GetCodeName(code), boll_up, boll_mid,
boll_down, boll_width, four[-1], adx[-1]))
self.NotifyAutoxdShow(code)
self.Speak(s)
def test_strategy(codes, strategy_name, cbfn_setparams=None, day_num=20, mode=0, start_day='', end_day=''):
"""strategy_name: str 通过策略名称来构造策略
cbfn_setparams: callback function 回调函数 fn(strategy) 用该函数来重新设置参数
day_num: 当前天或者数据集的最后一天向前推的天数， 同时会修正为数据集有效的第一天
mode : enum/int tick/hisdat
"""
import backtest_runner
if mode == 0:
mode = backtest_runner.BackTestPolicy.enum.tick_mode
for code in codes:
print code, stock.GetCodeName(code)
p = backtest_runner.BackTestPolicy(mode)
p.SetStockCodes([code])
backtesting = Backtest()
account = backtesting.createAccount(account_type=None, username=None, pwd=None)
#p.Regist(Strategy_basesign(backtesting, is_backtesting=True))
strategy = strategy_name(backtesting, is_backtesting=True, mode=mode)
#设置策略参数
if cbfn_setparams is not None:
cbfn_setparams(strategy)
else:
strategy.setParams()
print(strategy.getParams())
p.Regist(strategy)
#p.Regist(Strategy_Trade(backtesting, is_backtesting=True))
cur_day = agl.CurDay()
if end_day != '':
cur_day = end_day
d1, d2 = help.MyDate.s_Dec(cur_day, -20),cur_day
if start_day != '':
d1 = start_day
def getTradeDay(d1, d2, dtype=backtest_runner.BackTestPolicy.enum.hisdat_mode):
"""确定是交易日
return: (d1, d2)"""
try:
if dtype == backtest_runner.BackTestPolicy.enum.hisdat_mode:
df = stock.getHisdatDataFrameFromRedis(code, d1, d2)
else:
df = stock.getFenshiDfUseRedis(code, d1,d2)
if len(df) == 0:
#在指定日期内没有数据，应该是新股或次新股
return d2,d2
d2 = agl.datetime_to_date(df.index[-1])
if agl.DateTimeCmp(d1, agl.datetime_to_date(df.index[0])) <0:
d1 = agl.datetime_to_date(df.index[0])
except:
pass
return d1, d2
#for i in range(10):
#if d1 in df.index:
#return d1,d2
#else:
#d1 = help.MyDate.s_Dec(d1, 1)
d1,d2 = getTradeDay(d1,d2, mode)
if start_day == '':
#再次修正为已有数据的20天
d1 = help.MyDate.s_Dec(d2, -day_num)
d1,d2 = getTradeDay(d1,d2, mode)
if d1 != d2:
print d1, d2
p.Run(d1, d2)
else:
print '没有数据'
