量化交易策略之均线策略

quant001

收益风险











源码：

1. #股票池需要如下：
   
2. #沪深300池，
   
3. #当前不停牌的股票池，
   
4. #有历史数据的股票池,
   
5. #两者的交集得到可用股票池
   
6. #持仓股票池
   
7. #可用股票池中剔除持仓股票得到的股票池（可以进行买入操作的股票池）
   
8. #将要买入的股票池：即上述股票池中发出买入信号得到的股票池
   
9. #将要卖出的股票池：持仓股票池中，没有停牌的，发出卖出信号的股票池
   
10. 
    
11. import random
    
12. import numpy as np
    
13. import pandas as pd
    
14. from pandas import Series,DataFrame
    
15. import scipy.stats as stats
    
16. import math
    
17. def initialize(context):
    
18.     #初始化沪深300
    
19.     g.stocks_ttl = get_index_stocks('000300.XSHE')
    
20.     set_universe(g.stocks_ttl)
    
21.     set_commission(PerTrade(buy_cost=0.0005, sell_cost=0.0013, min_cost=5))
    
22.     #初始化可用股票池(不停牌的股票池)
    
23.     g.stocks_trading=[]
    
24.     #初始化有历史数据的股票池
    
25.     g.stocks_hist=[]
    
26.     #初始化持仓股票池
    
27.     g.stocks_hold=[]
    
28.     #初始化备选股票池
    
29.     g.stocks_toChoose=[]
    
30.     #将要买入的股票池
    
31.     g.stocks_toBuy=[]
    
32.     #将要卖出的股票池
    
33.     g.stocks_toSell=[]
    
34.     #长短均线的间隔
    
35.     g.shortMA=1
    
36.     g.longMA=60
    
37.     #持仓持有股票数量的最大上限
    
38.     g.numHoldmax=100
    
39.     # 坑满时每次调仓量
    
40.     g.num_of_change=4
    
41.     #设置计算几日收益率
    
42.     g.period=10
    
43. 
    
44. def before_trading_start(context):
    
45.     #得到当前的可用的股票池
    
46.     g.stocks_ttl = get_index_stocks('000300.XSHE')
    
47.     set_universe(g.stocks_ttl)
    
48.     current_data = get_current_data(g.stocks_ttl)
    
49.     g.stocks_trading=[]
    
50.     length=len(current_data)
    
51.     #得到有历史数据的股票池，并且得到有历史数据
    
52.     operate_buy={}
    
53.     g.stocks_hist=[]
    
54.     for i in range(0,length):
    
55.         #得到当前的不停牌股票
    
56.         if not current_data[g.stocks_ttl[i]].paused:
    
57.             #取出有历史数据的股票，如果历史数据能够支撑运算，顺便也把买入的信号一做
    
58.             temp_hist= attribute_history(g.stocks_ttl[i],g.longMA+1, '1d', ('close'),skip_paused=True)
    
59.             temp_hist=temp_hist.dropna()
    
60.             if len(temp_hist['close'])>=g.longMA:
    
61.                 g.stocks_hist.append(g.stocks_ttl[i])
    
62.                 signal=cal_signal(temp_hist)
    
63.                 operate_buy.update({g.stocks_ttl[i]:signal})
    
64. 
    
65.     #得到最后的备选池
    
66.     g.stocks_toChoose=list(set(g.stocks_hist).difference(set(g.stocks_hold)))
    
67.    
    
68.     #得到最终的可执行池：即发出信号的买入池
    
69.     g.stocks_toBuy=[]
    
70.     length=len(g.stocks_toChoose)
    
71.     for i in range(0,length):
    
72.         if operate_buy[g.stocks_toChoose[i]]==1:
    
73.             g.stocks_toBuy.append(g.stocks_toChoose[i])
    
74. 
    
75.     #得到发出信号的卖出池
    
76.     g.stocks_toSell=[]
    
77.     length=len(g.stocks_hold)
    
78.     if length>0:
    
79.         current_hold=get_current_data(g.stocks_hold)
    
80.         for i in range(0,length):
    
81.             #如果当天股票不停牌，则进行下一步计算
    
82.             if not current_hold[g.stocks_hold[i]].paused:
    
83.                 temp_hist= attribute_history(g.stocks_hold[i],g.longMA+1, '1d', ('close'),skip_paused=True)
    
84.                 signal=cal_signal(temp_hist)
    
85.                 if signal==-1:
    
86.                     g.stocks_toSell.append(g.stocks_hold[i])
    
87.                
    
88.    
    
89. #输入某只股票的hist数据，然后判断是否发出买入卖出信号，输入为dataframe，输出为
    
90. #数字1:买入，-1卖出，0表示不变
    
91. def cal_signal(data_withHist):
    
92.     length=len(data_withHist.iloc[:,0])
    
93.     MA_shortYesterday=calMA(data_withHist,g.shortMA)
    
94.     MA_shortBeforeYesterday=calMA(data_withHist.head(length-1),g.shortMA)
    
95.     MA_longYesterday=calMA(data_withHist,g.longMA)
    
96.     MA_longBeforeYesterday=calMA(data_withHist.head(length-1),g.longMA)
    
97.     signal=0
    
98.     if MA_shortBeforeYesterdayMA_longYesterday:
    
99.         signal=1
    
100.     elif MA_shortYesterday
     
101.         signal=-1
     
102.     return signal
     
103.    
     
104. #输入某只股票的hist数据,计算MA，返回一个数
     
105. def calMA(data_withHist,num):
     
106.     ma=data_withHist.tail(num).mean()
     
107.     ma=ma.values[0]
     
108.     return ma
     
109. 
     
110. #构成一个列索引为股票名，收益率一行的索引为
     
111. #'return'的dataframe，并返回这个dataframe
     
112. def calreturn(stocklist):
     
113.     #取出每只股票period天的收盘价格
     
114.     stocks_info=history(g.period,'1d','close',security_list=stocklist)
     
115.     #去除信息不全的数据
     
116.     stocks_info.dropna(axis=0,how='any',thresh=None)
     
117.     #取出昨天和period天之前的收盘价，计算收益率
     
118.     a1=list(stocks_info.iloc[0])
     
119.     a2=list(stocks_info.iloc[g.period-1])
     
120.     a1=np.array(a1)
     
121.     a2=np.array(a2)
     
122.     #用一个dataframe来保存所有股票的收益率信息
     
123.     stocks_return=DataFrame(a2/a1,columns=['return'],index=stocks_info.columns)
     
124.     stocks_info=stocks_info.T
     
125.     #把收益率的数据加到相应的列
     
126.     stocks_info=pd.concat([stocks_info,stocks_return],axis=1)
     
127.     #将股票信息按照收益率从小到大来存储
     
128.     stocks_info=stocks_info.sort(columns=['return'],ascending=[True])
     
129.     #返回处理好的dataframe
     
130.     return stocks_info   
     
131. 
     
132. def handle_data(context,data):
     
133.     #首先卖出持仓中该卖出的股票
     
134.     for i in range(0,len(g.stocks_toSell)):
     
135.         order_target(g.stocks_toSell[i],0, LimitOrderStyle(0.01))
     
136.     g.stocks_hold=list(set(g.stocks_hold).difference(set(g.stocks_toSell)))
     
137.     # 计算还剩下的坑位
     
138.     num_canBuy=g.numHoldmax-len(g.stocks_hold)
     
139.    
     
140.     # 如果坑满了，剔除坑中持有的一部分收益不好的股票，买入备选池中收益率较好的股票
     
141.     if num_canBuy == 0 and len(g.stocks_toBuy)>0:
     
142.         stocks_holdreturnup=calreturn(g.stocks_hold)
     
143.         stocks_tobuyreturnup=calreturn(g.stocks_toBuy)
     
144.         for i in range(0,min(len(g.stocks_toBuy),g.num_of_change)):
     
145.             order_target(stocks_holdreturnup.index[i],0, LimitOrderStyle(0.01))
     
146.             g.stocks_hold.remove(stocks_holdreturnup.index[i])
     
147.         num_canBuy=g.numHoldmax-len(g.stocks_hold)
     
148.         cash_ttl=context.portfolio.cash
     
149.         cash_perShare=cash_ttl/num_canBuy
     
150.         for i in range(0,num_canBuy):
     
151.             order_target_value(stocks_tobuyreturnup.index[len(stocks_tobuyreturnup)-i-1],cash_perShare,LimitOrderStyle(9999))
     
152.    
     
153.     # 如果坑没满
     
154.     elif num_canBuy>0:
     
155.         cash_ttl=context.portfolio.cash
     
156.         cash_perShare=cash_ttl/num_canBuy
     
157.         #如果备选股票池中的股票数量小于可买的股票，则全部买入
     
158.         if len(g.stocks_toBuy)<=num_canBuy:
     
159.             for i in range(0,len(g.stocks_toBuy)):
     
160.                 order_target_value(g.stocks_toBuy[i],cash_perShare,LimitOrderStyle(9999))
     
161.    
     
162.         #如果备选池的股票大于可买数量，则按照收益率买入
     
163.         elif len(g.stocks_toBuy)>num_canBuy:
     
164.             stocks_tobuyreturnup=calreturn(g.stocks_toBuy)
     
165.             for i in range (0,num_canBuy):
     
166.                  order_target_value(stocks_tobuyreturnup.index[len(stocks_tobuyreturnup)-i-1],cash_perShare,LimitOrderStyle(9999))
     
167.                 #成功下单完了以后更新g.stocks_hold
     
168.    
     
169.     #记录一下实际持仓：
     
170. def after_trading_end(context):
     
171.     g.stocks_hold=context.portfolio.positions.keys()
     
172.     #log.info("一天结束后的持仓")
     
173.     #log.info(g.stocks_hold)
     
174.    

复制代码