经典量化交易策略系列——海龟交易系统python源码及策略

金融老法师

1983年，著名的商品投机家理查德.丹尼斯挑选了13个人进行培训，他教给这13个学员一套完整的交易系统，由于学员们被称为“海龟”，后来人们就把这套系统称为海龟交易系统。

    海龟交易系统简介：

    交易信号：海龟的交易信号其实很简单，当价格创20或50天新高就买入，当价格创10天或20天新低就卖出，时间上具体的参数使用者也可以自己调整。

    头寸管理和风险控制策略：海龟交易系统由总资金风险百分比和N波动的系数策略来决定交易头寸的多少，用N确定什么时候加仓、加多少，同时用2N来确定头寸的保护性损止。N每7天调整一次（五个交易日）。这就是海龟交易系统的交易策略，属于一套完整的交易系统。下面是我写的海龟交易系统测试版的编程源码。

    海龟交易策略：

    1.基本原理：本策略的大框架是按照原版的海龟策略搭建的，但是在具体实现方面有些改动。

    市场：本策略中选取了一只股票，中国平安，为简化起见。

    头寸规模：本策略中最大头寸规模限制为4unit。

1. #源码：
   
2. 
   
3. import numpy as np      
   
4. import pandas as pd
   
5. from pandas import Series,DataFrame
   
6. import random
   
7. import math
   
8. # 定义一个全局变量, 保存要操作的证券
   
9. security='600196.XSHG'
   
10. # 设置我们要操作的股票池, 这里我们只操作一支股票
    
11. set_universe([security])
    
12. set_benchmark('600196.XSHG')
    
13. #设置回测条件
    
14. set_commission(PerTrade(buy_cost=0.0008, sell_cost=0.0015, min_cost=5))
    
15. set_slippage(FixedSlippage(0))
    
16. #调整资金规模时的临界损失比例
    
17. loss=0.1
    
18. #调整资金规模时调整后的资金占当前资金的比例
    
19. adjust=0.8
    
20. #计算第一个N时取得股票数据的天数
    
21. days=20
    
22. #系统一入市时股票价格需要高于short_in天内的最高价
    
23. short_in=20
    
24. #系统二入市时股票价格需要高于long_in天内的最高价
    
25. long_in=55
    
26. #系统一离市时股票价格需要低于short_out天内的最低价
    
27. short_out=10
    
28. #系统二离市时股票价格需要低于long_out天内的最低价
    
29. long_out=20
    
30. #系统一和系统二的资金分配比例，系统一得到ratio*总资金，系统二得到（1-ratio）*总资金
    
31. ratio=0.7
    
32. #单一市场中的头寸规模限制
    
33. limit=4
    
34. #记录策略运行了多少天
    
35. pdn=0
    
36. #记录N值
    
37. N=[]
    
38. #记录系统一中股票的单位数
    
39. sys1=0
    
40. #记录系统二中股票的单位数
    
41. sys2=0
    
42. #判断操作是对系统一还是系统二，值为‘True’是对系统一，‘False’是对系统二
    
43. short='False'
    
44. #用unit来保存一单位表示多少股票，默认值为1000
    
45. unit=1000
    
46. #记录系统一形成突破时的股票价格
    
47. break_price1=0
    
48. #记录系统二形成突破时的股票价格
    
49. break_price2=0
    
50. #记录分钟
    
51. minutes=0
    
52. 
    
53. #计算股票的N值
    
54. def Calcu_N(context,paused):
    
55.     #在策略运行了days-1天时，计算前days-1天的平均实际范围
    
56.     if pdn==days-1:
    
57.         #取出day-1天来得最高价，最低价，前一天的收盘价
    
58.         price=attribute_history(security,days-1,'1d', ('high','low','pre_close'),skip_paused=True)
    
59.         #如果不是所有的这day-1天都没有数据，算出这些天的实际范围的平均值
    
60.         TR=[]
    
61.         for i in range(0,days-1):
    
62.             h_l=price['high'][i]-price['low'][i]
    
63.             h_pdc=price['high'][i]-price['pre_close'][i]
    
64.             pdc_l=price['pre_close'][i]-price['low'][i]
    
65.             temp=max(h_l,h_pdc,pdc_l)
    
66.             TR.append(temp)
    
67.         ATR=np.mean(np.array(TR))
    
68.         N.append(ATR)
    
69.         
    
70.     #如果策略运行天数已经达到了days天
    
71.     else:
    
72.         #如果股票停牌，则将运行天数减1
    
73.         if paused==True:
    
74.             global pdn
    
75.             pdn=pdn-1
    
76.         #如果未停牌，则利用迭代，计算N值，并保存在列表N中
    
77.         else:
    
78.             price=attribute_history(security,1,'1d', ('high','low','pre_close'),skip_paused=True)
    
79.             h_l=price['high'][0]-price['low'][0]
    
80.             h_pdc=price['high'][0]-price['pre_close'][0]
    
81.             pdc_l=price['pre_close'][0]-price['low'][0]
    
82.             temp=max(h_l,h_pdc,pdc_l)
    
83.             TR.append(temp)
    
84.             ATR=np.mean(np.array(TR))
    
85.             N.append(ATR)
    
86.             
    
87. #止损
    
88. def Stop_Loss(current_price):
    
89.     #如果对系统一操作，则将突破价设置为系统一的突破价，如果是对系统二，则设置为系统二的
    
90.     if short=='True':
    
91.         break_price=break_price1
    
92.     else:
    
93.         break_price=break_price2
    
94.     #如果当前价格比上次的突破价低2N，则清空头寸
    
95.     #并相应的更改相应系统中的股票单位数
    
96.     if current_price
    
97.         if short=='True':
    
98.             order(security,-sys1)
    
99.             global sys1
    
100.             sys1=0  
     
101.         else:
     
102.             order(security,-sys2)
     
103.             global sys2
     
104.             sys2=0
     
105.             
     
106. #入市
     
107. def Sys_In(highest,day_in,context,current_price,cash):
     
108.     #取出day_in天以来的最高价
     
109.     price=attribute_history(security,day_in,'1d',('high','open'))
     
110.     #如果当前价格高于day_in天的最高价，则形成突破
     
111.     if current_price>max(price['high']) and current_price>=highest:
     
112.         #计算可以买的股票数量
     
113.         num_of_shares=cash/current_price
     
114.         #如果可以买的数量不小于一单位，且目前持有的股票数量未达到限制的数量，则买入
     
115.         if num_of_shares>=unit:
     
116.             if short=='True':
     
117.                 if sys1
     
118.                     order(security,+int(unit))
     
119.                     #买入后，相应的更新持有的股票数及突破价格
     
120.                     global sys1
     
121.                     sys1=sys1+int(unit)
     
122.                     global break_price1
     
123.                     break_price1=current_price
     
124.             else:
     
125.                 if sys2
     
126.                     order(security,+int(unit))
     
127.                     global sys2
     
128.                     sys2=sys2+int(unit)
     
129.                     global break_price2
     
130.                     break_price2=current_price
     
131.    
     
132. #增加单位   
     
133. def Sys_Add(day_in,context,current_price,cash):
     
134.     #根据short的值判断是对哪个系统操作，以对突破价格赋值
     
135.     if short=='True':
     
136.         break_price=break_price1
     
137.     else:
     
138.         break_price=break_price2
     
139.     #如果当前价格比上次的突破价格高0.5*N，则增加一单位
     
140.     if current_price>=break_price+0.5*N[-1]:
     
141.         num_of_shares=cash/current_price
     
142.         if num_of_shares>=unit:
     
143.             if short=='True':
     
144.                 if sys1
     
145.                     order(security,+int(unit))
     
146.                     global sys1
     
147.                     sys1=sys1+int(unit)
     
148.                     global break_price1
     
149.                     break_price1=current_price
     
150.             else:
     
151.                 if sys2
     
152.                     order(security,+int(unit))
     
153.                     global sys2
     
154.                     sys2=sys2+int(unit)
     
155.                     global break_price2
     
156.                     break_price2=current_price
     
157.    
     
158. # 离市
     
159. def Sys_Out(day_out,current_price,context):
     
160.     #取出day_out天以来的最低价
     
161.     price=attribute_history(security,day_out,'1d',('high','low'),skip_paused=True)
     
162.     #如果股票当前价格比day_out天的最低价低，则清空系统内的头寸
     
163.     #并将相应系统的头寸数量置为0
     
164.     if current_price
     
165.         if short=='True':
     
166.             if sys1>0:
     
167.                 order(security,-sys1)
     
168.                 global sys1
     
169.                 sys1=0
     
170.         else:
     
171.             if sys2>0:
     
172.                 order(security,-sys2)
     
173.                 global sys2
     
174.                 sys2=0
     
175. 
     
176. #每个单位时间(如果按天回测,则每天调用一次,如果按分钟,则每分钟调用一次)调用一次
     
177. def handle_data(context, data):
     
178.     global minutes
     
179.     minutes=minutes+1
     
180.     price=attribute_history(security,minutes,'1m',('high','price','open'),skip_paused=True)
     
181.     #取得从今天开盘为止的最高价
     
182.     highest=max(price['open'])
     
183.     #用paused保存股票是否停牌
     
184.     paused=data[security].paused
     
185.     #用dt保存当前时间
     
186.     dt=context.current_dt
     
187.     #保存当前股票价格
     
188.     current_price=data[security].price
     
189.     #保存资产组合的总值
     
190.     value=context.portfolio.portfolio_value
     
191.     #在每天开市时将策略运行时间加1
     
192.     if dt.hour==9 and dt.minute==30:
     
193.         global minutes
     
194.         minutes=0
     
195.         global pdn
     
196.         pdn=pdn+1
     
197.         #在运行时间达到days-1天时计算头寸单位
     
198.         if pdn==days-1:
     
199.             Calcu_N(context,paused)
     
200.     #运行时间达到days天时开始执行各种买卖操作
     
201.     if pdn>=days:
     
202.         if pdn==days:
     
203.             global break_price1
     
204.             break_price1=current_price*5+1
     
205.         #如果股票不停牌
     
206.         if paused==False:
     
207.             #取得当前现金
     
208.             cash=context.portfolio.cash
     
209.             #如果空仓了
     
210.             if sys1==0 and sys2==0:
     
211.                 #调整资金规模
     
212.                 if context.portfolio.portfolio_value<(1-loss)*context.portfolio.starting_cash:
     
213.                     cash=adjust*cash
     
214.                     value=adjust*value
     
215.             #每点价值量（yuan per point）
     
216.             ypp=1.0
     
217.             #价值量波动性 value volatility
     
218.             vv=ypp*N[-1]
     
219.             #计算一单位的数量
     
220.             global unit
     
221.             unit=value*0.01/vv
     
222.             #将short置为‘True’，对系统一进行操作
     
223.             global short
     
224.             short='True'
     
225.             #如果系统一没有头寸，并且当前价格比上次的突破价低，入市
     
226.             if sys1==0:
     
227.                 #入市
     
228.                 Sys_In(highest,short_in,context,current_price,ratio*cash)
     
229.             #如果已经有了头寸，则进行止损或者增加单位
     
230.             else:
     
231.                 #止损
     
232.                 Stop_Loss(current_price)
     
233.                 #增加单位
     
234.                 Sys_Add(short_in,context,current_price,ratio*cash)   
     
235.             #离市
     
236.             Sys_Out(short_out,current_price,context)
     
237.             #将short置为‘False’，对系统二进行操作
     
238.             global short
     
239.             short='False'
     
240.             if sys2==0:
     
241.                 #入市
     
242.                 Sys_In(highest,long_in,context,current_price,(1-ratio)*cash)
     
243.             else:
     
244.                 Stop_Loss(current_price)
     
245.                 Sys_Add(long_in,context,current_price,(1-ratio)*cash)
     
246.             #离市
     
247.             Sys_Out(long_out,current_price,context)   
     

复制代码

    入市：策略中有系统一和系统二两个入市系统。

    止损：使用以价格为基础的止损条件，当股价比买入时股价低2N时将持有的头寸清空。

    离市：在当前股价比day_out天以来的最低价还低时把持有的头寸清空。

    策略：执行限价指令以避免对实际市场价格造成大的波动是原版的海龟交易策略，由于本策略采用以前的数据进行回测，并没有干扰市场的问题，因为股票价格已经给定，所以都执行的是市价指令。

    2.变量计算及操作：

    下文把各个变量的计算及一些操作出来进行说明，因为涉及到的变量计算和操作较多。

    1.N的计算方式：N=(19×PDN+TR)/20，其中，PDN是指前一天的N，
      TR（实际范围）=max(H-L,H-PDC,PDC-L)
      式中：
      H-当日最高价
      L-当日最低价
      PDC-前个交易日的收盘价
      在本策略中，用于迭代的第一个N是采用days天内数据可用的那些天的TR的平均值。
    2.Unit的计算方式：unit=帐户净值的1%/(N×每点价值量)
      每点价值量 是指一手合约的价格每变动一个最小单位，整个合约变动的价格。在中国股市中，股票价格变动的最小价格一般是0.01元，一手股票是100股，因此每点价值量就是0.01*100=1。
    3.入市：价格形成突破，即当前股票价格>day_in天中股票的最高价格
      对于系统一，day_in=short_in，对于系统二，day_in=long_in
      对于系统一，如果上一次的突破实现了盈利，那么下一次就忽视掉系统一的突破信号
      入市以后的增加单位：如果在持有头寸之后，股票价格在上次突破时的价格的基础上又上涨了0.5N，则再买入一单位股票
      注：short_in是系统一入市时的参数，表示取多少天内的股票价格，例如，如果设置short_in=20，则当前股票价格>20天中股票的最高价格时算一次突破。
      Long_in是系统二的入市参数，含义同short_in
    4.增加单位：当股票价格>上次突破价格+0.5N时，在原来持有的头寸的基础上继续增加一单位
    5.止损：如果股票价格相对于上次买入的价格下降了2N，则把持有的头寸清仓
    6.离市：如果股票价格小于day_out天来得最低价，则清空持有的头寸
对于系统一，day_out=short_out。对于系统二，day_out=long_out
      注：short_out是系统一的离市参数，如果股票价格小于short_out天中股票的最低价，则离市，long__out同理
    7.调整资金规模：在将头寸全部清空之后，判断如果当前资金小于（1-loss）初始资金，则将可调用的资金缩减为adjust当前资金
注：loss,adjust是调整资金规模的参数，loss表示调整资金规模时的损失比例，即如果损失的资金占初始资金得比例达到loss时，需要调整资金规模。
      Adjust表示资金规模的调整系数，即每次调整时，将可用资金缩减到adjust*当前资金
      注：系统一和系统二是两个独立的系统，这两个系统的资金分配由ratio控制，系统一得到的资金占总资金的比例为ratio，系统二所占比例为1-ratio。此外，在购买股票和清空持有头寸时，两系统也是独立的，清空不是指把所有股票都清空，而是哪个系统需要清空就清空该系统内的股票。

    3.海龟策略流程

    1.计算N，unit，
    2.判断是否调整资金规模，如果需要，则进行调整
    3.进行系统一，根据当前价格，系统一中的头寸判断应该入市，还是增加单位，还是止损，还是离市
    4.进行系统二，同样，根据当前价格，系统一中的头寸判断应该入市，还是增加单位，还是止损，还是离市