量化量化交易入门系列2经典的量化交易策略上

来源： 恒生LIGHT云社区

量化投资策略

量化投资策略 是基于大数据基础上，利用统计学、数学、信息技术、人工智能等方法取代人工作出决策，通过模型完成股票交易来构建投资组合。

相对于人为主观投资，量化投资策略的最大特点是其具有一套 基于数据的完整交易规则 。

在投资决策的所有环节，根据设定好的客观量化标准，严格贯彻执行，比如，根据自己已经持有的A股票，等到A股票的横指标达到多少的阈值时，才可以开仓，以及每次开仓要买卖多少手等交易规则。

双均线策略

均线 最早由美国投资专家Joseph E.Granville(格兰威尔)于20世纪中期提出，现在仍然广泛为人们使用，成为判断买卖信号的一大重要指标。从统计角度来说，均线就是历史价格的平均值，可以代表过去N日股价的平均走势。

1962年7月，Joseph E.Granville在他的书中提出了著名的Granville八大买卖法则。

只利用股价和均线即可进行择时，这个方法简单好用，沿用至今，现在进行股票买卖的时候，大家一般也会根据均线去进行一些操作，比如5日均线、10日均线、20日均线、30均线、60日均线、年均线等。

Granville 八大法则其中有四条是用于判断买进时机，另外四条是用于判断卖出时机。买进和卖出法则一个一个地对应，分布在高点的左右两侧（除买4和卖4以外）。法则内容如下所示：

买1：均线整体上行，股价由下至上上穿均线，此为黄金交叉，形成第一个买点。 买2：股价出现下跌迹象，但尚未跌破均线，此时均线变成支撑线，形成第二个买点。 买3：股价仍处于均线上方，但呈现急剧下跌趋势。当跌破均线时，出现第三个买点。 买4：（右侧）股价和均线都处于下降通道，且股价处于均线下方，严重远离均线，出现第四个买点。

卖1：均线由上升状态变为缓慢下降的状态，股价也开始下降。当股价跌破均线时，此为死亡交叉，形成第一个卖点。 卖2：股价仍处于均线之下，但股价开始呈现上涨趋势，当股价无限接近均线但尚未突破时，此时均线变成阻力线，形成第二个卖点。 卖3：股价终于突破均线，处于均线上方。但持续时间不长，股价开始下跌，直至再一次跌破均线，此为第三个卖点。 卖4：（左侧）股价和均线都在上涨，股价上涨的速度远快于均线上涨的速度。当股价严重偏离均线时，出现第四个卖点。

双均线策略，通过建立m天移动平均线，n天移动平均线，则两条均线必有交点。若m>n，n天平均线“上穿越”m天均线则为买入点，反之为卖出点。

该策略基于不同天数均线的交叉点，抓住股票的强势和弱势时刻，进行交易。

对于双均线策略，其实比较容易理解，从长期来看，资产的价格总会回归到均值附近。

缺陷

双均线策略有效的前提，需要股票价格在周期性震荡，并且震荡周期合适。

（1）单边行情失效。如果是单边行情，比如单边上涨或者下跌，这时候均线缠绕，会不停产生买卖点，就产生了大量的无效交易，交易费用会很高，那么效果会很差。

（2）震荡周期过短效果也不行，因为本身存在一定滞后性，如果周期过段。等上涨信号传到的时候刚好进入下跌周期，或者下跌信号传到的时候进入上涨周期，这样会导致做出严重失误的决策，不但不赚钱，可能会亏损严重。

（3）均线周期差距很大，那么周期交易就很长，趋势性很不明显，趋势转变可能很长时间出现买卖点，也无法收到较好的效果。

改进策略

针对均线的缺点，市场上提出了各种各样的改进办法。

1.对均线的计算方法进行改正。

加权移动平均线是在移动平均线的基础上按照时间进行加权。越靠近当前日期的价格对未来价格的影响越大，赋予更大的权重；越远离当前日期价格，赋予越小的权重。

2.调整均线周期

利用不同周期均线得到的结果也不同。许多有经验的投资者发现，在不同的市场中，有些均线的效果显著优于其他周期均线。有些长线投资者还会将股价替换成短周期均线进行趋势判断。

策略逻辑

第一步：获取数据，计算长短期均线 第二步：设置交易信号

当短期均线由上向下穿越长期均线时做空 当短期均线由下向上穿越长期均线时做多

策略参考代码

1.  
   # 导入函数库
2.  
   from jqdata import *
3.  
    
4.  
   # 初始化函数，设定基准等等
5.  
   def initialize(context):
6.  
   # 设定沪深300作为基准
7.  
   set_benchmark('000300.XSHG')
8.  
   # 开启动态复权模式(真实价格)
9.  
   set_option('use_real_price', True)
10.  
    # 输出内容到日志 log.info()
11.  
    log.info('初始函数开始运行且全局只运行一次')
12.  
    # 过滤掉order系列API产生的比error级别低的log
13.  
    # log.set_level('order', 'error')
14.  
     
15.  
    ### 股票相关设定 ###
16.  
    # 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣5块钱
17.  
    set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')
18.  
     
19.  
    ## 运行函数（reference_security为运行时间的参考标的；传入的标的只做种类区分，因此传入'000300.XSHG'或'510300.XSHG'是一样的）
20.  
    # 开盘前运行
21.  
    run_daily(before_market_open, time='before_open', reference_security='000300.XSHG')
22.  
    # 开盘时运行
23.  
    run_daily(market_open, time='open', reference_security='000300.XSHG')
24.  
    # 收盘后运行
25.  
    run_daily(after_market_close, time='after_close', reference_security='000300.XSHG')
26.  
     
27.  
    ## 开盘前运行函数
28.  
    def before_market_open(context):
29.  
    # 输出运行时间
30.  
    log.info('函数运行时间(before_market_open)：' str(context.current_dt.time()))
31.  
     
32.  
    # 给微信发送消息（添加模拟交易，并绑定微信生效）
33.  
    # send_message('美好的一天~')
34.  
     
35.  
    # 要操作的股票：宏达股份（g.为全局变量）
36.  
    g.security = '600331.XSHG'
37.  
     
38.  
    ## 开盘时运行函数
39.  
    def market_open(context):
40.  
    log.info('函数运行时间(market_open):' str(context.current_dt.time()))
41.  
    security = g.security
42.  
    # 获取股票的收盘价
43.  
    close_data = get_bars(security, count=5, unit='1d', fields=['close'])
44.  
    # 取得过去五天的平均价格
45.  
    MA5 = close_data['close'].mean()
46.  
    # 取得上一时间点价格
47.  
    current_price = close_data['close'][-1]
48.  
    # 取得当前的现金
49.  
    cash = context.portfolio.available_cash
50.  
     
51.  
    # 如果上一时间点价格高出五天平均价1%, 则全仓买入
52.  
    if (current_price > 1.01*MA5) and (cash > 0):
53.  
    # 记录这次买入
54.  
    log.info("价格高于均价 1%%, 买入 %s" % (security))
55.  
    print("当前可用资金为{0}, position_value为{0}".format(cash, context.portfolio.positions_value))
56.  
    # 用所有 cash 买入股票
57.  
    order_value(security, cash)
58.  
    # 如果上一时间点价格低于五天平均价, 则空仓卖出
59.  
    elif current_price < MA5 and context.portfolio.positions[security].closeable_amount > 0:
60.  
    # 记录这次卖出
61.  
    log.info("价格低于均价, 卖出 %s" % (security))
62.  
    # 卖出所有股票,使这只股票的最终持有量为0
63.  
    order_target(security, 0)
64.  
     
65.  
    ## 收盘后运行函数
66.  
    def after_market_close(context):
67.  
    log.info(str('函数运行时间(after_market_close):' str(context.current_dt.time())))
68.  
    #得到当天所有成交记录
69.  
    trades = get_trades()
70.  
    for _trade in trades.values():
71.  
    log.info('成交记录：' str(_trade))
72.  
    log.info('一天结束')
73.  
    log.info('##############################################################')

策略效果

以沪深300为标的，对宏达股份进行策略交易。从2021年6月1日到2021年11月15日数据模拟：

海龟交易策略

著名的商品投机家理查德.丹尼斯相信，伟大的交易员是后天培养的，他可以教会人们成为伟大的交易员。

1983年，他挑选了13个人，对他们进行培训，并为他们提供真实的账户进行交易，希望证明自己的论断。他教给这13个学员一套完整的交易系统，由于学员们被称为“海龟”，后来人们就把这套系统称为海龟交易系统。

原版的海龟交易系统包括市场（买什么），头寸规模（买卖多少），入市（何时买入），止损（何时退出亏损的头寸），离市（何时退出赢利的头寸），策略（下限价指令还是市价指令），是一个趋势交易策略，最显著的特点是捕捉中长期趋势，力求在短期获得最大的利益。

建仓

首先介绍几个参数：

ATR： Average true range ,是指日内指数的最大波动的平均振幅，由当日最高、最低价和上一交易日的收盘价决定，是TR在N天内的均值。

PDC：前个交易日的收盘价。

H：当日最高价

L：当日最低价

TR计算公式：

利用N值来体现价值波动量DV： DV = N * 合约每点价值

每点价值量 是指一手合约的价格每变动一个最小单位，整个合约变动的价格。在中国股市中，股票价格变动的最小价格一般是0.01元，一手股票是100股，因此每点价值量就是0.01*100=1。

每一次开仓交易合约数unit的确定是将总资产的1%除以DV得到。

入市

海龟交易法使用的是以一个理查德唐奇安的通道突破系统为基础的入市系统。唐奇安通道分为系统一和系统二，对应短期突破和中长期突破。

其中，短期突破系统是以20日（最高价或最低价）突破为基础，当价格突破20日价格即为入市信号；中长期系统是当盘中价格突破过去55日价格为入市信号。

即：价格形成突破，即当前股票价格>day_in天中股票的最高价格，买入股票。

加仓

海龟交易法的加仓规则是当捕捉到入市信号后建立第一个交易单位的头寸，市价继续向盈利方向突破0.5N时加仓。

止损

如果股票价格相对于上次买入的价格下降了2N，则把持有的头寸清仓。每加仓一次，止损位就提高0.5N。

离市

如果股票价格小于day_out天来得最低价，则清空持有的头寸。

短期：多头头寸在突破过去10日最低价处止盈离市，空头头寸在突破过去10日最高价处止盈离市。 中长期：多头头寸在突破过去20日最低价处止盈离市，空头头寸在突破过去20日最高价处止盈离市。

策略思路

第一步：获取历史数据，计算N和ATR 第二步：当突破唐奇安通道时，开仓。 第三步：进行系统一/系统二，计算加仓和止损信号。

策略源码参考

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

策略效果

以宏达股份为例，选取2021年6月1日到2021年11月15日的数据，进行模拟。

最后

虽然我选取了同一支股票，用不同的策略回测，数据差异比较大，双均线收益率远高于海龟策略，并不是说双均线策略好于海龟策略，针对不同的市场行情以及股票当前的位置，选择合适的量化策略才是正道。

当然，策略是基于大数据基础上的模拟，不一定保证百分百收益，也不要过于依赖。

还是那句话： 入市有风险，投资需谨慎！