def mytest():
# 数据参数
spe_list = ['ta','m','rb','v','ru','cu','j']
# spe_list = ['m', 'rb', 'v', 'ru', 'cu', 'j']
time_list = [['2014-12-12 21:00:00','2018-08-21 15:30:00'],
['2014-12-26 21:00:00','2018-08-21 15:30:00'],
['2014-12-26 21:00:00','2018-08-21 15:30:00'],
['2009-05-25 09:00:00','2018-08-21 15:30:00'],
['2014-12-26 09:00:00','2018-08-21 15:30:00'],
['2013-12-20 21:00:00','2018-08-21 15:30:00'],
['2014-07-04 21:00:00','2018-08-21 15:30:00'],
]
strategy_list = [[3,5,7,9,11,13],[20,25,30,40,60,80,100]]
for spe in spe_list:
for begintime, endtime in time_list:
for fast in strategy_list[0]:
for slow in strategy_list[1]:
strategy = 'ma_' + spe + '_' + str(fast) + '-' + str(slow)
f_info = futures_info()
commodity_info, finance_info, info = f_info.futures_info()
info = info[spe]
stradict = {}
stradict['info'] = info
stradict['fast_index'] = fast
stradict['slow_index'] = slow
initialmoney = 1000000
# 获取数据
da = event_data(spe, begintime, endtime, 'D')
# 获取回测框架
bt = event_backtest(strategy, info['min_change']*2, initialmoney)
# 获取策略
jm = backtest_ma(stradict)
eventmanger = EventManager()
eventmanger.AddEventLister('begin', da.data_begin)
eventmanger.AddEventLister('data_public', jm.strategy_receive)
eventmanger.AddEventLister('data_receive', da.data_public)
eventmanger.AddEventLister('strategy_public', bt.backtest_receive)
eventmanger.AddEventLister('strategy_receive', jm.strategy_public)
eventmanger.AddEventLister('backtest_public', da.data_receive)
eventmanger.AddEventLister('backtest_receive', bt.backtest_public)
eventmanger.AddEventLister('end', bt.backtest_end)
# 绑定好之后，运行事件管理器
eventmanger.Start()
da.data_add_eventmanager(eventmanger)
bt.backtest_add_eventmanager(eventmanger)
jm.strategy_add_eventmanager(eventmanger)
da.init()
time.sleep(300)
def __init__(self):
info = futures_info()
commo_list, fina_list, futu_list = info.futures_list()
commo_info, fina_info, futu_info = info.futures_info()
self.commo_list = commo_list
self.fina_list = fina_list
self.futu_list = futu_list
self.commo_info = commo_info
self.fina_info = fina_info
self.futu_info = futu_info
def main(self):
spe_list, time_list, period_list = self.spe_time_list()
strategy_list = self.period_strategy_list()
for i in range(0, len(spe_list)):
spe = spe_list[i]
begintime = time_list[i][0]
endtime = time_list[i][1]
# 回测数据获取
class_data = dataload(spe, begintime, endtime, period_list[0])
backtest_data = class_data.backtest_data()
# 策略部分准备
for slow in strategy_list[0]:
strategy_name = 'ma_' + spe + '_' + str(slow) + '-' + str(
strategy_list[1][0])
# 分析类
class_analysis = BackTestAnalysis(strategy_name)
# 查看本地是否有文件，如果没有文件，继续
if class_analysis.strategy_exist():
continue
f_info = futures_info()
commodity_info, finance_info, info = f_info.futures_info()
info = info[spe]
initialmoney = 1000000
slip = info['min_change'] * 2
backtest_dict = {}
backtest_dict['strategy_name'] = strategy_name
backtest_dict['initial_money'] = initialmoney
backtest_dict['slip'] = slip
strategy_dict1 = {}
strategy_dict1['slow_index'] = slow
strategy_dict1['fast_index'] = strategy_list[1][0]
strategy_dict1['info'] = info
strategy_dict2 = copy.deepcopy(strategy_dict1)
strategy_dict2['fast_index'] = strategy_list[1][1]
strategy_dict3 = copy.deepcopy(strategy_dict1)
strategy_dict3['fast_index'] = strategy_list[1][2]
strategy_dict4 = copy.deepcopy(strategy_dict1)
strategy_dict4['fast_index'] = strategy_list[1][3]
strategy_dict5 = copy.deepcopy(strategy_dict1)
strategy_dict5['fast_index'] = strategy_list[1][4]
strategy_dict6 = copy.deepcopy(strategy_dict1)
strategy_dict6['fast_index'] = strategy_list[1][5]
# 回测参数
strategy_name1 = 'ma_' + spe + '_' + str(slow) + '_' + str(
strategy_dict1['fast_index'])
strategy_name2 = 'ma_' + spe + '_' + str(slow) + '_' + str(
strategy_dict2['fast_index'])
strategy_name3 = 'ma_' + spe + '_' + str(slow) + '_' + str(
strategy_dict3['fast_index'])
strategy_name4 = 'ma_' + spe + '_' + str(slow) + '_' + str(
strategy_dict4['fast_index'])
strategy_name5 = 'ma_' + spe + '_' + str(slow) + '_' + str(
strategy_dict5['fast_index'])
strategy_name6 = 'ma_' + spe + '_' + str(slow) + '_' + str(
strategy_dict6['fast_index'])
backtest_dict1 = {}
backtest_dict1['name'] = strategy_name1
backtest_dict1['initial_money'] = initialmoney
backtest_dict1['slip'] = slip
backtest_dict2 = copy.deepcopy(backtest_dict1)
backtest_dict2['name'] = strategy_name2
backtest_dict3 = copy.deepcopy(backtest_dict1)
backtest_dict3['name'] = strategy_name3
backtest_dict4 = copy.deepcopy(backtest_dict1)
backtest_dict4['name'] = strategy_name4
backtest_dict5 = copy.deepcopy(backtest_dict1)
backtest_dict5['name'] = strategy_name5
backtest_dict6 = copy.deepcopy(backtest_dict1)
backtest_dict6['name'] = strategy_name6
# self.min_unit(data_dict, strategy_dict, backtest_dict)
# 查看本地是否有文件，如果没有文件，继续
if BackTestAnalysis(strategy_name1).strategy_exist():
continue
t1 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict1,
backtest_dict1,
))
t2 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict2,
backtest_dict2,
))
t3 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict3,
backtest_dict3,
))
t4 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict4,
backtest_dict4,
))
t5 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict5,
backtest_dict5,
))
t6 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict6,
backtest_dict6,
))
t1.start()
t2.start()
t3.start()
t4.start()
t5.start()
t6.start()
t1.join()
t2.join()
t3.join()
t4.join()
t5.join()
t6.join()
# 数据回测完之后，要分析
self.analysis_all()
def main(self):
macd = MACD_JW()
atr = atr_event()
f_info = futures_info()
commodity_info, finance_info, info = f_info.futures_info()
lis = self.macd_list()
list_cal = [] # 时间 品种 涨跌 四个价位 止损 对应手数
for li in lis:
# 提取品种
spe = ''
for sp in li:
if sp > '9':
spe = spe + sp
spe = spe.lower()
# 获取品种交易单位
trading_unit = info[spe]['trading_unit']
# 读取pandas形式的数据
data = self.macd_data_read(li)
# 将数据macd处理
for d in range(0, len(data)):
macd.macd_main(data.iloc[d])
# atr处理
for d in range(0, len(data)):
atr.atr_main(data.iloc[d])
# 根据当前资金，以及atr，计算当前对应手数
mini_posi = self.money * 0.01 / trading_unit / atr.atr[-1]
mini_posi = float('%.2f' % mini_posi)
# 时间
lasttime = macd.data[-1][0]
# 品种
species = li
# 对应手数
position = mini_posi
# 加仓点位
posiadd = 0.5 * float('%.2f' % atr.atr[-1])
# 如果是金叉
if macd.gold_dead[-1] == 'gold':
# 涨跌
rise_or_fall = 'rise'
# 四个价位
p1 = macd.data[-1][4]
p2 = p1 + posiadd
p3 = p2 + posiadd
p4 = p3 + posiadd
stop = p1 - 2 * posiadd
list_cal.append([
lasttime, species, rise_or_fall, p1, p2, p3, p4, stop,
position
])
if macd.gold_dead[-1] == 'dead':
# 涨跌
rise_or_fall = 'fall'
# 四个价位
p1 = macd.data[-1][4]
p2 = p1 - posiadd
p3 = p2 - posiadd
p4 = p3 - posiadd
stop = p1 + 2 * posiadd
list_cal.append([
lasttime, species, rise_or_fall, p1, p2, p3, p4, stop,
position
])
if len(list_cal) != 0:
self.macd_refer_excel(list_cal)
print('Done!')
def main(self):
spe_list, time_list, period_list = self.spe_time_list()
strategy_list = self.period_strategy_list()
for i in range(0, len(spe_list)):
# 数据参数部分
spe = spe_list[i]
begintime = time_list[i][0]
endtime = time_list[i][1]
period = period_list[0]
# 首先，读取数据
class_data = dataload(spe, begintime, endtime, period)
backtest_data = class_data.backtest_data()
# 策略部分准备
for Length_slow in strategy_list[0]:
# 策略参数
phase = strategy_list[2][0]
initialmoney = 1000000
f_info = futures_info()
commodity_info, finance_info, info = f_info.futures_info()
info = info[spe]
slip = info['min_change'] * 2
"""
data_dict = {}
data_dict['spe'] = spe
data_dict['begintime'] = begintime
data_dict['endtime'] = endtime
data_dict['period'] = period
"""
strategy_dict1 = {}
strategy_dict1['Length_slow'] = Length_slow
strategy_dict1['Length_fast'] = strategy_list[1][0]
strategy_dict1['phase'] = phase
strategy_dict2 = copy.deepcopy(strategy_dict1)
strategy_dict2['Length_fast'] = strategy_list[1][1]
strategy_dict3 = copy.deepcopy(strategy_dict1)
strategy_dict3['Length_fast'] = strategy_list[1][2]
strategy_dict4 = copy.deepcopy(strategy_dict1)
strategy_dict4['Length_fast'] = strategy_list[1][3]
strategy_dict5 = copy.deepcopy(strategy_dict1)
strategy_dict5['Length_fast'] = strategy_list[1][4]
# 回测参数
strategy_name1 = 'jma_' + spe + '_' + str(
Length_slow) + '_' + str(strategy_dict1['Length_fast'])
strategy_name2 = 'jma_' + spe + '_' + str(
Length_slow) + '_' + str(strategy_dict2['Length_fast'])
strategy_name3 = 'jma_' + spe + '_' + str(
Length_slow) + '_' + str(strategy_dict3['Length_fast'])
strategy_name4 = 'jma_' + spe + '_' + str(
Length_slow) + '_' + str(strategy_dict4['Length_fast'])
strategy_name5 = 'jma_' + spe + '_' + str(
Length_slow) + '_' + str(strategy_dict5['Length_fast'])
backtest_dict1 = {}
backtest_dict1['name'] = strategy_name1
backtest_dict1['initial_money'] = initialmoney
backtest_dict1['slip'] = slip
backtest_dict2 = copy.deepcopy(backtest_dict1)
backtest_dict2['name'] = strategy_name2
backtest_dict3 = copy.deepcopy(backtest_dict1)
backtest_dict3['name'] = strategy_name3
backtest_dict4 = copy.deepcopy(backtest_dict1)
backtest_dict4['name'] = strategy_name4
backtest_dict5 = copy.deepcopy(backtest_dict1)
backtest_dict5['name'] = strategy_name5
# self.min_unit(data_dict, strategy_dict, backtest_dict)
# 查看本地是否有文件，如果没有文件，继续
if BackTestAnalysis(strategy_name1).strategy_exist():
continue
t1 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict1,
backtest_dict1,
))
t2 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict2,
backtest_dict2,
))
t3 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict3,
backtest_dict3,
))
t4 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict4,
backtest_dict4,
))
t5 = threading.Thread(target=self.min_unit,
args=(
backtest_data,
strategy_dict5,
backtest_dict5,
))
t1.start()
t2.start()
t3.start()
t4.start()
t5.start()
t1.join()
t2.join()
t3.join()
t4.join()
t5.join()
#==========================策略分析========================
self.analysis_all()