VNPY单品种期货的网格交易策略的实现是怎样的

这篇文章给大家介绍VNPY单品种期货的网格交易策略的实现是怎样的，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。

这里做了单品种期货网格交易策略实现。
当bar.close在通道中时候，下个bar打到上轨开多单，打到下轨空单。
这里采用了均量交易法,就是每笔下单手数都是一样，并非金字塔式下单。
有多单时候，突破上线加多单，突破下线情况清空所有多单，当多单到达定义的最大手数不再下单
为防止在一个线上下波动，造成重复开平仓情况，如果突破平仓，比如平多单，后面n个bar不能再开多单，只能开空单；反之平空单后，
现在这个策略很粗糙，只做实现逻辑分析，可以回测，考虑涉及仓位控制，别实盘。

点击(此处)折叠或打开

1. # encoding: UTF-8
   

2. from __future__ import division
   

3. 
   

4. 
   

5. 
   

6. from vnpy.trader.vtGateway import *
   

7. from math import isnan
   

8. import numpy as np
   

9. import pandas as pd
   

10. from vnpy.trader.app.ctaStrategy.ctaTemplate import (CtaTemplate, TargetPosTemplate,
    

11.                                                      BarGenerator,
    

12.                                                      ArrayManager)
    

13. 
    

14. 
    

15. class GridStrategy(CtaTemplate):
    

16.     className = 'GridStrategy'
    

17.     author = u'BillyZhang'
    

18. 
    

19.     # 策略参数
    

20.     historyBars = 200  # 历史数据大小，用来确定网格基准线
    

21.     initDays = 20  # 初始化数据所用的天数，随着历史数据大小要改变
    

22.     gridlines = 10  # 网格线数量，单边数量
    

23.     ordersize = 10  # 最大持仓数量
    

24.     order = 1      # 每次下单手数
    

25.     barMins = 30    #bar的时间
    

26.     frozenBars = 1 #平仓后，frozenBars个bar不再开反向单
    

27.     atrWindow = 30         # ATR窗口数
    

28.     slMultiplier = 5.0     # 计算止损距离的乘数
    

29. 
    

30.     # 基本变量
    

31.     upline = 0   #当前上线
    

32.     bottomline = 0 #当前下线
    

33.     frozen = 0 #当前是否冻结开反向单
    

34.     intraTradeHigh = 0
    

35.     intraTradeLow = 0
    

36.     atrValue = 0
    

37. 
    

38. 
    

39. 
    

40.     # 参数列表，保存了参数的名称
    

41.     paramList = ['name',
    

42.                  'className',
    

43.                  'author',
    

44.                  'vtSymbol',
    

45.                  'historyBars'
    

46.                  'initDays',
    

47.                  'gridlines',
    

48.                  'barMins',
    

49.                  'order',
    

50.                  'ordersize',
    

51.                  'atrWindow',
    

52.                  'slMultiplier'
    

53.                  ]
    

54.     # 变量列表，保存了变量的名称
    

55.     varList = ['inited',
    

56.                'trading',
    

57.                'pos',
    

58.                'frozen',
    

59.                'upline',
    

60.                'bottomline'
    

61.                'atrValue']
    

62.     # 同步列表，保存了需要保存到数据库的变量名称
    

63.     syncList = ['pos',
    

64.                 'frozen']
    

65. 
    

66.     # ----------------------------------------------------------------------
    

67.     def __init__(self, ctaEngine, setting):
    

68.         """Constructor"""
    

69.         super(GridStrategy, self).__init__(ctaEngine, setting)
    

70.         self.bg = BarGenerator(self.onBar, self.barMins, self.onXminBar) # 创建K线合成器对象
    

71.         self.am = ArrayManager(self.historyBars + 50)
    

72. 
    

73.     # ----------------------------------------------------------------------
    

74.     def onInit(self):
    

75.         """初始化策略（必须由用户继承实现）"""
    

76.         self.writeCtaLog(u'%s策略初始化' % self.name)
    

77.         # 载入历史数据，并采用回放计算的方式初始化策略数值
    

78.         initData = self.loadBar(self.initDays)
    

79.         for bar in initData:
    

80.             self.onBar(bar)
    

81.         self.putEvent()
    

82. 
    

83.     def onStart(self):
    

84.         """启动策略（必须由用户继承实现）"""
    

85.         self.writeCtaLog(u'%s策略启动' % self.name)
    

86.         self.putEvent()
    

87. 
    

88.     def onStop(self):
    

89.         """停止策略（必须由用户继承实现）"""
    

90.         self.writeCtaLog(u'%s策略停止' % self.name)
    

91.         self.putEvent()
    

92. 
    

93. 
    

94. 
    

95.     # -----------------------------------------------------------------------
    

96.     def onXminBar(self, bar):
    

97.         """收到X分钟K线"""
    

98.         # 全撤之前发出的委托
    

99.         self.cancelAll()
    

100.         # 保存K线数据
     

101.         am = self.am
     

102.         am.updateBar(bar)
     

103.         if not am.inited:
     

104.             return
     

105.         # 这里采用了均量交易法,就是每笔。
     

106.         # 空仓时候，每次突破上线是开多单，突破下线是开空单；
     

107.         # 有多单时候，突破上线加多单，突破下线情况清空所有多单，
     

108.         # 有空单时候，突破下线加空单，突破上线清空所有空单，
     

109.         # 为防止在一个线上下波动，造成重复开平仓情况，如果突破平仓，比如平多单，后面n个bar不能再开多单，只能开空单；反之平空单后，
     

110.         # 后面n个bar只能开多单。
     

111.         # 计算网格,返回通道队列, 再算出当前点位所在通道，0为最下通道，2*self.gridlines - 1为最上通道
     

112.         baseline = self.am.sma(self.historyBars)
     

113.         # 过去300的标准差，按照顶一个gridlines取整做出一个队列
     

114.         intervallist = baseline+ np.array([n * 1.00 / self.gridlines for n in range(-1 * self.gridlines, self.gridlines + 1)]) * self.am.std(self.historyBars)
     

115. 
     

116.         griploc = pd.cut([bar.close], intervallist, labels=[nx for nx in range(0,2*self.gridlines)])[0]
     

117.         # 如果返回为nan，说明现在bar.close在标准差范围以外，如果没有仓位，先不处理；如果有，按照ATR波动移动止盈
     

118.         if isnan(griploc):
     

119.             # 持有多头仓位
     

120.             if self.pos > 0:
     

121.                 self.intraTradeHigh = max(self.intraTradeHigh, bar.high)
     

122.                 self.intraTradeLow = bar.low
     

123.                 self.longStop = self.intraTradeHigh - self.atrValue * self.slMultiplier
     

124.                 self.sell(self.longStop, abs(self.pos), True)
     

125.             # 持有空头仓位
     

126.             elif self.pos < 0:
     

127.                 self.intraTradeHigh = bar.high
     

128.                 self.intraTradeLow = min(self.intraTradeLow, bar.low)
     

129.                 self.shortStop = self.intraTradeLow + self.atrValue * self.slMultiplier
     

130.                 self.cover(self.shortStop, abs(self.pos), True)
     

131.             return
     

132.         #返回上下线：
     

133.         self.upline = intervallist[griploc + 1]
     

134.         self.bottomline = intervallist[griploc]
     

135. 
     

136.         # 空仓时候，每次突破上线是开多单，突破下线是开空单；
     

137.         # 如果此时在最下一个通道，此时只挂往上的多单, 如果在最上面通道，此时只挂往下空单；如果在中间的，则同时开上下单
     

138.         if self.pos == 0:
     

139.             if griploc ==0:
     

140.                 self.buy(self.upline, self.order, True)
     

141.             elif griploc == 2*self.gridlines - 1:
     

142.                 self.short(self.bottomline,self.order,True)
     

143.             else:
     

144.                 #此时如果frozen 为0， 直接开上下单：
     

145.                 if self.frozen == 0:
     

146.                     self.buy(self.upline, self.order, True)
     

147.                     self.short(self.bottomline, self.order, True)
     

148.                 #此时如果大于0，只能开空单，如果小于0，只能开多单
     

149.                 elif self.frozen > 0:
     

150.                     self.frozen = self.frozen -1
     

151.                     self.short(self.bottomline, self.order, True)
     

152.                 elif self.frozen < 0:
     

153.                     self.frozen = self.frozen + 1
     

154.                     self.buy(self.upline, self.order, True)
     

155.         #如果持有多仓时候，如果在中间通道，同时开上下单；如果最高点位不再开单，突破最大标准差高点，
     

156.         elif self.pos > 0:
     

157.             # 在最下通道不可能有多单，只用考量在中间段,pos 小于ordersize可以增多仓，否则只能向下平仓；和最高段情况,最高段设置往下平仓，
     

158.             if griploc == 2*self.gridlines - 1:
     

159.                 self.intraTradeHigh = bar.high
     

160.                 self.sell(self.bottomline, abs(self.pos), True)
     

161.             else:
     

162.                 if abs(self.pos) < self.ordersize:
     

163.                     self.buy(self.upline, self.order, True)
     

164.                     self.sell(self.bottomline, abs(self.pos), True)
     

165.                 else:
     

166.                     self.sell(self.bottomline, abs(self.pos), True)
     

167.         elif self.pos < 0:
     

168.             # 最上通道通道不可能有空单，只用考虑中间段，和最低档情况
     

169.             if griploc == 0:
     

170.                 self.intraTradeLow = bar.low
     

171.                 self.cover(self.upline,abs(self.pos),True)
     

172.             else:
     

173.                 if abs(self.pos) < self.ordersize:
     

174.                     self.cover(self.upline, abs(self.pos),True)
     

175.                     self.sell(self.bottomline, self.order, True)
     

176.                 else:
     

177.                     self.cover(self.upline, abs(self.pos), True)
     

178. 
     

179. 
     

180.     # ----------------------------------------------------------------------
     

181.     def onTick(self, tick):
     

182.         """收到行情TICK推送（必须由用户继承实现）"""
     

183.         self.bg.updateTick(tick)
     

184. 
     

185.     # ----------------------------------------------------------------------
     

186.     def onBar(self, bar):
     

187.         """收到Bar推送（必须由用户继承实现）"""
     

188.         self.bg.updateBar(bar)
     

189.     # ----------------------------------------------------------------------
     

190.     def onOrder(self, order):
     

191.         """收到委托推送"""
     

192.         pass
     

193. 
     

194. 
     

195.     # ----------------------------------------------------------------------
     

196.     def onTrade(self, trade):
     

197.         # 发出状态更新事件
     

198.         # 如果收到成交，清空所有挂单
     

199.         self.cancelAll()
     

200.         # 如果交易多头方向，且现在仓位为0，则应该是空头平仓，不再开空单
     

201.         if trade.direction == DIRECTION_LONG and self.pos == 0:
     

202.             self.frozen = -1* self.frozen
     

203.         # 如果交易空头方向，且现在仓位为0，则应该是多平仓，不再开多单
     

204.         elif trade.direction == DIRECTION_SHORT and self.pos == 0:
     

205.             self.frozen = self.frozen
     

206. 
     

207. 
     

208.         self.putEvent()
     

209. 
     

210.     # ----------------------------------------------------------------------
     

211.     def onStopOrder(self, so):
     

212.         """停止单推送"""
     

213.         pass

关于VNPY单品种期货的网格交易策略的实现是怎样的就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。