python数据分析及可视化（十七）聚宽（双均线分析、因子选股策略、多因子选股策略、均值回归理论、布林带策略、PEG策略、权重收益策略）

聚宽

聚宽是一个做金融量化的网站，https://www.joinquant.com，登录注册，如果你写的文章、策略被别人采纳，增加积分，积分用于免费的回测时长。在我的策略，进入策略列表，里面有做好的策略模板可以进行参考和学习，也可以新建策略，选择股票策略，可以更改文件的名称。左边是代码区域，可以点击函数库查看聚宽平台的函数库进行了解和学习，克隆为把打开的代码克隆一份在新的网页打开使用，2to3是将python2的代码转化为python3，API为常见的API开发文档，在聚宽平台上写策略的话需要用的方法，都可以在开发文档中找到相应的说明，如参数、返回值等等；右上方是进行回测的参数设置，如起止日期，投入金额，进行操作的频率；右下方是操作的日志信息和输出的效果。

默认聚宽的代码运行

新建股票策略，默认生成一个代码的框架，包含导入函数库，初始化函数，开盘前、开盘时、收盘后运行的函数，执行相应的操作。

# 导入函数库
from jqdata import *

# 初始化函数，设定基准信息等等，如购买哪支股票
def initialize(context):
    # 设定沪深300作为基准，是股票池，具有代表性的300支股票，可以发生变化，从里面挑选股票进行购买
    set_benchmark('000300.XSHG')
    # 开启动态复权模式(以真实的价格模拟策略的交易)
    set_option('use_real_price', True)
    # 输出内容到日志 log.info()
    log.info('初始函数开始运行且全局只运行一次')
    # 过滤掉order系列API产生的比error级别低的log
    # log.set_level('order', 'error')

    ### 股票相关设定 ###
    # 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税（必须要有的）, 每笔交易佣金最低扣5块钱
    set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')

    ## 运行函数（reference_security为运行时间的参考标的；传入的标的只做种类区分，因此传入'000300.XSHG'或'510300.XSHG'是一样的）
      # 开盘前运行
    run_daily(before_market_open, time='before_open', reference_security='000300.XSHG')
      # 开盘时运行
    run_daily(market_open, time='open', reference_security='000300.XSHG')
      # 收盘后运行
    run_daily(after_market_close, time='after_close', reference_security='000300.XSHG')

## 开盘前运行函数
def before_market_open(context):
    # 输出运行时间
    log.info('函数运行时间(before_market_open)：'+str(context.current_dt.time()))

    # 给微信发送消息（添加模拟交易，并绑定微信生效）
    # send_message('美好的一天~')

    # 要操作的股票：平安银行（g.为全局变量）
    g.security = '000001.XSHE'

## 开盘时运行函数
def market_open(context):
    log.info('函数运行时间(market_open):'+str(context.current_dt.time()))
    security = g.security
    # 获取股票的收盘价
    close_data = get_bars(security, count=5, unit='1d', fields=['close'])
    # 取得过去五天的平均价格
    MA5 = close_data['close'].mean()
    # 取得上一时间点价格
    current_price = close_data['close'][-1]
    # 取得当前的现金
    cash = context.portfolio.available_cash

    # 如果上一时间点价格高出五天平均价1%, 则全仓买入
    if (current_price > 1.01*MA5) and (cash > 0):
        # 记录这次买入
        log.info("价格高于均价 1%%, 买入 %s" % (security))
        # 用所有 cash 买入股票
        order_value(security, cash)
    # 如果上一时间点价格低于五天平均价, 则空仓卖出
    elif current_price < MA5 and context.portfolio.positions[security].closeable_amount > 0:
        # 记录这次卖出
        log.info("价格低于均价, 卖出 %s" % (security))
        # 卖出所有股票,使这只股票的最终持有量为0
        order_target(security, 0)

## 收盘后运行函数
def after_market_close(context):
    log.info(str('函数运行时间(after_market_close):'+str(context.current_dt.time())))
    #得到当天所有成交记录
    trades = get_trades()
    for _trade in trades.values():
        log.info('成交记录：'+str(_trade))
    log.info('一天结束')
    log.info('##############################################################')

点击编译运行，会得到回测结果。基准收益是指对股票投资按照时间预计能得到的收益，正常买了之后不涉及任何的操作，所得到的收益，策略收益是指投入资金后，对价值的估值，按照策略大致得到的收益。从下图可以看出，模拟的策略低于基准收益。

聚宽基础使用

可以在API里进行函数、方法的查询，在页面上方的数据字典里可以查看给定的数据内容。
get_index_stocks (index_symbol, date=None)，获取指数成份股
获取一个指数给定日期在平台可交易的成分股列表。参数：index_symbol: 指数代码；date: 查询日期, 一个字符串(格式类似’2015-10-15’)或者datetime.date/datetime.datetime对象, 可以是None, 使用默认日期. 这个默认日期在回测和研究模块上有点差别:
回测模块: 默认值会随着回测日期变化而变化, 等于context.current_dt
研究模块: 默认是今天
返回：返回股票代码的list。如’000300.XSHG’，指的是选择日期当天的沪深300指的300支股票的列表，是最有代表性的300支股票，并不是固定的，股票随时会变。好比全年级前300名，这300名并不是一成不变的，会随时发生变化。
get_current_data() 获取当前时间数据，获取当前单位时间（当天/当前分钟）的涨跌停价, 是否停牌，当天的开盘价等。不需要传入参数, 即使传入了, 返回的 dict 也是空的, dict 的 value 会按需获取，其中 key 是股票代码, value 是拥有如下属性的对象。
last_price : 最新价
high_limit: 涨停价
low_limit: 跌停价
paused: 是否停止或者暂停了交易, 当停牌、未上市或者退市后返回 True
is_st: 是否是 ST(包括ST, *ST)，是则返回 True，否则返回 False
day_open: 当天开盘价
name: 股票现在的名称, 可以用这个来判断股票当天是否是 ST, *ST, 是否快要退市
industry_code: 股票现在所属行业代码,

# 导入函数库
import jqdata

# 初始化函数，设定基准等等，点击编译运行，函数不用调用会自动运行
def initialize(context):  # context类似 类里的self
    # 定义一个全局变量 保存要操作的股票，可以是列表，存放多支股票
    # g.security = '000001.XSHE'  # 平安银行
    # 获取以往的历史数据，选取沪深300股票
    g.security = get_index_stocks('000300.XSHG')
    # print(g.security) # 输出 2019-1-1的代表300支股票
    # 开启动态复权模式，以真实的价格进行模拟交易
    set_option( 'use_real_price',True)
     # 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣5块钱，如买入的时候手续费为0，open_tax=0
    set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')

def handle_data(context,data):  # 每一天的操作，每天都要显示的内容
    # print('hello')  # 每天都打印 'hello'
    # 获取当前时间数据
    # print(get_current_data())  # 输出的是个空字典
    # print(get_current_data()['601318.XSHG'].day_open)  # 每一天的开盘价格，用Key，value的形式获取数据
    # 获取以往的历史数据
    # print(attribute_history('601318.XSHG',5)) # 相当于MA5.历史5天的数据
    # 买入多少股，必须是100的倍数
    order('601318.XSHG',100)
    # 买入多少钱的
    order_value('601318.XSHG',10000)
    
    # 从股票池里获取股票
    for stock in g.security :
        # 获取当前股票的开盘价格
        p = get_current_data()[stock].day_open
        # 获取当前股票持有股数
        amount = context.portfolio.positions[stock].total_amount
    

运行回测的结果

双均线分析

对于每一个交易日，都可以计算出前N天的移动平均值，然后把这些移动平均值连起来，成为一条线，就叫做N日移动平均线。移动平均线常用：5天,10天,30天,60天，120天和240天的指标
● 5天和10天的是短线操作的参照指标，称做日均线指标;
● 30天和60天的是中期均线指标，称做季均线指标;
● 120天和240天的是长期均线指标，称做年均线指标。
黄金交叉
短期均线上穿长期均线，买入信号

死亡交叉
短期均线下穿长期均线，卖出信号
两个交叉点是交替出现的。
position 持仓标的信息；order 按照股票数下单，要保证有足够的剩余资金进行下单购买；order_value 按照价值下单，参数value= 最新价 * 手数 * 保证金率（股票为1） * 乘数（股票为100），知道当前用户手中的可用资金来判断购买多少股。
2016-1-1到201-6-1的时间内，购买的是100的整数倍，策略收益高于基准收益。

# 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
    # 设定沪深300作为基准
    set_benchmark('000300.XSHG')
    # 开启动态复权模式(真实价格)
    set_option('use_real_price', True)
    # 输出内容到日志 log.info()
    log.info('初始函数开始运行且全局只运行一次')
    
    g.security = ['601318.XSHG'] # 假设只有一种股票
    g.d5 = 5
    g.d60 = 60
# 在指定日期的工作日内，都会运行一次
def handle_data(context,data):  # context 上下文数据（必须得有，相当于类里的self），data可以省略
    # print(110) # 每一个交易日都会执行的操作
    # 循环遍历股票
    for stock in g.security:
        # print(stock)
        # 金叉：如果5日均线大于60日均线，且不持仓，进行买入
        # 死叉：如果5日均线小于60日均线，且持仓，进行卖出
        
        # 方法一：
        # df = attribute_history(stock,g.d5) # 获取5天的历史数据
        # # print(df) # 打印每个交易日的前5天的数据
        # ma5 = df['close'].mean() # ma5的值是收盘价格的平均值
        # 方法二：
        df = attribute_history(stock,g.d60)
        ma5 = df['close'][-5:].mean()
        ma60 = df['close'].mean()
        # 进行金叉和死叉的判断
        
        # 如果60日均线大于5日均线，且持仓即当前股票在投资组合信息汇总中
        if ma60 > ma5 and stock in context.portfolio.positions:
            # 进行卖出
            order_target(stock,0) # 全仓卖出
        if ma60 < ma5 and stock not in context.portfolio.positions:
            # 进行买入，按金额买入，可用资金
            order_value(stock,context.portfolio.available_cash * 0.8)
		# 看一下均线的交叉，找出并分析黄金和死亡交叉点
        # 显示线形图
        record(ma5=ma5,ma60=ma60)  # 自定义参数名称

运行回测的结果，上面的图是策略收益线和基准收益线，执行的策略收益大于基准收益，下面的线为ma5和ma60的线，可以找到交叉的点（交叉的日期）.

因子选股策略

● 因子：选择股票的某种标准，选择股票的策略；双均线分析是选择买入股票的时机，择时的股票策略。购买股票不光是买入的时机要好，买入的股票表现也要好，股票挑选的不好，不管怎么使用策略，股票本身上涨空间有限。
选择股票的标准：增长率、市值、市盈率、ROE(净资产收益率)，公司的财报数据中一般都会包含这些内容。市值一般是估算，并不是说公司市值多少，价值就是多少，一般公司的资产要比市值要低，比如上市公司市值多少亿，其实公司的资金并没有那么多。
● 选股策略：根据选择股票的标准来选择股票，如相亲的标准
1.对于某个因子，选取表现最好(因子最大或最小)的N支股票持仓，因子最大或者最小，市盈率越高越好，增长率越大越好，亏损率越小越好。
2.每隔一段时间调仓一次，买了不建议一直放在手里，根据股票的走势适时调整选择的股票。
3.选股策略一般都是长期的投资，因为不是一天交易一次，而是几个月交易一次
● 小市值策略：市值为因子选股的因子选取股票池中市值最小的N只股票持仓，比如古代富人家对进京赶考秀才的资助，可以资助多个秀才，增加自己投资的几率，远比直接攀大官要现实的多。

聚宽平台上默认的小市值策略

'''
筛选出市值介于20-30亿的股票，选取其中市值最小的三只股票，
每天开盘买入，持有五个交易日，然后调仓。
'''

## 初始化函数，设定要操作的股票、基准等等
def initialize(context):
    # 设定沪深300作为基准
    set_benchmark('000300.XSHG')
    # True为开启动态复权模式，使用真实价格交易
    set_option('use_real_price', True) 
    # 设定成交量比例
    set_option('order_volume_ratio', 1)
    # 股票类交易手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣5块钱
    set_order_cost(OrderCost(open_tax=0, close_tax=0.001, \
                             open_commission=0.0003, close_commission=0.0003,\
                             close_today_commission=0, min_commission=5), type='stock')
    # 持仓数量
    g.stocknum = 3 
    # 交易日计时器
    g.days = 0 
    # 调仓频率
    g.refresh_rate = 5
    # 运行函数
    run_daily(trade, 'every_bar')

## 选出小市值股票
def check_stocks(context):
    # 设定查询条件
    q = query(
            valuation.code,
            valuation.market_cap
        ).filter(
            valuation.market_cap.between(20,30)
        ).order_by(
            valuation.market_cap.asc()
        )

    # 选出低市值的股票，构成buylist
    df = get_fundamentals(q)
    buylist =list(df['code'])

    # 过滤停牌股票
    buylist = filter_paused_stock(buylist)

    return buylist[:g.stocknum]
  
## 交易函数
def trade(context):
    if g.days%g.refresh_rate == 0:

        ## 获取持仓列表
        sell_list = list(context.portfolio.positions.keys())
        # 如果有持仓，则卖出
        if len(sell_list) > 0 :
            for stock in sell_list:
                order_target_value(stock, 0)

        ## 分配资金
        if len(context.portfolio.positions) < g.stocknum :
            Num = g.stocknum - len(context.portfolio.positions)
            Cash = context.portfolio.cash/Num
        else: 
            Cash = 0

        ## 选股
        stock_list = check_stocks(context)

        ## 买入股票
        for stock in stock_list:
            if len(context.portfolio.positions.keys()) < g.stocknum:
                order_value(stock, Cash)

        # 天计数加一
        g.days = 1
    else:
        g.days += 1

# 过滤停牌股票
def filter_paused_stock(stock_list):
    current_data = get_current_data()
    return [stock for stock in stock_list if not current_data[stock].paused]

对比代码进行仿写
新建策略–股票策略，同一个策略在不同时期的收益是不一样的
选择沪深300中市值最小的前20支股票，在每个月的第一个交易日进行股票的筛选进行交易

# 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
    # 设定沪深300作为基准
    set_benchmark('000300.XSHG')
    # 开启动态复权模式(真实价格)
    set_option('use_real_price', True)
    ### 股票相关设定 ###
    # 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣5块钱
    set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')
    
    # 定义全局变量
    g.security = get_index_stocks('000300.XSHG') # 从沪深300里面去选择
    # 查询市值比较小的股票
    g.q = query(valuation).filter(valuation.code.in_(g.security))
    # 选择其中的20支股票
    g.N = 20
    # 每月执行一次，1为第一个交易日
    run_monthly(handle,1)
    
# 定义函数，每个月第一个交易日调用一次，并不是hand_data函数    
def handle(context):
    # 1.获取市值最小的20支股票，
    # 获取对应股票的交易代码和总市值market_cap
    df = get_fundamentals(g.q)[['code','market_cap']]
    # 对20支股票进行排序操作,[:g.N,:]从小到大排列取前20，取所有的列
    df = df.sort_values('market_cap').iloc[:g.N,:]
    print(df)  # 每次取出的前20支股票不一定都一样
    
    # 2.调仓，持有的股票中有前20，就保留，没有持有就买入
    # 取出股票代码，看一下当前有无持有这20支股票
    # 需要持有的股票代码
    to_hold = df['code'].values
    # 循环现在所持有的股票，当前投资信息里所持有的股票
    for stock in context.portfolio.positions:
        # 如果持有股票没有在to_hold列表里，就卖出去
        if stock not in to_hold:
            order_target(stock,0)  # 卖出后，持有为0
    # 需要买入的股票列表
    # 遍历持有列表里的股票 如果没有在持有股票里，就买入
    tobuy = [stock for stock in to_hold if stock not in context.portfolio.positions]
    
    # 计算每支股票可以使用的钱是多少，比如账户里有十万，买9支股票，可以买多少
    # 判断，当前是否有需要买入的股票
    if len(tobuy) > 0:
        # 上下文投资组合信息汇总中可用资金除以当前有多少支股票，十万除以几支股票
        # 每支股票花的钱
        cash_per_stock = context.portfolio.available_cash // len(tobuy)
        for stock in tobuy:
            # 每支股票买入的钱
            order_value(stock,cash_per_stock)

应用策略得到的结果

多因子选股策略

单因子是只考虑一个因子的情况，只考虑一个标准。多因子选股可以综合多个因子：市值，市盈率，ROE(净资产收益率)等等，进行策略分析的时候选择两个以上的因子。

评分模型：
● 每个股票针对每个因子进行评分，将评分相加，获取每支股票在不同标准下的评分，进行相加，选出评分最高的进行股票进行持仓。
● 选出总评分最大的N只股票持仓。考察学生的学习成绩，单因子的话只考虑一门课的成绩，多因子要考虑多门学科的综合成绩
● 如何计算股票在某个因子下的评分：归一化(标准化)，不同的数据指标标准不一样，比如语文成绩的80分跟理科综合的80分评分标准是不一样的， 归一化操作是为了减轻差异化数据带来的影响。

标准化(归一化：数据预处理)

机器学习用到的数据预处理的特征工程，创建模型要考虑到数据差异化的影响。

min-max标准化：x* = (x-min)/(max-min)

没有新数据加入，这种方法相对比较简单。
● 将原始数据转化为一个0到1的数，映射到0-1的范围内，比如70,80，90，映射后为0.7,0.8,0.9
● 缺点：如果有新数据加入，可能导致min和max的变化，从而求得的映射值也会发生变化。比如之前的值是0-100，突然加入了1000，整个数据的映射值也会发生变化

我的策略–进入策略列表–新建策略–股票策略

# 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
    # 初始化股票池
    g.security = get_index_stocks('000300.XSHG')
    # 得到数据查询对象，查询公司的财务指标，如市值、净资产的盈利率、增长率等
    g.q = query(valuation,indicator).filter(valuation.code.in_(g.security))
    
    # 每个月运行一次，第1个工作日
    run_monthly(handle_month,1)
# 定义每个月运行一次的函数
def handle_month(context):
    # 得到表对象，获取代码，市值，净资产
    df = get_fundamentals(g.q)[['code','market_cap','roe']]
    print(df)

正常情况下的市值、净资产值为：

对市值和净资产进行归一化操作

# 导入函数库

# 定义每个月运行一次的函数
def handle_month(context):
    # 得到表对象，获取代码，市值，净资产
    df = get_fundamentals(g.q)[['code','market_cap','roe']]
    # print(df)
    
    # 归一化处理 映射的值 (x-min)/(max-min)
    # 市值归一化
    df['market_cap'] = (df['market_cap']-df['market_cap'].min())/(df['market_cap'].max()-df['market_cap'].min())
    # 净资产归一化
    df['roe'] = (df['roe']-df['roe'].min())/(df['roe'].max()-df['roe'].min())
    print(df)

进行归一化处理后，再进行买入卖出的操作

# 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
    # 初始化股票池
    g.security = get_index_stocks('000300.XSHG')
    # 得到数据查询对象，查询公司的财务指标，如市值、净资产的盈利率、增长率等
    g.q = query(valuation,indicator).filter(valuation.code.in_(g.security))
    
    # 每个月运行一次，第1个工作日
    run_monthly(handle_month,1)
# 定义每个月运行一次的函数
def handle_month(context):
    # 得到表对象，获取代码，市值，净资产的收益率
    df = get_fundamentals(g.q)[['code','market_cap','roe']]
    # print(df)
    
    # 归一化处理 映射的值 (x-min)/(max-min)
    # 市值归一化
    df['market_cap'] = (df['market_cap']-df['market_cap'].min())/(df['market_cap'].max()-df['market_cap'].min())
    # 净资产归一化
    df['roe'] = (df['roe']-df['roe'].min())/(df['roe'].max()-df['roe'].min())
    # print(df)
    # 选出评分最大的股票，选择前20支股票的全部列
    df['score'] = df['roe'] - df['market_cap']
    df = df.sort_values('score',ascending=False).iloc[:20,:] 
    # print(df)  # 从大到小排列
    
    # 获取需要持有的股票代码
    # 需要买入的股票代码
    to_hold = df['code'].values
    # 循环现在持有的股票，当前投资信息里所持有的股
    for stock in context.portfolio.positions:
        # 如果持有股票没有在to_hold列表里，就卖出去
        if stock not in to_hold:
            order_target(stock,0)  # 卖出后，持有为0
    # 需要买入的股票列表
    # 遍历持有列表里的股票 如果没有在持有股票里，就买入
    tobuy = [stock for stock in to_hold if stock not in context.portfolio.positions]
    
    # 计算每支股票可以使用的钱是多少，比如账户里有十万，买9支股票，可以买多少
    # 判断，当前是否有需要买入的股票
    if len(tobuy) > 0:
        # 上下文投资组合信息汇总中可用资金除以当前有多少支股票，十万除以几支股票
        # 每支股票花的钱
        cash_per_stock = context.portfolio.available_cash // len(tobuy)
        for stock in tobuy:
            # 每支股票买入的钱
            order_value(stock,cash_per_stock)

归一化处理后得到的收益如下图所以，在不同的时期，同一个策略考虑因子的多少也会影响收益的效果。如果建立比较适宜的模型，考虑多因子的策略应该高于单子策略的收益。

建立模型的时候，比较重要的因子（如市值）设置的评分比重应该高一点，roe的比重低一点。好比评分的第一标准，第二标准等，多因子策略（多条标准）要考虑首要条件，比如有钱可以占100分，但是只占0.8的比例，算是主要的因素，但不是完全所有的因素，还要考虑其他的因素（性格占0.2的比例）。要看策略的完善情况，有些比较好的策略能应对绝大多数股市变化的情况，但也不可能考虑股市各种各样的情况，看的是整体策略的收益情况。

Z-score标准化：x* = (x-μ)/σ

如果需要增加新数据，此种方法更适合。
● μ一组数的平均值 σ为标准差
● 将原始数据转化为均值为0，标准差为1的正态分布的随机变量

均值回归理论

均值回归：核心内容就是 “跌下去的迟早要涨上来”

均值回归的理论基于以下观测
价格的波动一般会以它的均线为中心。也就是说，当标的价格由于波动而偏离移动均线时，它将调整并重归于均线。涨到最高点势必会下降，降到最低点就会再上升，具体是下跌到什么程度才会买入，就要引入定义偏离程度。

定义偏离程度：(MA-P)/MA，MA为移动平均线，如MA5,MA30等等，P为收盘时候的价格，价格的波动超出平均线的范围，结果为正数即是向上偏移，为负数是向下偏移。

均值回归策略执行
● 计算股票池中所有股票的N日均线，可以是5日、30日等等
● 计算股票池中所有股票与均线的偏离度，价格与平均线偏离的程度
● 选取偏离度最高（价格波动比较大）的M支股票并调仓(调大或者调小，判断是否风险最大)
主页–进入策略列表–新建策略–股票策略，进行均值回归策略的实现。设定沪深300为基准，开启动态复权模式以及手续费的设置，先建立一个Series对象，索引是沪深300的股票代码，遍历这300支股票求出每支股票ma30和p的数据，然后求出偏离程度，取出偏离程度最大（比正常的价格要低）的10支股票进行调仓，然后看一下目前账户里持有的股票，有不在这10支股票里的就卖掉，创建买入的列表，只要有需要买入的股票，就看一下当期资金的剩余情况除以需要买入股票的数量得到 每支股票要买多少钱的，进行买入的操作。

# 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
    # 设定沪深300作为基准
    set_benchmark('000300.XSHG')
    # 开启动态复权模式(真实价格)
    set_option('use_real_price', True)

    ### 股票相关设定 ###
    # 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣5块钱
    set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')

    # 设置全局变量，股票池
    g.security = get_index_stocks('000300.XSHG')
    # MA30，30天一交易，5天的话时间间隔短，交易太频繁
    g.ma_days = 30
    # 选择10支股票
    g.stock_num = 10
    #每个月执行一次，第一个交易日执行操作
    run_monthly(handle,1)

def handle(context):
    # 把选择的沪深300的股票作为索引对象
    sr = pd.Series(index=g.security)
    for stock in sr.index:
        #获取每支股票的前30天的历史数据，收盘价格的平均值
        ma = attribute_history(stock,g.ma_days)['close'].mean()
        #获取当前股票的开盘价格
        p = get_current_data()[stock].day_open
        # 计算偏离程度
        ratio = (ma - p)/ ma
        # 把偏离程度赋值给Series对象，创建的时候只有索引，没有对应的内容
        
        sr[stock] = ratio
    # print(sr)
    # 选择偏离程度最高（value值最大）的10支股票 
    to_hold = sr.nlargest(g.stock_num).index.values
    # print(to_hold)  # 每个月建议持有的10支股票
    
    # 查看目前账户里持有的股票
    for stock in context.portfolio.positions:
        # 如果不在to_hold列表里，就卖出
        if stock not in to_hold:
            order_target(stock,0) # 卖出，持有为0
    
    # 买入股票，在to_hold列表，不在我持有的股票列表里
    to_buy = [stock for stock in to_hold if stock not in context.portfolio.positions]
    # 如果当前列表不为空，就应该有买入的操作
    if len(to_buy) > 0:
        # 每支股票买入的金额 当前账户的可用资金除以买入股票的数量，每支股票买入多少钱的
        cash_per_stock = context.portfolio.available_cash / len(to_buy)
        # 每支股票买入这么多金额的数量
        for stock in to_buy:
            order_value(stock,cash_per_stock)

运行回测的结果，策略收益比基准收益要高点，应用策略的时候最好时间长一点。

布林带策略

布林带策略定义

布林是个人名，布林带/布林线/保利加(Bollinger Band)通道策略：由三条轨道线组成，其中上下两条线分别可以看成是价格的压力线和支撑线，在两条线之间是一条价格平均线。当价格突破压力线的时候，意味着价格肯定会下降，当价格跌破了支撑线就会上涨。压力线和支撑线好比路两边的马路牙子，撞到了就要返回。

正常情况下，支撑线到均线的距离比压力线到均线的距离要短一些，越靠近均线，交易次数会越频繁
计算公式
● 压力线 = M日均线 + NSTD
● 支撑线 = M日均线 - NSTD
○ STD为标准差
○ N为参数，意味着布林带宽度
新建策略–股票策略

# 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
    # 设定沪深300作为基准
    set_benchmark('000300.XSHG')
    # 开启动态复权模式(真实价格)
    set_option('use_real_price', True)

    ### 股票相关设定 ###
    # 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣5块钱
    set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')

    g.security = '600036.XSHG'
    g.M = 20
    g.k = 2
    
def handle_data(context,data):
    sr = attribute_history(g.security,g.M)['close']
    ma = sr.mean()
    # 压力线
    up = ma + g.k*sr.std()
    # 支撑线
    down = ma - g.k*sr.std()
    # 选择对应股票的数据
    p = get_current_data()[g.security].day_open
    # 每一天花多少钱买股票，看一下账户里的可用资金
    cash = context.portfolio.available_cash
    # 当前的开盘价格小于支撑线，并且这支股票并没有在我当前的账户信息里，就可以进行买入
    if p < down and g.security not in context.portfolio.positions:
        # 买入
        order_value(g.security,cash)
    elif p > up and g.security in context.portfolio.positions:
        # 卖出
        order_target(g.security,0)

PEG策略

彼得林奇：任何一家公司股票如果定价合理的话，市盈率就会与收益增长率相等。这就是PEG估值法。

市盈率

市盈率是当前股价§相对每股收益(EPS)的比值
$PE=\frac{P}{EPS}$
● 市盈率(PE) = 股价§ / 每股收益 (EPS)
○ 股价*股数 ≈ 市值，并不是完全相等
○ 每股收益*股数 ≈ 净收益
● 市盈率 ≈ 市值 / 净收益
比如一家店市值30万，每年会有10万的盈利，PE=30万/10万 =3，在不考虑其他因素的情况下，3年就能回本。
收益增长率
$G=\frac{EPSthisyear-EPSlastyear}{EPSlastyear}$
第一年盈利10万，第二年盈利12万，G = （12-10）/10，即为20%

PEG策略

PEG策略重要条件为：市盈率会与收益增长率相等。也就是PE = G，则得出公式：
$PEG=\frac{PE}{G\ast 100}$
PEG = 3/(0.2*100) = 0.15
由此可以得出结论：
● PEG越低，代表股价被低估的可能性越大，股价会涨的可能性越大。小于1就是被低估了，大于1就是被高估了
● PEG是一个综合指标，既考察价值，又兼顾成长性。PEG估值法适合应用于成长型的公司，财务比较稳定的公司，周期类、项目性的公司就不适合，剔除掉增长超过50的股票，大多数的股票不可能持续的高增长，有些A股公司常年会有补贴，卖股权等收入来源，这类公司在计算的时候PE和G是有出入的

PEG策略执行思路

PEG策略(选股)：
● 计算股票池中所有股票的PEG指标
● 选择PEG最小的N只股票调仓(小的买入，大的卖出)
注意：过滤掉市盈率或收益增长率为负的数据。

"""
PEG策略
"""
# 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
    # 设定沪深300作为基准
    set_benchmark('000300.XSHG')
    # 开启动态复权模式(真实价格)
    set_option('use_real_price', True)

    ### 股票相关设定 ###
    # 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣5块钱
    set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')
    # 设定沪深300作为基准
    g.security = get_index_stocks("000300.XSHG")
    
    # 市盈率 净利润同比增长率 财务数据 query对象
    # pe_ratio  所属表：valuation
    # inc_net_profit_year_on_year 所属表：indicator
    # 获取相应的数据
    g.q = query(valuation.code,valuation.pe_ratio,indicator.inc_net_profit_year_on_year).filter(valuation.code.in_(g.security))
    
    run_monthly(handle_month,1)
    

def handle_month(context):
    # 获取财务数据
    df = get_fundamentals(g.q)
    # print(df)
    
    # 选出 PE 并且 G 都大于 0 的数据
    df = df[(df["pe_ratio"]>0) & (df["inc_net_profit_year_on_year"]>0)]
    
    # 计算PEG 
    df["peg"] = df["pe_ratio"]/df["inc_net_profit_year_on_year"]*100
    
    # 排序 选出最小的
    df = df.sort_values("peg")
    
    # 取前20支股票的code 放到 tohold 中
    to_hold = df["code"][:20].values
    # print(to_hold)
    
    # 目前账户所持有的股票
    for stock in context.portfolio.positions:
        # 不再to_hold 股票 给 卖掉
        if stock not in to_hold:
            order_target(stock,0)
    
    # 买入 在to_hold里面 但是不在我持有的股票列表里面
    tobuy = [stock for stock in to_hold if stock not in context.portfolio.positions]

    if len(tobuy) > 0:
        cash_per_stock = context.portfolio.available_cash/len(tobuy)
        for stock in tobuy:
            order_value(stock,cash_per_stock)

运行回测的结果

权重收益策略

权重，即为占比，比如公司有50位股东，并不是所有人发表的意见或权利是等效的，持股多的人说话的分类要高于其他人。

"""
每月第一个交易日，筛选出沪深300指数前10的权重股票代码
每个交易日，对持有但不在前10的股票代码进行卖出
再将可用资金，买入前10的股票
"""

import numpy as np
import pandas as pd
from jqdata import *

# 1.初始化函数
def initialize(context):
    # 初始化系统
    # 1.1 过滤掉order系列API产生的比error级别低的log
    log.set_level('order', 'error')
    # 1.2 设置动态复权(真实价格)模式
    set_option('use_real_price', True)
    # 1.3 设置是否开启避免未来数据模式(当天的收盘价)
    set_option('avoid_future_data', True)

# 2.模拟盘在每天的交易时间结束后会休眠，第二天开盘时会恢复，
# 如果在恢复时发现代码已经发生了修改，则会在恢复时执行这个函数。
def after_code_changed(context):
    # 2.1 初始化
    g.index = '000300.XSHG' # 投资指数
    g.stocks = [] # 投资组合
    # 2.2 设置定时器
    # 2.2.1 清除所有定时任务，添加新的
    unschedule_all() # 重置，方便代码升级
    # 2.2.2 每月第一个(1)交易日，在开盘之前执行handle_prepare
    run_monthly(handle_prepare, 1, 'before_open')
    # 2.2.3 每天开盘时运行handle_trader
    run_daily(handle_trader, 'open')
    # 2.2.4 每月最后一个(-1)交易日，在收盘之后执行report_portoflio
    # run_monthly(report_portoflio, -1, 'after_close')
    
# 3. 每月第一个(1)交易日，在开盘之前执行
def handle_prepare(context):
    # 3.1 获取指数成分股的权重
    weight = get_index_weights(g.index) # 提取指数权重
    # print(weight)
    # 3.2 给权重进行降序排序，并取出前10支
    weight = weight.sort_values(by='weight', ascending=False).head(10)
    # print(weight)
    # 3.3 获取股票代码列表
    g.stocks = weight.index.tolist() 

# 4. 每天开盘时运行
def handle_trader(context):
    # 4.1 获取当前时间数据
    cur_data = get_current_data()
    
    # 4.2 遍历当前账户持仓股票
    # 多头卖出
    for s in context.portfolio.positions:
        # 4.3 如果 当前持仓 不在 大盘权重前10列表中
        if s not in g.stocks:
            log.info('sell', s, cur_data[s].name)
            # 4.4 清仓
            order_target(s, 0)
    
    # 4.3 遍历大盘权重前10列表中股票
    # 多头买进
    for s in g.stocks:
        # 0.095 * 总的权益
        position = 0.095 * context.portfolio.total_value
        # 如果没有持仓 并且 可使用的资金 大于 总权益时
        if s not in context.portfolio.positions and\
            context.portfolio.available_cash > position:
            # 买入
            order_value(s, position)

# 5. 每月最后一个(-1)交易日，在收盘之后执行
def report_portoflio(context):
    # 报告账户
    log.info('total returns', 100*context.portfolio.returns)
    log.info('available cash', context.portfolio.available_cash)
    log.info('total value', context.subportfolios[0].total_value)
    # 分列持仓
    cur_data = get_current_data()
    for s in context.portfolio.positions:
        ps = context.portfolio.positions[s]
        log.info('long', s, cur_data[s].name, ps.total_amount, int(ps.value))
# end

运行回测的结果是