量化交易策略—鳄鱼法则交易系统(2)

关于交易系统的介绍和相关概念见上一篇：《量化交易策略—鳄鱼法则交易系统》

1.选股

    选择沪深300指数成分股；沉睡的鳄鱼（选择连续20交易日处于沉睡状态的股票，建立buy_stock池）；每6个月更新股票池；benchmark沪深300指数。

2.入场

    存在有效碎形；有效碎形被突破；AO指标连续5日上行；AC指标连续3日上行；收盘价高于前一日收盘价；按g.amount=总资金/股票池股数×乘数因子3买入。

3.止损&止盈

    个股累计收益率（以成本价为基准）超过30%，全部卖出；
    个股累计收益率下跌10%，全部卖出；
    大盘3日累计收益率下跌3%，全部股票清仓。

4.加仓&减仓

    AO连续5日下跌，AC连续3日下跌减仓10%；AO连续5日上行，AC连续3日上行加仓10%。

5.退出

    存在有效向下碎形，向下碎形被突破，全部卖出。

收益风险

1. t numpy as np
   
2. def initialize(context):
   
3.     g.up_price = {} #向上碎形最高价
   
4.     g.low_price = {} #向下碎形最低价
   
5.     g.up_fractal_exists = {} #判断有效向上碎形
   
6.     g.down_fractal_exists = {} #判断有效向下碎形
   
7.     g.AO_index = {} #存放连续的AO指标数据
   
8.     g.cal_AC_index = {} #计算AC指标中转存储
   
9.     g.AC_index = {} #存放连续的AC指标数据
   
10.     g.amount = {} #满仓仓位
    
11.     g.stock = get_index_stocks('000300.XSHG')
    
12.     g.buy_stock = []
    
13.     set_benchmark('000300.XSHG')
    
14.     g.month = context.current_dt.month
    
15.     run_monthly(select_universe,1,'open')
    
16. 
    
17. #重置全局变量
    
18. def reset_global():
    
19.     g.up_price = {} #向上碎形最高价
    
20.     g.low_price = {} #向下碎形最低价
    
21.     g.up_fractal_exists = {} #判断有效向上碎形
    
22.     g.down_fractal_exists = {} #判断有效向下碎形
    
23.     g.AO_index = {} #存放连续的AO指标数据
    
24.     g.cal_AC_index = {} #计算AC指标中转存储
    
25.     g.AC_index = {} #存放连续的AC指标数据
    
26.     g.amount = {} #满仓仓位
    
27.     g.buy_stock = []
    
28. 
    
29. def initial_stock_global(stock):
    
30.     g.up_price[stock] = 0
    
31.     g.low_price[stock] = 0
    
32.     g.up_fractal_exists[stock] = False
    
33.     g.down_fractal_exists[stock] = False #判断有效向下碎形
    
34.     g.AO_index[stock] = [0] #存放连续的AO指标数据
    
35.     g.cal_AC_index[stock] = [0]  #计算AC指标中转存储
    
36.     g.AC_index[stock] = [0] #存放连续的AC指标数据
    
37.     g.amount[stock] = 0 #满仓仓位
    
38. 
    
39. #轮换选股后清空持仓
    
40. def reset_position(context):
    
41.     for stock in g.buy_stock:
    
42.         order_target(stock,0)
    
43.         log.info("sell %s for reset position"%stock)
    
44. #选股
    
45. def select_universe(context):
    
46.     #每三个月操作一次
    
47.     month = context.current_dt.month
    
48.     if month%6 != g.month%6:
    
49.         return
    
50.     #清空全局变量
    
51.     reset_position(context)
    
52.     reset_global()
    
53.     hist = history(30,'1d','close',g.stock,df = False)
    
54.     for stock in g.stock:
    
55.         if is_sleeping_alligator(stock,hist,20):
    
56.             g.buy_stock.append(stock)
    
57.             #初始化该股票全局变量
    
58.             initial_stock_global(stock)
    
59.     print g.buy_stock
    
60.     return None
    
61. 
    
62. #睡着的鳄鱼
    
63. def is_sleeping_alligator(stock,hist,nday):
    
64.     for i in range(nday):
    
65.         if is_struggle(stock,hist,i) == False:
    
66.             return False
    
67.     return True
    
68. 
    
69. #均线纠缠，BRG三线非常接近
    
70. def is_struggle(stock,hist,delta):
    
71.     blue_line = hist[stock][-21-delta:-8-delta].mean()
    
72.     red_line = hist[stock][-13-delta:-5-delta].mean()
    
73.     green_line = hist[stock][-8-delta:-3-delta].mean()
    
74.     if abs(blue_line/red_line-1)<0.02 and abs(red_line/green_line-1)<0.02:
    
75.         return True
    
76.     else:
    
77.         return False
    
78. 
    
79. #判断 向上 或 向下 碎形
    
80. def is_fractal(stock,direction):
    
81.     hist = history(5,'1d',direction,[stock],df = False)
    
82.     if direction == 'high'\
    
83.     and hist[stock][2] > hist[stock][0]\
    
84.     and hist[stock][2] > hist[stock][1]\
    
85.     and hist[stock][2] > hist[stock][3]\
    
86.     and hist[stock][2] > hist[stock][4]:
    
87.         g.up_price[stock] = hist[stock][2]
    
88.         return True
    
89.     elif direction == 'low'\
    
90.     and hist[stock][2] < hist[stock][0]\
    
91.     and hist[stock][2] < hist[stock][1]\
    
92.     and hist[stock][2] < hist[stock][3]\
    
93.     and hist[stock][2] < hist[stock][4]:
    
94.         g.low_price[stock] = hist[stock][2]
    
95.         return True
    
96.     return False
    
97. 
    
98. #通过比较碎形与红线位置，判断碎形是否有效
    
99. def is_effective_fractal(stock, direction):
    
100.     if is_fractal(stock,direction):
     
101.         hist = history(13,'1d','close',[stock],df = False)
     
102.         red_line = hist[stock][:-5].mean()
     
103.         close_price = hist[stock][-1]
     
104.         if direction == 'high':
     
105.             if close_price > red_line:
     
106.                 g.up_fractal_exists[stock] = True
     
107.             else:
     
108.                 g.up_fractal_exists[stock] = False
     
109.         elif direction == 'low':
     
110.             if close_price < red_line:
     
111.                 g.down_fractal_exists[stock] = True
     
112.             else:
     
113.                 g.down_fractal_exists[stock] = False
     
114. 
     
115. #N日内最高价格的N日线
     
116. def nday_high_point(stock,n):
     
117.     hist = history(2*n,'1d','high',[stock],df = False)[stock]
     
118.     high_point = []
     
119.     for i in range(n):
     
120.         high_point.append(max(hist[-5-i:-1-i]))
     
121.     return np.array(high_point).mean()
     
122. 
     
123. #N日内最低价格的N日线
     
124. def nday_low_point(stock,n):
     
125.     hist = history(2*n,'1d','low',[stock],df = False)[stock]
     
126.     low_point = []
     
127.     for i in range(n):
     
128.         low_point.append(max(hist[-5-i:-1-i]))
     
129.     return np.array(low_point).mean()
     
130. 
     
131. #AO=5日内（最高-最低）/2的5日移动平均-34日内（最高-最低）/2的34日移动平均
     
132. def AO_index(stock):
     
133.     g.AO_index[stock].append(nday_high_point(stock,5)/2 + nday_low_point(stock,5)/2\
     
134.                       - nday_high_point(stock,34)/2 - nday_low_point(stock,34)/2)
     
135.     return None
     
136. 
     
137. #AO-AO的5日平均值的5日平均
     
138. def AC_index(stock):
     
139.     AO_index(stock)
     
140.     if len(g.AO_index[stock]) >= 5:
     
141.         g.cal_AC_index[stock].append(g.AO_index[stock][-1] - np.array(g.AO_index[stock][-5:]).mean())
     
142.         if len(g.cal_AC_index[stock]) >=5:
     
143.             g.AC_index[stock].append(np.array(g.cal_AC_index[stock][-5:]).mean())
     
144. 
     
145. #判断序列n日上行
     
146. def is_up_going(alist,n):
     
147.     if len(alist) < n:
     
148.         return False
     
149.     for i in range(n-1):
     
150.         if alist[-(1+i)] <= alist[-(2+i)]:
     
151.             return False
     
152.     return True
     
153. 
     
154. #判断序列n日下行
     
155. def is_down_going(alist,n):
     
156.     if len(alist) < n:
     
157.         return False
     
158.     for i in range(n-1):
     
159.         if alist[-(1+i)] >= alist[-(2+i)]:
     
160.             return False
     
161.     return True
     
162. 
     
163. #碎形被突破
     
164. def active_fractal(stock,direction):
     
165.     close_price = history(1,'1d','close',[stock],df=False)[stock][0]
     
166.     if direction == 'up' and close_price > g.up_price[stock]:
     
167.         return True
     
168.     elif direction == 'down' and close_price < g.low_price[stock]:
     
169.         return True
     
170.     return False
     
171. 
     
172. #进场，初始仓位
     
173. def set_initial_position(stock,context):
     
174.     close_price = history(1,'1d','close',[stock],df=False)[stock][0]
     
175.     g.amount[stock] = context.portfolio.cash/close_price/len(g.buy_stock)*3
     
176.     order(stock, g.amount[stock])
     
177.     log.info("buying %s 股数为 %s"%(stock,g.amount[stock]))
     
178.     g.down_fractal_exists[stock] = False
     
179. 
     
180. #卖出
     
181. def sell_all_stock(stock,context):
     
182.     order_target(stock,0)
     
183.     log.info("selling %s"%stock)
     
184.     g.up_fractal_exists[stock] = False
     
185. 
     
186. #加仓
     
187. def adjust_position(stock,context,position):
     
188.     order(stock,g.amount[stock]*position)
     
189.     log.info("adjust position buying %s 股数为 %s"%(stock,g.amount[stock]*position))
     
190. 
     
191. # 计算股票前n日收益率
     
192. def security_return(days,security_code):
     
193.     hist1 = attribute_history(security_code, days + 1, '1d', 'close',df=False)
     
194.     security_returns = (hist1['close'][-1]-hist1['close'][0])/hist1['close'][0]
     
195.     return security_returns
     
196. 
     
197. # 止损，根据前n日收益率
     
198. def conduct_nday_stoploss(context,security_code,days,bench):
     
199.     if  security_return(days,security_code)<= bench:
     
200.         for stock in g.buy_stock:
     
201.             order_target_value(stock,0)
     
202.             log.info("Sell %s for stoploss" %stock)
     
203.         return True
     
204.     else:
     
205.         return False
     
206. 
     
207. # 计算股票累计收益率（从建仓至今）
     
208. def security_accumulate_return(context,data,stock):
     
209.     current_price = data[stock].price
     
210.     cost = context.portfolio.positions[stock].avg_cost
     
211.     if cost != 0:
     
212.         return (current_price-cost)/cost
     
213.     else:
     
214.         return None
     
215. 
     
216. # 个股止损，根据累计收益
     
217. def conduct_accumulate_stoploss(context,data,stock,bench):
     
218.     if security_accumulate_return(context,data,stock) != None\
     
219.     and security_accumulate_return(context,data,stock) < bench:
     
220.         order_target_value(stock,0)
     
221.         log.info("Sell %s for stoploss" %stock)
     
222.         return True
     
223.     else:
     
224.         return False
     
225. 
     
226. # 个股止盈，根据累计收益
     
227. def conduct_accumulate_stopwin(context,data,stock,bench):
     
228.     if security_accumulate_return(context,data,stock) != None\
     
229.     and security_accumulate_return(context,data,stock) > bench:
     
230.         order_target_value(stock,0)
     
231.         log.info("Sell %s for stopwin" %stock)
     
232.         return True
     
233.     else:
     
234.         return False
     
235. 
     
236. def handle_data(context,data):
     
237.     #大盘止损
     
238.     if conduct_nday_stoploss(context,'000300.XSHG',3,-0.03):
     
239.         return
     
240.     for stock in g.buy_stock:
     
241.         #个股止损
     
242.         if conduct_accumulate_stopwin(context,data,stock,0.3)\
     
243.         or conduct_accumulate_stoploss(context,data,stock,-0.1):
     
244.             return
     
245.         #计算AO，AC指标
     
246.         AC_index(stock)
     
247.         #空仓时，寻找机会入场
     
248.         if context.portfolio.positions[stock].amount == 0:
     
249.             #计算向上碎形
     
250.             is_effective_fractal(stock,'high')
     
251.             #有效向上碎形存在，并被突破，买入
     
252.             if g.up_fractal_exists and active_fractal(stock,'up'):
     
253.                 close_price = history(5, '1d', 'close', [stock],df = False)
     
254.                 if is_up_going(g.AO_index[stock],5)\
     
255.                 and is_up_going(g.AC_index[stock],3)\
     
256.                 and is_up_going(close_price[stock],2):
     
257.                     set_initial_position(stock,context)
     
258.         #有持仓时，加仓或离场
     
259.         else:
     
260.             #计算向下碎形
     
261.             is_effective_fractal(stock,'low')
     
262.             #出场条件1：有效向下碎形存在，并被突破，卖出
     
263.             if g.down_fractal_exists and active_fractal(stock,'down'):
     
264.                 sell_all_stock(stock,context)
     
265.                 return
     
266.             #出场条件2：
     
267.             #加仓10%：AO，AC同时5日上行，且收盘价走高
     
268.             # if is_up_going(g.AO_index[stock],5)\
     
269.             # and is_up_going(g.AC_index[stock],3)\
     
270.             # and is_up_going(close_price[stock],2):
     
271.             #     adjust_position(stock,context,0.1)
     
272.             # #减仓10%：AO，AC同时3日下行，且收盘价走低
     
273.             # if is_down_going(g.AO_index[stock],5)\
     
274.             # and is_down_going(g.AC_index[stock],3)\
     
275.             # and is_down_going(close_price[stock],2):
     
276.             #     adjust_position(stock,context,-0.1)

复制代码

学习了