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

成都创新互联公司坚持“要么做到，要么别承诺”的工作理念，服务领域包括：网站设计制作、成都做网站、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的察雅网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

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

点击(此处)折叠或打开

1. # encoding: UTF-8

2. from __future__ import division

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)

15. class GridStrategy(CtaTemplate):

16.     className = 'GridStrategy'

17.     author = u'BillyZhang'

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     # 计算止损距离的乘数

30.     # 基本变量

31.     upline = 0   #当前上线

32.     bottomline = 0 #当前下线

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

34.     intraTradeHigh = 0

35.     intraTradeLow = 0

36.     atrValue = 0

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']

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)

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()

83.     def onStart(self):

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

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

86.         self.putEvent()

88.     def onStop(self):

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

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

91.         self.putEvent()

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)

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]

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)

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

181.     def onTick(self, tick):

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

183.         self.bg.updateTick(tick)

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

186.     def onBar(self, bar):

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

188.         self.bg.updateBar(bar)

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

190.     def onOrder(self, order):

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

192.         pass

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

208.         self.putEvent()

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

211.     def onStopOrder(self, so):

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

213.         pass

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

网站标题：VNPY单品种期货的网格交易策略的实现是怎样的-创新互联
文章分享：http://chengdu.cdxwcx.cn/article/csgpdo.html