聚宽 (JoinQuant) API 文档

API文档

感谢您使用JoinQuant（聚宽）量化平台，以下内容主要介绍聚宽量化平台的API使用方法，目录中带有"♠" 标识的API是 "回测环境/模拟"的专用API，不支持在投资研究模块中调用。

内容较多，可使用Ctrl+F进行搜索。

如果以下内容仍没有解决您的问题，请您查看常见问题、常见Bug或者警告解决方法或者通过社区提问的方式告诉我们。此外您也可以通过在线客服免费咨询

开始写策略

简单但是完整的策略

先来看一个简单但是完整的策略:

def initialize(context):
    # 定义一个全局变量, 保存要操作的股票
    g.security = '000001.XSHE'
    # 运行函数
    run_daily(market_open, time='every_bar')

def market_open(context):
    if g.security not in context.portfolio.positions:
        order(g.security, 1000)
    else:
        order(g.security, -800)

一个完整策略只需要两步:

• 设置初始化函数: initialize,上面的例子中, 只操作一支股票: '000001.XSHE', 平安银行
• 实现一个函数, 来根据历史数据调整仓位.

这个策略里, 每当我们没有股票时就买入1000股, 每当我们有股票时又卖出800股, 具体的下单API请看order函数.

这个策略里, 我们有了交易, 但是只是无意义的交易, 没有依据当前的数据做出合理的分析

下面我们来看一个真正实用的策略

实用的策略

在这个策略里, 我们会根据历史价格做出判断:

• 如果上一时间点价格高出五天平均价1%, 则全仓买入
• 如果上一时间点价格低于五天平均价, 则空仓卖出

# 导入聚宽函数库
import jqdata

# 初始化函数，设定要操作的股票、基准等等
def initialize(context):
    # 定义一个全局变量, 保存要操作的股票
    # 000001(股票:平安银行)
    g.security = '000001.XSHE'
    # 设定沪深300作为基准
    set_benchmark('000300.XSHG')
    # 开启动态复权模式(真实价格)
    set_option('use_real_price', True)
    # 运行函数
    run_daily(market_open, time='every_bar')

# 每个单位时间(如果按天回测,则每天调用一次,如果按分钟,则每分钟调用一次)调用一次
def market_open(context):
    security = g.security
    # 获取股票的收盘价
    close_data = attribute_history(security, 5, '1d', ['close'])
    # 取得过去五天的平均价格
    MA5 = close_data['close'].mean()
    # 取得上一时间点价格
    current_price = close_data['close'][-1]
    # 取得当前的现金
    cash = context.portfolio.available_cash

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

策略引擎介绍

安全

1. 保证您的策略安全是我们的第一要务
2. 在您使用我们网站的过程中, 我们全程使用https传输
3. 策略会加密存储在数据库
4. 请不要在其他非聚宽平台登录聚宽账号。
5. 回测时您的策略会在一个安全的进程中执行, 我们使用了进程隔离的方案来确保系统不会被任何用户的代码攻击, 每个用户的代码都运行在一个有很强限制的进程中:

• 只能读指定的一些python库文件

• 不能写和执行任何文件, 如果您需要保存和读取私有文件, 请看write_file/read_file

• 限制了cpu和内存, 堆栈的使用，当使用多核时，回测耗时按CPU占用耗时计算

• 可以访问网络, 但是对带宽做了限制, 下载最大带宽为500Kbps, 上传带宽为10Kbps

• 有严格的超时机制, 如果handle_data超过30分钟则立即停止运行 对于读取回测所需要的数据, 和输出回测结果, 我们使用一个辅助进程来帮它完成, 两者之间通过管道连接.

  我们使用了linux内核级别的apparmer技术来实现这一点. 有了这些限制我们确保了任何用户不能侵入我们的系统, 更别提盗取他人的策略了.

数据

1. 股票数据：我们拥有所有A股上市公司2005年以来的股票行情数据、财务数据、上市公司基本信息、融资融券信息等。为了避免幸存者偏差，我们包括了已经退市的股票数据。其中volume（成交量）字段单位是股。
2. 基金数据：我们目前提供了600多种在交易所上市的基金的行情、净值等数据，包含ETF、LOF、分级A/B基金以及货币基金的完整的行情、净值数据等，请点击基金数据查看。
3. 金融期货数据：我们提供中金所推出的所有金融期货产品的行情数据，并包含历史产品的数据。
4. 股票指数：我们支持近600种指数数据，包括指数的行情数据以及成分股数据。为了避免未来函数，我们支持获取历史任意时刻的指数成分股信息，具体见get_index_stocks。
5. 行业板块：我们支持按行业、按板块选股，具体见get_industry_stocks
6. 概念板块：我们支持按概念板块选股，具体见get_concept_stocks
7. 所有的行情数据我们均已处理好前复权信息。
8. 我们当日的回测数据会在收盘后通过多数据源进行校验，并在T+1（第二天）的00:01更新。
9. 我们提供的所有行情K线数据为后对齐，标识K线的时间为数据的结束时间。在一分钟K线上，没有09:30，从09:31开始，有15:00的K线，共计240根。表示时间为09:31的一分钟K线，其数据时间为09:25:00~09:30:59，这一分钟的开盘价是09:25的集合竞价的价格。
10. 期货K线的划分方式：将标的当天的开盘时间到收盘时间的日历时间按照划分单位划分区间，然后将同一个区间的分钟bar合并。例如，某个标的的开盘时间为09:30,收盘时间为15:00，然后划分单位为5m，划分bar的逻辑如下：将09:30-15:00按照5m划分区间，然后将这个标当天行情在同一个区间的分钟bar合并。

运行频率

聚宽支持天、分钟及tick频率，其他频率您可以在此基础上自己根据时间判断，有关运行频率解析及隔固定时间运行方法请点击查看，下面是运行频率的详细说明。

1. Bar 的概念

在一定时间段内的时间序列就构成了一根 K 线（日本蜡烛图），单根 K 线被称为 Bar。

如果是一分钟内的 Tick 序列，即构成一根分钟 K 线，又称分钟 Bar;
如果是一天内的分钟序列，即构成一根日线 K 线，又称日线 Bar;

Bar 的示意图如下所示：

Bar 就是时间维度上，价格在空间维度上变化构成的数据单元。如下图所示，多个数据单元 Bar 构成的一个时间序列。

2. 频率详解

下列图片中齿轮为 handle_data(context, data) 的运行时间，before_trading_start(context) 等其他函数运行时间详见相关API。

频率：天

当选择天频率时， 算法在每根日线 Bar 都会运行一次，即每天运行一次。

在算法中，可以获取任何粒度的数据。

频率：分钟

当选择分钟频率时， 算法在每根分钟 Bar 都会运行一次，即每分钟运行一次。

在算法中，可以获取任何粒度的数据。

频率：Tick

当选择 Tick 频率时，每当新来一个 Tick，算法都会被执行一次。

执行示意图如下图所示：

运行时间

设置您的策略什么时候运行，主要由设置策略频率（天、分钟或者tick）与控制策略运行时间的API共同完成

• 开盘前(9:00)运行:

  • run_monthly/run_weekly/run_daily中指定time='09:00'运行的函数
  • before_trading_start

• 盘中运行:

  • run_monthly/run_weekly/run_daily中在指定交易时间执行的函数, 执行时间为这分钟的第一秒. 例如: run_daily(func, '14:50') 会在每天的14:50:00(精确到秒)执行
  • handle_data
    • 按日回测/模拟, 在9:30:00(精确到秒)运行, data为昨天的天数据
    • 按分钟回测/模拟, 在每分钟的第一秒运行, 每天执行240次, 不包括11:30和15:00这两分钟, data是上一分钟的分钟数据. 例如: 当天第一次执行是在9:30:00, data是昨天14:59至15:00这一分钟的分钟数据, 当天最后一次执行是在14:59:00, data是14:58至14:59:00这一分钟的分钟数据.

• 收盘后(15:00后半小时内)运行:

  • run_monthly/run_weekly/run_daily中指定time='15:30'运行的函数
  • after_trading_end

• 同一个时间点, 总是先运行 run_xxx 指定的函数, 然后是 before_trading_start , handle_data 和 after_trading_end

• 注意:

  • 为了避免您换算错误，建议设置time为具体的时间（例如：time='9:30'）;
  • run_xxx指run_monthly/run_weekly/run_daily中的任意一个
  • run_xxx 指定的函数只能有一个参数 context, data 不再提供, 请使用 history等获取;
  • initialize / before_trading_start / after_trading_end / handle_data 都是可选的, 如果不是必须的, 不要实现这些函数, 一个空函数会降低运行速度;
  • run_xxx和handle_data不要在同一个策略中使用，建议使用run_xxxx;
  • 一个策略中可以写多个run_xxx函数，例如需要每分钟运行和定时运行的话，可以这样设置：

  ## func1, func2, func3都是您自己实现的函数
  # 每分钟运行     
  run_daily(func1, time='every_bar')      
  # 11:00定时运行        
  run_daily(func2, time='11:00')     
  # 14:00定时运行        
  run_daily(func3, time='14:00')  
  # 14:50定时运行        
  run_daily(func2, time='14:50')      
  

订单处理

订单处理总体过程：

• 从委托到成交的流程:
  订单创建->订单检查->报单->确认委托->撮合，在订单检查时未通过则订单取消；
• 回测模式整个过程是同步进行，order_*函数执行成功后会创建一个order对象,市价单的order对象撮合后(交易时间下单立即撮合)会立即获得交易的结果,限价单的order对象每次成交后都会立即更新；
• 目前官网的模拟盘过程同回测；
• 所有未完成订单将在本交易日结束后撤销。

撮合流程

• 在回测和模拟交易中，所有的委托（无论市价单还是限价单）在下单后都将尝试进行撮合，撮合的逻辑根据是否打开盘口撮合进行选择；
• 若委托未能完全成交且为限价单，则挂单，然后根据挂单撮合逻辑进行后续的流程。

下单时的撮合逻辑

未启用盘口撮合时

• 当 “最新价+滑点” 在涨跌停范围内将尝试进行撮合，若满足以下条件则成交，成交价为最新价+滑点：

  • 买入/开多/平空时，委托价 >= 最新价+滑点；
  • 卖出/开空/平多时，委托价 <= 最新价-滑点；

• 若标的“最新价+滑点”不低于涨停或者不高于跌停时：

  • 跌停时市价卖单会被撤销，涨停时市价买单会被撤销；
  • 限价单会挂单等待撮合。

• 交易价格: 最新价 + 滑点，如果在开盘时刻运行， 最新价格为开盘价。 其他情况下， 为上一分钟的最后一个价格或上一个tick的最新价。

• 满足撮合条件时成交量的限制：

  • 回测：不超过当日总成交量 * order_volume_ratio；
  • 模拟交易：全部成交；

• 超出最大成交量的部分：

  • 对于市价单，剩余部分将撤单；
  • 对于限价单，将按委托价挂单，根据策略频率使用不同的后续逻辑。

注意:

• 回测中可通过选项 order_volume_ratio 设置每日最大的成交量, 例如: 0.25 表示下单成交量不会超过本日成交量的 25%；
  • 通过选项 order_volume_ratio 设置每日最大的成交量仅限制了每个订单的成交量, 虽然你可以通过多次下单来超过该限制, 但是为了对你的回测负责请不要这么做；
• context.portfolio 中的持仓价格会使用上一分钟的最后一个价格更新。

启用盘口撮合时

仅在模拟交易中可启用盘口撮合。

• 根据对手盘盘口进行撮合；
• 优先从一档（买一/卖一）开始撮合，根据成交量算出加权均价；
• 盘口撮合不限制成交量；
• 若无盘口数据，使用未启用盘口撮合时的逻辑尝试进行撮合；
• 当盘口无法完全成交时：
  • 对于市价单，剩余部分将全部按最高一档盘口撮合；
  • 对于限价单，将按委托价挂单，根据策略频率使用不同的后续逻辑；
• 对涨跌停情况的处理：
  • 若涨跌停时存在对手盘，则按盘口正常撮合；
  • 若没有对手盘，此时转入未启用盘口时的撮合逻辑：跌停时市价卖单会被撤销，涨停时市价买单会被撤销；限价单会挂单等待撮合。

挂单时的撮合逻辑

针对不同频率（天/分钟，tick）的策略，挂单的限价单将有以下撮合逻辑

按分钟Bar撮合

• 天/分钟频率的策略，挂单的限价单每分钟都将尝试在本分钟Bar结束时按照Bar信息尝试进行撮合，若满足以下条件则成交，成交价为委托价：
  • 买入/开多/平空时，委托价 > Bar的最低价；
  • 卖出/开空/平多时，委托价 < Bar的最高价；
• 成交量限制：
  • 模拟交易中不超过本分钟Bar成交量；
  • 回测中不超过本分钟Bar成交量 * order_volume_ratio；
• 若订单未完全成交，剩余部分将在每个分钟bar结束时继续尝试撮合直到全部成交或收盘；

按tick撮合

• 挂单的限价单每个tick都将尝试在tick结束时按照tick信息尝试进行撮合，若满足以下条件则成交，成交价为委托价：
  • 买入/开多/平空时，若委托价 > tick的最新价，则进行撮合；
  • 卖出/开空/平多时，若委托价 < tick的最新价，则进行撮合；
• 成交量限制：按tick撮合时不检查成交量，当出现满足撮合条件的价格后，剩余部分全部以委托价成交。

非交易时段下单的特别说明

• 如果非交易时间下单且不撮合，不管是市价单还是限价单，都会挂单
• 对于日频级策略，会在开盘时尝试进行撮合；对于分钟或者tick频率的策略，会在下一个分钟bar或者tick完成时尝试撮合
• 市价单挂单后开始交易时会按照下单时的逻辑撮合，限价单按照bar/tick来撮合
• 如果用户在 11:30:01 下单，那么订单挂单，引擎退出；下午开盘前引擎恢复运行时，账户初始化会定位未完成订单的对应频率的数据，如果是tick，可能会影响用户的tick订阅数量

拆分合并与分红

• 传统前复权回测模式：当股票发生拆分，合并或者分红时，股票价格会受到影响，为了保证价格的连续性, 我们使用前复权来处理之前的股票价格，给您的所有股票价格已经是前复权的价格。
• 真实价格（动态复权）回测模式：当股票发生拆分，合并或者分红时，会按照历史情况，对账户进行处理，会在账户账户中增加现金或持股数量发生变化，并会有日志提示。

def initialize(context):
    set_option('use_real_price', True)

股息红利税的计算

真实的税率计算方式如下：

• 分红派息的时候，不扣税；
• 等你卖出该只股票时，会根据你的股票持有时间（自你买进之日，算到你卖出之日的前一天，下同）超过一年的免税。2015年9月之前的政策是，满一年的收5%。现在执行的是,2015年9月份的新优惠政策：满一年的免税；
• 等你卖出股票时，你的持有时间在1个月以内（含1个月）的，补交红利的20%税款，券商会在你卖出股票当日清算时直接扣收；
• 等你卖出股票时，你的持有时间在1个月至1年间（含1年）的，补交红利的10%税款，券商直接扣；
• 分次买入的股票，一律按照“先进先出”原则，对应计算持股时间；
• 当日有买进卖出的（即所谓做盘中T+0），收盘后系统计算你当日净额，净额为买入，则记录为今日新买入。净额为卖出，则按照先进先出原则，算成你卖出了你最早买入的对应数量持股，并考虑是否扣税和税率问题。

在回测及模拟交易中，由于需要在分红当天将扣税后的分红现金发放到账户，因此无法准确计算用户的持仓时间（不知道股票卖出时间），我们的计算方式是，统一按照 20% 的税率计算的。

滑点

在实战交易中，往往最终成交价和预期价格有一定偏差，因此我们加入了滑点模式来帮助您更好地模拟真实市场的表现，可以使用set_slippage设置滑点。

交易税费

交易税费包含券商手续费和印花税。您可以通过set_order_cost来设置具体的交易税费的参数。

券商手续费

中国A股市场目前为双边收费，券商手续费系默认值为万分之三，即0.03%，最少5元。

印花税

印花税对卖方单边征收，对买方不再征收，系统默认为千分之一，即0.1%。

风险指标

风险指标数据有利于您对策略进行一个客观的评价。

注意: 无论是回测还是模拟, 所有风险指标(年化收益/alpha/beta/sharpe/max_drawdown等指标)都只会每天于17:00左右更新一次, 也只根据每天收盘后的收益计算, 并不考虑每天盘中的收益情况. 例外:

• 分钟和TICK模拟盘每分钟会更新策略收益和基准收益
• 按天模拟盘每天开盘后和收盘后会更新策略收益和基准收益
• 基准收益的计算起点取的是回测开始时间前一个交易日的收盘价

那么可能会造成这种现象: 模拟时收益曲线中有回撤, 但是 max_drawdown 可能为0.

回测环境

1. 回测引擎可在Python2.7与Python3.6上运行,默认使用Python3.6。我们将在未来逐步停止对Python2.7引擎的更新，强烈建议您使用Python3.6开发策略。
2. 我们支持所有的Python标准库和部分常用第三方库, 具体请看: 研究和回测（模拟）中都支持哪些第三方Python库. 另外您可以把.py文件放在研究根目录, 回测中可以直接import, 具体请看: 自定义python库
3. 安全是平台的重中之重, 您的策略的运行也会受到一些限制, 具体请看: 安全

回测过程

1. 准备好您的策略, 选择要操作的股票池, 实现handle_data函数
2. 选定一个回测开始和结束日期, 选择初始资金、调仓间隔(每天还是每分钟), 开始回测
3. 引擎根据您选择的股票池和日期, 取得股票数据, 然后每一天或者每一分钟调用一次您的handle_data函数, 同时告诉您现金、持仓情况和股票在上一天或者分钟的数据. 在此函数中, 您还可以调用函数获取任何多天的历史数据, 然后做出调仓决定.
4. 当您下单后, 我们会根据接下来时间的实际交易情况, 处理您的订单. 具体细节参见订单处理
5. 下单后您可以调用get_open_orders取得所有未完成的订单, 调用cancel_order取消订单
6. 您可以在handle_data里面调用record()函数记录某些数据, 我们会以图表的方式显示在回测结果页面
7. 您可以在任何时候调用log.info/debug/warn/error函数来打印一些日志
8. 回测结束后我们会画出您的收益和基准(参见set_benchmark)收益的曲线, 列出每日持仓,每日交易和一系列风险数据。

模拟盘注意事项

• 模拟交易是根据回测的策略创建的，因此需要先回测，再创建模拟交易，如何创建模拟交易？

• 模拟盘有10s系统延迟, 日志中的时间并非实际时间而是逻辑时间(同回测) ,如需获取实际时间请print(datetime.datetime.now())

• 模拟盘进程启动时,可能存在两三分钟内的延迟

• 为了避免以不合理的价格对标的进行下单，模拟盘在下单时会检查开盘（例如股票为9:25）到下单时刻的累积成交量，若为0则会拒绝，提示：WARNING - 该标的截至到目前成交量为0 ，暂时无法成交。

• 模拟盘中因尽量避免在距离开盘时间较早的时间点进行下单, 比如9点以前对股票下单，可能导致当时还没有拿到涨跌停价而产生比较异常的委托甚至委托失败。

• 在日级模拟中使用时，使用handle_data或者run_daily中time='9:30'，策略的实际运行时间是9:27~9:30之间；股指期货在9:27~9:30之间有可能没有产生集合竞价，会出现9:30下单提示该标的截至到目前成交量为0，可以忽略或者在9:31及之后运行；

• 模拟盘在每天运行结束后会保存状态, 结束进程(相当于休眠). 然后在第二天恢复.

• 进程结束时会保存这些状态:

  • 用户账户, 持仓

  • 使用 pickle 保存 g 对象. 注意

    • g 中以 '__' 开头的变量将被忽略, 不会被保存
    • g 中不能序列化的变量不会被保存, 重启后会不存在. 如果你写了如下的代码:

    def initialize(context):
        g.query = query(valuation)
    

    • g 将不能被保存, 因为 query() 返回的对象并不能被持久化. 重启后也不会再执行 initialize, 使用 g.query 将会抛出 AttributeError 异常。正确的做法是, 在 process_initialize 中初始化它, 并且名字以 '__' 开头.

    def process_initialize(context):
        g.__query = query(valuation)
    

    • 注意: 涉及到IO(打开的文件, 网络连接, 数据库连接)的对象是不能被序列化的:
      • query(valuation) : 数据库连接
      • open("some/path") : 打开的文件
      • requests.get('') : 网络连接

  • 使用 pickle保存 context 对象, 处理方式跟 g 一样

  • 为了防止恶意攻击, 序列化之后的状态大小不能超过 30M, 如果超出将在保存状态时运行失败. 当超过 20M 时日志中会有警告提示, 请注意日志.

• 恢复过程是这样的:

  1. 加载策略代码, 因为python是动态语言, 编译即运行, 所以全局的(在函数外写的)代码会被执行一遍.
  2. 使用保存的状态恢复 g, context, 和函数外定义的全局变量.
  3. 如果策略代码和上一次运行时发生了修改，而且代码中定义了 after_code_changed 函数，则会运行 after_code_changed(#after_code_changed) 函数。
  4. 执行 process_initialize, 每次启动时都会执行这个函数.

• 重启后不再执行 initialize 函数, initialize 函数在整个模拟盘的生命周期中只执行一次. 即使是更改回测后, initialize 也不会执行.

• 模拟盘更改回测之后上述的全局变量(包括 g 和 context 中保存的)不会丢失. 新代码中 initialize 不会执行. 如果需要修改原来的值, 可以在 after_code_changed 函数里面修改, 比如, 原来代码是:

  def initialize(context):
      g.stock = '000001.XSHE'
  

  代码改成:

  def initialize(context):
      g.stock = '000002.XSHE'
  

  执行时, g.stock 仍然是 '000001.XSHE', 要修改他们的值, 必须定义 after_code_changed:

  def after_code_changed(context):
      g.stock = '000002.XSHE'
  

• 创建模拟交易时, 如果选择的日期是今天, 则从今天当前时间点开始运行, 应该在当前时间点之前运行的函数不再运行. 比如: 今天10:00创建了按天的模拟交易, 选择日期是今天, 代码中实现了 handle_data 和 after_trading_end, 则 handle_data 今天不运行, 而 after_trading_end 会在 15:30 运行

• 当模拟交易在A时间点失败后, 然后在B时间点"重跑", 那么 A-B 之间的时间点应该运行的函数不再运行

• 因为模拟盘资源有限, 为了防止用户创建之后长期搁置浪费资源, 我们做出如下限制: 如果满足下面条件, 则暂缓运行:

  • 延时模拟盘 , 所有者在最近一个月内没有访问过聚宽网站
  • 实时模拟盘 , 所有者在最近三个月内没有访问过聚宽网站

  当用户重新使用网站后, 第二天会继续运行(会把之前的交易日执行一遍, 并不会跳过日期)

• 由于模拟盘资源有限及防止恶意攻击, 我们设置：（1）模拟交易序列化之后的状态大小不能超过 30M；（2）每个函数运行时间不能超过1800s；（3）进程占用内存不能超过3G。如果日志中出现这样的提示或者模拟交易因此提示而失败的话，请优化策略，具体的参考常见Bug或者警告解决方法。

• 强烈建议模拟盘使用真实价格成交, 即调用 set_option('use_real_price', True). 更多细节

• 模拟交易替换代码参考教程

• 替换代码时，版本模拟交易和回测的版本需要对应，python2(python3)版本的模拟交易不能使用python3(python2)版本的回测替换

模拟交易和回测的差别

比较的前提是策略、起始资金、时间区间及频率等完全一致。模拟交易现在和回测还是有些微小的差别, 具体原因如下:

• 策略运行的环境如果不相同的话，可能导致不同，例如Python2和Python3，聚宽官网和一创聚宽;
• 策略中有随机因素，例如：使用随机数、不稳定的排序、遍历 dict中的元素等；
• 回测的策略使用了未来数据，例如开盘前获取当天的收盘价、财务数据、技术指标等；
• 替换代码：回测不支持替换代码，模拟交易中间替换了代码，回测使用替换后的代码，导致策略不一致；
• 暂停及重启策略：回测中不支持暂停，模拟交易可以暂停策略，暂停期间策略不运行；
• 回测只有一个进程,但模拟盘会在每天结束后关闭,次日再重启,涉及全局变量的持久化保存问题，请规范使用全局变量，具体见策略API介绍-对象-全局变量对象g部分。

期货交割日

期货持仓到交割日，没有手动交割，系统会以当天结算价平仓, 没有手续费, 不会有交易记录.

还券细则

• T+1, 当日融的券当日不能还
• 还券时要扣除利息
• 直接还券时, 可以使用当日买入的券还(不受T+1限制), 且优先使用当日买入的券还

投资组合优化器

投资组合优化是指应用概率论与数理统计、最优化方法以及线性代数等相关数学理论方法，根据既定目标收益和风险容许程度（例如最大化收益，最小化风险，风险平价等），将投资重新组合，分散风险的过程，它体现了投资者的意愿和投资者所受到的约束，即在一定风险水平下收益最大化或一定收益水平下的风险最小化。

投资组合管理者在设定了投资收益预期、风险预算、相关约束和风险模型之后， 依托优化器的快速计算优势，得到资产配置最优化结果。

由于不同的约束条件、目标函数，会形成不同的优化器，优化器的处理结果依赖用户输入的相关信息，因此投资者对收益率的预期和风险模型本身估计的准确性，都会影响最终的分析结果，再考虑到交易成本等各类因素的影响，所以从用户使用上而言， 没有绝对意义上最好的优化器。对于资产组合优化问题， 我们可以通过使用优化器，进行一个较长时间的回测，测试整个投资过程，在所有组合输入一致的情况下通过策略的绩效对比来看哪一个优化器有更好的表现， 或者更符合自己的需求。

组合优化器支持对股票、基金进行投资优化，支持如下优化模型：

• MinVariance - 组合风险最小化（均值-方差优化）
• MaxProfit - 组合收益最大化
• MaxSharpeRatio - 组合夏普比率最大化
• MinTrackingError - 追踪误差最小化
• RiskParity - 风险平价
• MaxScore - 组合标的打分最大化
• MinScore - 组合标的打分最小化
• MaxFactorValue - 因子值最大化
• MinFactorValue - 因子值最小化
• 自定义约束条件的优化模型

对使用优化器的投资组合管理者来说，只需根据收益预期、风险预算，选择恰当的优化模型，并设定相关的约束限制条件。优化器程序可以基于选定的优化模型，输出优化后的投资权重调整建议。我们会对投资组合优化器的进行持续创新与改进。

示例

下面选出上证50成分股的一部分与选定的ETF基金进行组合构成股票池，设定不同的投资组合优化约束条件，并进行回测，测试投资组合优化器对整个投资的影响。

• 模型1：等权重配置

• 模型2：组合风险平价；股票的总权重限制为0到90%，ETF的总权重限制为0到10%；每只标的权重不超过10%

• 模型3：组合风险最小化（最小化组合方差）；组合总权重限制为90%到100%；组合年化收益率目标下限为10%

• 模型4：'人气指标5日均值'最大化；组合年化收益率目标下限为10%；每只标的权重不超过20%

• 模型5：组合夏普比率最大化；每只标的权重不超过10%

回测代码如下, 优化函数API详情见 portfolio_optimizer - 投资组合优化：

# 导入函数库
import pandas as pd
from jqdata import *
from jqfactor import Factor
from jqlib.optimizer import *

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

    # 过滤掉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')

    # 优化器设置
    g.optimizer = 2 #设定使用的优化模型
    optimize_model = {
                        1:"模型1：等权重配置",
                        2:"模型2：组合风险平价；股票的总权重限制为0到90%，ETF的总权重限制为0到10%；每只标的权重不超过10%",
                        3:"模型3：组合风险最小化（最小化组合方差）；组合总权重限制为90%到100%；组合年化收益率目标下限为10%",
                        4:"模型4：'人气指标5日均值'最大化；组合年化收益率目标下限为10%；每只标的权重不超过20%",
                        5:"模型5：组合夏普比率最大化；每只标的权重不超过10%"
                      }
    print("优化%s"%(optimize_model[g.optimizer]))

    ## 运行函数（reference_security为运行时间的参考标的；传入的标的只做种类区分，因此传入'000300.XSHG'或'510300.XSHG'是一样的）
      # 开盘前运行
    run_monthly(before_market_open, monthday=1, time='9:00', reference_security='000300.XSHG')
      # 开盘运行
    run_monthly(market_open, monthday=1, time='9:30', reference_security='000300.XSHG')

## 开盘前运行函数
def before_market_open(context):
    print('调仓日期：%s'%context.current_dt.date())

    # 选出上证50成分股的一部分与选定的ETF基金进行组合,构成股票池。
    etf = [
        '159902.XSHE',
        '159903.XSHE',
        '510050.XSHG',
        '510880.XSHG',
        '510440.XSHG',
        ]
    g.buy_list = list(get_index_stocks('000016.XSHG')[-15:]) + etf

## 开盘时运行函数
def market_open(context):
    # 将不在股票池中的股票卖出
    sell_list = set(context.portfolio.positions.keys()) - set(g.buy_list)
    for stock in sell_list:
        order_target_value(stock, 0)

    # 组合优化模型
    if g.optimizer == 1:
        # 模型1：等权重配置
        optimized_weight = pd.Series(data=[1.0/len(g.buy_list)]*len(g.buy_list),
                                    index=g.buy_list)
    elif g.optimizer == 2:
        # 模型2：组合风险平价；股票的总权重限制为0到90%，ETF的总权重限制为0到10%；每只标的权重不超过10%
        optimized_weight = portfolio_optimizer(date=context.previous_date,
                                    securities = g.buy_list,
                                    target = RiskParity(count=250, risk_budget=None),# risk_budget 为 None默认为每只股票贡献相等
                                    constraints = [MarketConstraint('stock', low=0.0, high=0.9),
                                                  MarketConstraint('etf', low=0.0, high=0.1)],
                                    bounds=[Bound(0, 0.1)],
                                    default_port_weight_range=[0., 1.0],
                                    ftol=1e-09,
                                    return_none_if_fail=True)
    elif g.optimizer == 3:
        # 模型3：组合风险最小化（最小化组合方差）；组合总权重限制为90%到100%；组合年化收益率目标下限为10%
        optimized_weight = portfolio_optimizer(date=context.previous_date,
                                    securities = g.buy_list,
                                    target = MinVariance(count=250),
                                    constraints = [WeightConstraint(low=0.9, high=1.0),
                                                   AnnualProfitConstraint(limit=0.1, count=250)],
                                    bounds=[],
                                    default_port_weight_range=[0., 1.0],
                                    ftol=1e-09,
                                    return_none_if_fail=True)
    elif g.optimizer == 4:
        # 模型4：组合标的因子值最大化

        # 定义因子：人气指标5日均值
        class AR(Factor):
            name = 'ar'
            # 每天获取过去五日的数据
            max_window = 5
            # 获取的数据是人气指标
            dependencies = ['AR']
            def calc(self, data):
                return data['AR'].mean()
        # 模型4：'人气指标5日均值'最大化；组合年化收益率目标下限为10%；每只标的权重不超过20%
        optimized_weight = portfolio_optimizer(date=context.previous_date,
                                    securities = g.buy_list,
                                    target = MaxFactorValue(factor=AR, count=1),
                                    constraints = [AnnualProfitConstraint(limit=0.2, count=250)],
                                    bounds=[Bound(0, 0.2)],
                                    default_port_weight_range=[0., 1.0],
                                    ftol=1e-09,
                                    return_none_if_fail=True)
    elif g.optimizer == 5:
        # 模型5：组合夏普比率最大化；每只标的权重不超过10%
        optimized_weight = portfolio_optimizer(date=context.previous_date,
                                    securities = g.buy_list,
                                    target = MaxSharpeRatio(rf=0.0,weight_sum_equal=0.5, count=250),#无风险利率为0，最大化夏普比率需要约束组合权重的和为0.5
                                    constraints = [],
                                    bounds=[Bound(0, 0.1)],
                                    default_port_weight_range=[0., 1.0],
                                    ftol=1e-09,
                                    return_none_if_fail=True)

    # 查看优化结果
    print(optimized_weight)

    # 优化失败，给予警告
    if type(optimized_weight) == type(None):
        print('警告：组合优化失败')
    # 按优化结果，执行调仓操作
    else:
        total_value = context.portfolio.total_value # 获取总资产
        for stock in optimized_weight.keys():
            value = total_value * optimized_weight[stock] # 确定每个标的的权重
            order_target_value(stock, value) # 调整标的至目标权重

策略程序架构♠

initialize(context)

def initialize(context):
    # g为全局变量
    g.security = "000001.XSHE"

def initialize(context):
    ## func是您自己定义的函数
    # 按月运行
    run_monthly(func, monthday, time='9:30', reference_security, force=False)
    # 按周运行
    run_weekly(func, weekday, time='9:30', reference_security, force=False)
    # 每天内何时运行(没有force属性)
    run_daily(func, time='9:30', reference_security)

def initialize(context):
    run_daily(func, time='10:00')

def func(context):
    parm1 = 'JoinQuant'
    func1(context, parm1)

def func1(context, parm1):
    print(parm1)
    print(context.current_dt)
    print('-'*50)

def on_week_start(context):
    pass

class MyObject(object):
    def on_week_start2(self, context):
        pass

def initialize(context):
    # OK
    run_weekly(on_week_start, 1)
    # 错误, 下面的语句会报错
    run_weekly(MyObject().on_week_start2, 1)

def on_week_start(context):
    pass
def on_week_end(context):
    pass
def initialize(context):
    run_weekly(on_week_start, 1)
    run_weekly(on_week_end, -1)

def initialize(context):
    run_weekly(weekly, 1)

def weekly(context):
    if context.current_dt.isoweekday() != 1:
        # 不在周一, 跳过执行
        return

def initialize(context):
    run_weekly(market_open, weekday=2, force=False)

def market_open(context):
    print("今天是周内第二个交易日") #注意策略开始的那一周,第一个交易日是按策略开始的日期开始计算的

def weekly(context):
    print('weekly %s %s' % (context.current_dt, context.current_dt.isoweekday()))


def monthly(context):
    print('monthly %s %s' % (context.current_dt, context.current_dt.month))


def daily(context):
    print('daily %s' % context.current_dt)


def initialize(context):

    # 指定每月第一个交易日, 在开盘后十分钟执行
    # 注意策略开始的那一月,第一个交易日是按策略开始的日期开始计算的
    run_monthly(monthly, 1, '09:40')

    # 指定每周倒数第一个交易日, 在开盘前执行
    run_weekly(weekly, -1, '9:00')

    # 指定每天收盘前10分钟运行
    run_daily(daily, '14:50')

    # 指定每天收盘后执行
    run_daily(daily, '15:30')

    # 指定在每天的10:00运行
    run_daily(daily, '10:00')

    # 指定在每天的01:00运行
    run_daily(daily, '01:00')

    # 参照股指期货的时间每分钟运行一次, 必须选择分钟回测, 否则每天执行
    run_daily(daily, 'every_bar', reference_security='IF9999.CCFX')

handle_data(context, data)

def handle_data(context, data):
    order("000001.XSHE",100)

on_event(context, event)

before_trading_start(context)

def before_trading_start(context):
    log.info(str(context.current_dt))

after_trading_end(context)

def after_trading_end(context):
    log.info(str(context.current_dt))

def on_strategy_end(context)

def on_strategy_end(context):
    print('回测结束')

process_initialize(context)

def process_initialize(context):
    # query 对象不能被 pickle 序列化, 所以不能持久保存, 所以每次进程重启时都给它初始化
    # 以两个下划线开始, 系统序列化 [g](#g) 时就会自动忽略这个变量, 更多信息, 请看 [g](#g) 和 [模拟盘注意事项](#simulation_matters)
    g.__q = query(valuation)

def handle_data(context, data):
    get_fundamentals(g.__q)

after_code_changed(context)

def after_code_changed(context):
    g.stock = '000001.XSHE'

# 取消所有定时运行
unschedule_all()

def after_code_changed(context):
    # 取消所有定时运行
    unschedule_all()
    # 设定新的定时运行函数，指定函数在每天的10:00运行
    run_daily(func, '10:00')

策略API介绍

注意事项

• 【取数据函数】【其它函数】目录中带有"♠" 标识的API是 "回测环境/模拟"专用的API，不能在研究模块中调用。整个 【jqdata 模块】在研究环境与回测环境下都可以使用.
• 所有价格单位是元
• 时间表示:
  • 所有时间都是北京时间, 时区:UTC+8
  • 所有时间都是datetime.datetime对象
• 每个交易日结束时自动撤销所有未完成订单， 例如A股是在17:00之后。
• 下文中提到 Context, SecurityUnitData, Portfolio, Position, Order 对象都是只读的, 尝试修改他们会报错或者无效.
• 没有python基础的同学请注意, 有的函数的定义中, 某些参数是有值的, 这个值是参数的默认值, 这个参数是可选的, 可以不传.
• 回测和模拟中，每日下单的最大数量为10000笔

如需使用策略组合或分仓操作，请看策略组合操作.

策略设置函数

set_benchmark(security)

set_benchmark('600000.XSHG')

set_benchmark({'000001.XSHG':0.5,'000300.XSHG':0.3,'600000.XSHG':0.2})

set_order_cost(cost, type, ref=None)

# 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣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')

# 期货类每笔交易时的手续费是：买入时万分之0.23,卖出时万分之0.23,平今仓为万分之23
set_order_cost(OrderCost(open_tax=0, close_tax=0, open_commission=0.000023, close_commission=0.000023, close_today_commission=0.0023, min_commission=0), type='index_futures')

# 单独设置 000300.XSHG 的费用
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', ref='000300.XSHG')

# 设置所有期货（包括金融指数期货）的费用
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='futures')

# 对 IF/IH/IC 三个品种有效
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='index_futures')

# 单独设置AU期货品种的费用
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='futures', ref='AU')

# 单独设置AU1709合约的费用
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='futures', ref='AU1709')