聚宽 (JoinQuant) API 文档

使用前复权价格，不论回测开始时间、结束时间是何时，使用的数据都是基于今天（回测当天）或某个时间的复权因子进行前复权获得的价格，因此使用前复权价格进行回测，回测结果肯定有问题。示意图如下：

不论历史时刻1或历史时刻2，拿到的数据都是基于未来某一天的前复权价格，使用这样的数据存在未来函数（未来函数是回测最大的敌人之一）

使用真实价格回测模式，回测到历史时刻1，使用历史时刻1的真实价格撮合成交；如果需要复权，会使用的历史时刻1的复权因子，对“历史时刻1"之前的价格进行前复权，这样有效避免了未来函数，因为回测全程都不可能使用未来的数据。

你可能没有看懂，下面举个例子：

如现有一只股票，股价一直没有波动，只进行了拆分。

• 前复权回测模式

  • 站在“历史时刻3”看历史数据：因为使用今天的复权因子，“历史时刻3”之前的股价均为2；
  • 站在“历史时刻2”看历史数据：因为使用今天的复权因子，“历史时刻3”的股价是2；
  • 站在“历史时刻1”看历史数据，因为使用今天的复权因子，“历史时刻2”和“历史时刻3”的股价是2；

• 真实价格回测模式

  • 站在“历史时刻3”看历史数据：因为使用历史时刻3的复权因子，“历史时刻3”之前的股价均为8
  • 站在“历史时刻2”看历史数据：因为使用历史时刻2的复权因子，“历史时刻3”的股价是4；
  • 站在“历史时刻1”看历史数据：因为使用历史时刻1的复权因子，“历史时刻2”和“历史时刻3”的股价是2；

因为使用了未来的复权因子，前复权回测模式，回测过程中使用的价格是不正确的。

下面再举一个真实的例子，比较一下前复权回测模式和真实价格回测模式的区别

2007-01-30，波导股份的真实股价（绿色曲线）是低于格力电器（黑色曲线）的；但使用前复权价格，波导股份的价格会高于格力电器。 采用最简单的交易思路，购买股价低的股票并持有，前复权模式会买入格力电器，真实价格回测模式会买入波导股份。

下面我们进行回测，根据2007-01-30当天格力电器与波导股份的收盘价，买入低价位股票并持有到现在。回测结果如下所示：

前复权回测模式的回测结果： 初始资金：100,000 策略收益：776.54% 沪深300收益：21.98% 最大回撤：64.98%

真实价格回测模式的回测结果： 初始资金：100,000 策略收益：78.35% 沪深300收益：21.98% 最大回撤：79.78%

由回测结果不难看出，前复权回测模式因为存在未来函数，结果是不准确的，使用前复权回测模式可能会让你获得非常高的收益，但实盘时，效果却非常一般；在某些策略中，如使用到价格因子，前复权模式会导致回测中买卖信号与实际中不一致，从而导致回测结果不准确，影响策略在真实场景中的应用。

开启真实价格回测功能

其实很简单，只需一步即可搞定：

在initialize中使用set_option即可，如下所示：

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

近来，很多用户反馈在模拟盘看到的有些股票价格与在炒股软件上看到的不一样，对此表示很疑惑。

这是因为在模拟交易中，在未开启动态复权(真实价格)模式时，我们是使用基于模拟交易创建日期的后复权价格。

后复权模式示意图如下图所示：

不开启真实价格模拟盘的运算结果是没有错误，只是会让您理解起来更费劲一些。

用户如果想知道今天的真实价格，还需知道模拟创建的日期，并进行复权计算。

为了让用户使用更便于理解、更真实的模拟系统，我们强烈建议您开启动态复权(真实价格)模式。开启方式：用户可在代码中调用set_option('use_real_price', True).

开启动态复权(真实价格)模式示意图如下图所示：

开启动态复权(真实)模式后，您看到的价格都是最新的，每到新的一天, 如果持仓中有股票发生了拆合或者分红或者其他可能影响复权因子的情形, 我们会根据复权因子自动调整股票的数量. 但不要跨日期缓存这些 API 返回的结果

我们强烈建议您开启动态复权(真实价格)模式，进行模拟与回测！

注意：

1. 开启真实价格回测之后，为了让编写代码简单, 通过history/attribute_history/get_price/SecurityUnitData.mavg/vwap 等 API 拿到的都是基于当天日期的前复权价格. 另一方面, 你在不同日期调用 history/attribute_history/get_price/SecurityUnitData.mavg/vwap 返回的价格可能是不一样的, 因为我们在不同日期看到的前复权价格是不一样的. 所以不要跨日期缓存这些 API 返回的结果.
2. 每到新的一天, 如果持仓中有股票发生了拆合或者分红或者其他可能影响复权因子的情形, 我们会根据复权因子自动调整股票的数量, 如果调整后的数量是小数, 则向下取整到整数, 最后为了保证context.portfolio.total_value不变, context.portfolio.available_cash可能有略微调整.

投资中面临着系统性风险（即Beta）和非系统性风险（即Alpha），Alpha是投资者获得与市场波动无关的回报。比如投资者获得了15%的回报，其基准获得了10%的回报，那么Alpha或者价值增值的部分就是5%。

表示投资的系统性风险，反映了策略对大盘变化的敏感性。例如一个策略的Beta为1.5，则大盘涨1%的时候，策略可能涨1.5%，反之亦然；如果一个策略的Beta为-1.5，说明大盘涨1%的时候，策略可能跌1.5%，反之亦然。

表示每承受一单位总风险，会产生多少的超额报酬，可以同时对策略的收益与风险进行综合考虑。

表示每承担一单位的下行风险，将会获得多少超额回报。

衡量单位超额风险带来的超额收益。信息比率越大，说明该策略单位跟踪误差所获得的超额收益越高，因此，信息比率较大的策略的表现要优于信息比率较低的基准。合理的投资目标应该是在承担适度风险下，尽可能追求高信息比率。

用来测量策略的风险性，波动越大代表策略风险越高。

用来测量基准的风险性，波动越大代表基准风险越高。

描述策略可能出现的最糟糕的情况，最极端可能的亏损情况。

策略收益下行波动率。和普通收益波动率相比，下行标准差区分了好的和坏的波动。

盈利次数在总交易次数中的占比(每次卖出记为一次交易)。

策略盈利超过基准盈利的天数在总交易数中的占比。

周期盈利亏损的比例(每次卖出记为一次交易)。

衡量策略产生的超额收益的总体情况。

描述策略可能出现的跑输基准的最糟糕情况。

表示每承受一单位总风险，策略相对于基准会产生多少的超额报酬，可以同时对策略的收益与风险进行综合考虑。

由于投资的资产变动是有复利效应的，所以净值的变动是符合几何增长过程的，在这种情况中，最自然的“减法”不是减法，而是除法，所以一个更合理的超额收益算法是:

先看一眼这条线的效果，第一印象就可以发现它和策略线分开了，不是继续黏在一起。

回到上面的例子，假如在时间T时策略的净值S是基准B的十倍，那么超额收益线就是:

假设在从 T 之后的一年里，策略涨幅 2% 并且基准涨幅 10%，那么，一年之后的超额收益线是:

低于了之前的 900%，它表明了在这一年里策略跑输了基准。跑输了多少呢？算一下

告诉我们如果我们在时间T的时候用一块钱策略和一块钱基准一起跑（注意这很重要，不是十块钱策略对一块钱基准），那么在一年之后策略的净值只有基准的 92.7%。

使用除法产生的超额收益线上任意两点的数值都可以进行上面的计算，当然这里要展示的并不是教大家如何去算这个数，而是要让大家明白，只要除法版的超额收益线发生了回撤，就说明在这段时间里策略跑输了基准，而只要超额收益上涨了，就说明策略跑赢了基准，我们不需要再改时间重新回测就可以知道这个信息了。

举一个可以看出效果的例子，看下图标为 1 和 2 的部分：

• 在 1 的地方，策略和基准都涨了。谁涨的多？看黄线下跌了，所以是基准涨的多。
• 在 2 的地方策略和基准都跌了。谁跌的多？看黄线又是下跌了，所以是策略跌的多。
• 在 1 和 2 哪个地方策略输于基准更厉害？在1的地方黄线挖了一个坑，而在 2 的地方黄线下降并不多，所以虽然看起来2的地方策略跌得很厉害，但其实1的那段输于基准更多。

除此之外，我们知道回测在14年7月4号的超额收益指标是 150% 左右，并且在16年6月24号是接近 200%，并且根据这条黄线的形状，我们可以判断出：如果我从14年7月4号开始运行这个策略，它会在很长一段时间里跑输基准，然后在红色竖线的地方追平，最后在16年6月24号的地方净值大于基准；我们甚至不需要知道策略和基准的收益曲线都可以做出这个判断。

除法版超额收益线解决了多个时间序列在截面上比对的问题，但是同一序列在不同时间的对比还存在着问题。什么问题呢？就是我们没法看清策略在两个不同时间段的涨跌幅的区别。再回顾之前的一个回测的话，

要不是图上标出了最大回撤的位置，我们肯定目测不出最大回撤的位置。这是因为08年的时候策略净值还相对小，回撤个80%所损失的钱也不是那么多；而15年的时候净值是之前的几十倍，就算回撤20%损失也比之前回撤80%的损失多，所以在图上根本对比不出来。再者说，基准线呢？根本都看不见了啊。

和之前一样，这是由于策略净值有着复合增长效应，导致净值上很难表现出很多的信息。这里的解决办法就是把竖轴做一个变换，改成对数轴。

在对数轴的图上，策略（或者基准）在时间T时显示的高度是：

就像我们之前从减法改成用除法一样，对数log可以把乘法变加法，把除法变减法，

这样，在对数轴的图上，涨跌幅的倍数就不再是乘除关系而是加法关系，这样回测图上就能看出更丰富的信息了。

举例来说，策略在时间T的时候净值是 S，在 T+1 时是 2S，在 T+2 时是 4S，也就是说在每个时间段都翻了一倍。那么在普通轴上我们可以看出 T+1 的净值比 T 的净值高很多，但是 T+2 的净值比 T+1 高出更多，然而哪个是阶段的涨幅更大却很难看出。如果改用对数轴，那么在 T 时对数轴上高度是 $log(S)$；在 T+1 时是 $log(2S)=log(2)+log(S)$；在 T+2 时是 $log(4S)=2log(2)+log(S)$。这三个数构成一个等差数列，也就是说在对数轴上它们相互之间的距离是一样的，很容易通过目测看出每个时间段的涨跌幅是一样的。

再举个最大回撤的例子。假设一策略在 08 年高峰时的净值是 S，并且在随后的股灾中回撤 80%，即损失 0.8S；它在 15 年高峰时净值有之前的五十倍，50S，并在股灾中回撤 50%，即 25S。在普通轴上我们根本不可能目测出哪个回撤更大，但如果换到对数轴上，在08年高峰和低点的对数值分别是 $log(S)$ 和 $log(S/5)=log(S)-log(5)$，那么对数轴上的回撤是 $log(5)$；在15年高峰和低点的对数值分别是 $log(50S)$ 和 $log(25S)=log(50S/2)= log(50S)-log(2)$，在对数轴上的回撤是 $log(2)$。由于 $log(5)>log(2)$，我们可以很明显地看出 08 年的回撤大于 16 年。

除此之外，策略和基准在同一时间段中的对比也更简单了。假设基准在一段时间里翻了一倍，策略只涨了 50%，那么如果策略净值太大的话我们在普通轴上根本看不出基准有什么变动。在上边我们提到可以根据除法版超额收益的回撤来观测，而另一个方法就是在对数轴上看：在这段时间里基准在对数轴上上升了$log(2)$ 个单位，而基准只上升了 $log(1.5)$ 个单位，很直观，上升多的那个就是赢了。

我们把之前的回测放到对数轴上，净值规模造成的问题荡然无存。08 年回撤巨大，在图上清晰可见。相比之下，16 年的股灾（标注 3 的地方）虽然净值损失很多，但是实际上回撤比 08 年温柔很多，同时凭目测可以看出标注2的阴跌部分回撤和 16 年股灾中差不多。

对数轴上的超额收益的计算方法为：

也就是说，普通轴上的除法版超额收益可以很方便地移植到对数轴上，只要取一个 $log$ 就好。这条曲线集成了上面说过的所有优点。首先，由于log函数是单调的（x小于y的话就有log(x)小于log(y)），那么只要超额收益线在对数轴上上升或下降，就说明它在普通轴上同样也上升或下降，于是可以看出策略在这段时间里是跑赢还是跑输了大盘。另外，在对数轴上，净值的规模效应也被消除了。举例来说，在时间T的时候策略净值 S，基准净值 B，一年之后变动为 3S 和 2B，再假设在多年后的某个时间点策略和基准的净值分别是 10S 和 B，一年后变成 30S 和 2B。在这两个一年期里都是策略翻两倍基准翻一倍，实际上是一样的涨跌幅。在基准轴上超额收益分别是从 S/B-100% 变到3S/2B-100%以及从 10S/B-100% 变到30S/2B-100%，由于净资产规模的影响，后者在图像上的变动是前者的 10 倍。但是如果改用对数轴，我们看到两个一年期内超额收益的对数分别是从 $log(S/B)$ 变到 $log(3/2)+log(S/B)$ 以及从 $log(10S/B)$ 变到 $log(3/2)+log(10S/B)$，都是得到了$log(3/2)$ 的增长，反映了在这两个一年期里，策略相对于大盘的表现是一样的。

如何看一个策略是否有稳定的alpha收益？最直观的方法莫过于看它在对数轴上的超额收益线了，如果那条线是稳定斜向向上的就对了。

先看这个回测，它有着整体很高的超额收益，但是我们也发现了几个明显的黄线回撤，说明它在这些时段跑输大盘的地方。而下面这个策略虽然收益不如上面的高，但是超额收益高稳定得多，黄线看不出明显回撤说明它基本没有跑输大盘的时候。

进一步，我们也可以看出这个策略的超额收益都产生于哪些时候。在第一根红线之前超额收益超额收益斜率较大，说明超额收益很高；两根红线的之间的超额收益基本为零；第二根红线之后又开始有了超额收益，但远没有第一个阶段里高。策略什么时候强什么时候弱，哪些时段需要额外的分析研究，或者很多其他的重要信息，都在一条线上一目了然，这是一条不简单的线。

initialize(context)

初始化方法，在整个回测、模拟中最开始执行一次，用于初始一些全局变量

参数 context: Context对象, 存放有当前的账户/股票持仓信息

注意 该函数只在开始模拟交易的时候运行一次, 直接替换/修改代码导致的初始化函数变动并不会在模拟盘中生效 , 应该使用after_code_changed等函数

返回 None

示例

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

• run_monthly
• run_weekly
• run_daily

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)

回测环境/模拟专用API

指定每月, 每周或者每天要运行的函数, 可以在具体每月/周的第几个交易日(或者倒数第几天)的某一分钟执行。

在日级模拟中使用时，如果设置time='9:30'，策略的实际运行时间是9:27~9:30之间。策略内获取到逻辑时间(context.current_dt)仍然是 9:30。 注意只有在使用相同的参照标的时，定时运行函数的优先级别为:run_monthly>run_weekly>run_daily且与函数被注册的顺序无关；handle_data与handle_tick的执行顺序与前述函数无关。用户策略不应该依赖于这些计划任务执行的顺序。

调用这些函数后, handle_data可以不实现

参数

返回值 None

注意

• 一个策略中尽量不要同时使用run_daily和handle_data，更不能使用run_daily(handle_data, "xx:xx")
• 建议使用run_daily；
• 【API解析】策略运行频率（附隔固定时间运行方法）
• run_daily中的函数只能有一个参数context，具体示例如下：

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)

• 参数 func 必须是一个全局的函数, 不能是类的成员函数, 示例:

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)

• 通过history/attribute_history取天数据时, 是不包括当天的数据的(即使在15:00和after_close里面也是如此), 要取得当天数据, 只能取分钟的
• 这些函数可以重复调用, 比如下面的代码可以在每周的第一个交易日和最后一个交易日分别调用两个函数:

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)

• 每次调用这些函数都会产生一个新的定时任务, 如果想修改或者删除旧的定时任务, 请先调用 unschedule_all 来删除所有定时任务, 然后再添加新的.

• 在一月/一周交易日数不够以致于monthday/weekday无法满足时, 我们会找这周内最近的一个日期来执行, 比如, 如果某一周只有4个交易日:

  • 若 weekday == 5, 我们会在第4个交易日执行
  • 若 weekday == -5, 我们会在第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)

该函数每个单位时间会调用一次, 如果按天回测,则每天调用一次,如果按分钟,则每分钟调用一次 ,tick频率不支持这个函数。

该函数依据的时间是股票的交易时间，即 9:30 - 15:00. 期货请使用定时运行函数。

该函数在回测中的非交易日是不会触发的（如回测结束日期为2016年1月5日，则程序在2016年1月1日-3日时，handle_data不会运行，4日继续运行）。

对于使用当日开盘价撮合的日级模拟盘，在9:25集合竞价完成时就可以获取到开盘价，出于减少并发运行模拟盘数量的目的，我们会提前到9:27~9:30之间运行, 策略内获取到逻辑时间(context.current_dt)仍然是 9:30。

参数 context: Context对象, 存放有当前的账户/标的持仓信息 data: 一个字典(dict), key是股票代码, value是当时的SecurityUnitData 对象. 存放前一个单位时间(按天回测, 是前一天, 按分钟回测, 则是前一分钟) 的数据. 注意:

• 为了加速, data 里面的数据是按需获取的, 每次 handle_data 被调用时, data 是空的 dict, 当你使用 data[security] 时该 security 的数据才会被获取.
• data 只在这一个时间点有效, 请不要存起来到下一个 handle_data 再用
• 注意, 要获取回测当天的开盘价/是否停牌/涨跌停价, 请使用 get_current_data

返回
None

示例

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

on_event(context, event)

用户在策略中定义on_event，在账户中持仓的标的发生对应的事件时on_event会被调用。建议用户使用isinstance对事件类型进行判断。 目前已支持的事件有：

• DividendsEvent：分红送股事件
• ForcedLiquidationEvent：强行平仓事件

参数

• context: Context对象, 存放有当前的账户/标的持仓信息
• event: 发生的事件，一个事件对象。详见事件对象

返回
None

before_trading_start(context)

该函数会在每天开始交易前被调用一次, 您可以在这里添加一些每天都要初始化的东西.

该函数依据的时间是股票的交易时间，即该函数启动时间为'09:00'. 期货请使用定时运行函数，time 参数设定为'08:30' 。

参数 context: Context对象, 存放有当前的账户/股票持仓信息

返回 None

示例

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

after_trading_end(context)

该函数会在每天结束交易后被调用一次, 您可以在这里添加一些每天收盘后要执行的内容. 这个时候所有未完成的订单已经取消.

该函数依据的时间是股票的交易时间，即该函数启动时间为 15:30. 期货请使用定时运行函数，time 参数设定为'15:30' 。

参数 context: Context对象, 存放有当前的账户/股票持仓信息

返回 None

示例

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

def on_strategy_end(context)

在回测、模拟交易正常结束时被调用， 失败时不会被调用。

在模拟交易到期结束时也会被调用， 手动在到期前关闭不会被调用。

参数 context: Context对象, 存放有当前的账户/股票持仓信息

返回 None

示例

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

process_initialize(context)

该函数会在每次模拟盘/回测进程重启时执行, 一般用来初始化一些不能持久化保存的内容. 在 initialize 后执行.

因为模拟盘会每天重启(只在注册的定时运行时间点才会启动,任务结束后进程关闭), 所以这个函数会每天都执行.

参数 context: Context对象, 存放有当前的账户/股票持仓信息

返回 None

示例

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)

模拟盘在每天的交易时间结束后会休眠，第二天开盘时会恢复，如果在恢复时发现代码已经发生了修改，则会在恢复时执行这个函数。 具体的使用场景：可以利用这个函数修改一些模拟盘的数据。

注意: 因为一些原因, 执行回测时这个函数也会被执行一次, 在 process_initialize 执行之前执行.

参数 context: Context对象, 存放有当前的账户/股票持仓信息

返回 None

示例

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')

set_benchmark(security)

默认我们选定了沪深300指数的每日价格作为判断您策略好坏和一系列风险值计算的基准. 您也可以使用set_benchmark指定其他股票/指数/ETF/自定义组合的价格作为基准。

如果在期货策略中不希望看到基准，可以这样设置：set_benchmark({"000001.XSHG":0})，策略可以正常运行 （但无法计算alpha等收益）。

参数

• security:股票/指数/ETF代码，或者一个dict，key为股票/指数/ETF代码，value为小于1的浮点数，代表对应标的的权重，权重之和必须小于等于1（小于1代表基准中部分资金闲置）。

返回 None

示例一

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)

指定每笔交易要收取的手续费, 系统会根据用户指定的费率计算每笔交易的手续费

参数

• cost: OrderCost 对象

• open_tax，买入时印花税 (只股票类标的收取，基金与期货不收)

• close_tax，卖出时印花税 (只股票类标的收取，基金与期货不收)

• open_commission，买入时佣金

• close_commission, 卖出时佣金

• close_today_commission, 平今仓佣金

• min_commission, 最低佣金，不包含印花税

• type: 股票、场内基金、场内交易的货币基金、分级A基金、分级B基金、分级母基金、金融期货、期货、债券基金、股票基金、QDII 基金、混合基金，'stock'/ 'fund' / 'mmf' /'fja'/'fjb'/ 'fjm'/ 'index_futures' / 'futures' / 'bond_fund' / 'stock_fund' / 'QDII_fund' / / ‘mixture_fund' /

• ref: 参考代码，支持股票代码/基金代码/期货合约代码，以及期货的品种，如 '000001.XSHE'/'510180.XSHG'/'IF1709'/'IF'/'000300.OF'

注意：针对特定的交易品种类别设置手续费时，必须将ref设为None；若针对特定的交易品种或者标的，需要将type设置为对应的交易品种类别，将ref设置为对应的交易品种或者标的

默认与示例

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

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

set_slippage(object,type=None, ref=None)

设定滑点，回测/模拟时有效.

当您下单后, 真实的成交价格与下单时预期的价格总会有一定偏差, 因此我们加入了滑点模式来帮您更好的模拟真实市场的表现. 我们也支持为交易品种和特定的交易标的设置滑点。

参数

• type：交易品种，支持股票、基金、金融期货、期货、债券基金、股票基金、QDII 基金、货币基金、混合基金，'stock'/ 'fund' / 'index_futures' （金融期货）/ 'futures'（包含股指期货和商品期货） / 'bond_fund' / 'stock_fund' / 'QDII_fund' / 'money_market_fund' / ‘mixture_fund' 。为None时则应用于全局。当type被设定而ref为None时，表示将滑点应用于交易品种为type的所有交易标的。
• ref: 标的代码。如要为特定交易标的单独设置滑点，必须同时设置type为交易标的的交易品种。

固定滑点 当您使用固定滑点的时候, 我们认为您的落单的多少并不会影响您最后的成交价格. 您只需要指定一个价差, 当您下达一个买单指令的时候, 成交的价格等于当时(您执行order函数所在的单位时间)的平均价格加上价差的一半；当您下达一个卖出指令的时候，卖出的价格等于当时的平均价格减去价差的一半. 价差可以设定为一个固定值或者按照百分比设定。

• 固定值： 这个价差可以是一个固定的值(比如0.02元, 交易时加减0.01元), 设定方式为：FixedSlippage(0.02)
• 百分比： 这个价差可以是是当时价格的一个百分比(比如0.2%, 交易时加减当时价格的0.1%), 设定方式为：PriceRelatedSlippage(0.002)
• 跳数（期货专用，双边）: 这个价差可以是合约的价格变动单位（跳数），比如2跳，设定方式为： StepRelatedSlippage(2)；滑点为小数时，向下取整，例如设置为3跳，单边1.5，向下取整为1跳。

# 为全部交易品种设定固定值滑点
set_slippage(FixedSlippage(0.02))

# 为股票设定滑点为百分比滑点
set_slippage(PriceRelatedSlippage(0.00246),type='stock')

# 设置CU品种的滑点为跳数滑点2
set_slippage(StepRelatedSlippage(2),type='futures',ref = 'CU') 

# 为螺纹钢RB1809设定滑点为跳数滑点(注意只是这一个合约，不是所有的RB合约)
set_slippage(StepRelatedSlippage(2),type='futures', ref="RB1809.XSGE")
# StepRelatedSlippage(2)表示开平的单边滑点为1个价格最小单位，螺纹钢价格最小变动单位为1元/吨
# 如果以市价单进行开多仓（或者平空仓），现价3000元，成交价3000+1*2/2=3001元
# 如果以市价单进行开空仓（或者平多仓），现价3000元，成交价3000-1*2/2=2999元

注：(1)如果您没有调用 set_slippage 函数, 系统默认的滑点是 PriceRelatedSlippage(0.00246)；(2)所有类型为 "mmf"与"money_market_fund"的标的滑点默认为0，且调用set_slippage重新设置也不会生效。

set_option('use_real_price', value)

该设定必须在initialize中调用，建议开启
设置是否开启动态复权（真实价格）模式，默认是False(主要是为了让旧的策略不会出错)。 是否开启动态复权模式对模拟交易是有影响的，原理参考拆分合并与分红，【API解析】| 动态复权与技术指标。

参数

• value: True / False

示例

# 开启动态复权模式
set_option('use_real_price', True)

是否开启动态复权对于回测及模拟交易的影响（原理参考拆分合并与分红）：

• 开启，value 值为 True: 回测过程中:

  • 每天看到的当天的价格都是真实的(不复权的)

  • 使用真实的价格下单, 交易详情和持仓详情里看到的都是真实价格

  • 为了让编写代码简单, 通过数据获取函数API 拿到的都是基于当天日期的前复权价格. 比如: 回测运行到���2015-01-01这一天, 那么history(3, '1d', 'close')取得的就是你穿越到2015-01-01这一天所看到的前复权价格. 另一方面, 你在不同日期调用数据获取函数API返回的价格可能是不一样的, 因为我们在不同日期看到的前复权价格是不一样的. 所以不要跨日期缓存这些API返回的结果.

  • 每到新的一天, **如果持仓中有股票发生了送股或者分红，对应的股数/现金会自动在账户中体现

  • 注意事项:

    • 如上所说, 不要跨日期缓存数据获取函数API返回的结果

    • 开启真实价格回测之后, 回测结果可能会之前不一样, 因为交易时买入数量必须是100的倍数, 使用前复权价格和实际价格能买入的数量是不一样的.

    • 如果想通过 history 拿到昨天的真实价格, 还是需要用取得价格除以factor, 因为可能今天发生了拆合分红, 导致拿到的昨天的价格是相对于今天的前复权价格.

      s = '000001.XSHE'
      df = attribute_history(s, 1, '1d', fields=['close', 'factor'])
      real_close = df['close'][-1] / df['factor'][-1]
      

• 关闭，value 值为 False: 此选项的核心是选定一个日期作为基准, 保证这个日期的价格是真实价格, 然后调整其他日期的价格. 最终保证所有价格是连续的, 在回测或者模拟交易过程中不同日期看到的价格是一致的. 下面分回测和模拟交易单独做介绍:

  • 回测: 基准日期是建立回测的日期, 回测过程中所看到的所有价格都是基于此日期的前复权价格. 比如说, 我昨天跑了一个回测, 那么回测过程所有价格都是在昨天所看到的前复权价格. 这会导致两个问题:
    • 回测过程中使用了前复权价格下单, 这是违背真实场景的.
    • 不同的日期建立的回测跑出来的结果可能会有差异, 因为如果这两次回测之间回测的股票发生了拆合或者分红, 会导致回测中看到前复权价格会不一致.
  • 模拟交易: 基准日期是建立模拟交易的日期, 模拟交易过程所看到的所有价格都是基于此日期调整过的. 为了方便计算, 我举一个虚拟的例子: 某只股票在如下三个日期的实际价格和后复权因子分别是:

• 如果你在 09-01 建立了一个模拟交易, 你在不同日期看到的所有价格都是 1

• 如果你在 10-01 建立了一个模拟交易, 你在不同日期看到的所有价格都是 2

• 如果你在 11-01 建立了一个模拟交易, 你在不同日期看到的所有价格都是 4

• 为了更好的模拟, 建议大家都设成 True.

注意： (1)对期货不生效,对场内基金会生效, 但因场内基金在拆分/合并时除权日披露不标准,目前采用的是折算基准日，和实际除权日可能有差异，鉴于此原因不建议给含有场内基金的策略开启动态复权 (2) 设置 use_real_price 为 True之后, 如下的按天回测的代码是不对的：

def initialize(context):
    g.cached_data = []
    g.s = '000001.XSHE'

def handle_data(content, data):
    g.cached_data.append(data)
    if len(g.cached_data) > 1:
        # 如果昨天收盘价比前天涨了5%, 则买入. 这是不对的, 如果昨天早上发生了拆合, 则昨天和前天的股价不具可比性.
        if g.cached_data[-1][g.s].close > g.cached_data[-2][g.s].close * 1.05:
            order(g.s, 1000)

set_option('order_volume_ratio', value)

设定成交量比例，根据实际行情限制每个订单的成交量.

参数

• value: value 是一个 float 值, 默认为1.0, 根据实际行情限制每个订单的成交量.

  • 对于每一笔订单：

    • 如果是市价单, 成交量不超过: 每日成交量 * value

    • 如果是限价单, 限价单撮合时设定分价表中每一个价格的成交量的比率, 假设某一分钟分价表如下:

      价格	成交量
      10.0	10
      10.1	11
      10.2	12

    • 撮合时, 按价格 10.0 成交 10 * value 股, 按价格 10.1 成交 11 * value 股, 按价格 10.2 成交 12 * value 股

示例

# 设定成交量比例
set_option('order_volume_ratio', 0.25) # 成交量不超过总成交量的四分之一

注意
当下单量超过了当日全市场所有的成交量，系统成交数量是直接取全市场所有的成交量

set_option('match_with_order_book', value)

设定是否使用盘口撮合模式. 此选项只对模拟盘生效，默认关闭

参数

• value: 默认关闭
• True，开启，使用盘口进行撮合，撮合方式详见订单处理
• False，关闭，使用 Bar 进行撮合，撮合方式详见订单处理

set_universe(security_list)

设置或者更新此策略要操作的股票池 context.universe. 请注意:

• 该函数现在只用于设定history函数的默认security_list, 除此之外并无其他用处。

参数

• security_list: 股票列表

返回 None

示例

set_universe(['000001.XSHE', '600000.XSHG'])

set_commission(object)

已废弃。请使用set_order_cost替代

指定每笔交易要收取的手续费, 系统会根据用户指定的费率计算每笔交易的手续费

此函数已废弃，请使用 set_order_cost - 设置佣金/印花税

参数 object: 一个PerTrade对象

• PerTrade.buy_cost，买入时手续费
• PerTrade.sell_cost，卖出时手续费
• PerTrade.min_cost，最少的手续费

默认：PerTrade(buy_cost=0.0003, sell_cost=0.0013, min_cost=5) 每笔交易时的手续费是, 买入时万分之三，卖出时万分之三加千分之一印花税, 每笔交易最低扣5块钱

disable_cache()

在默认情况下系统启用了缓存以加快运行速度，但在策略内存占用较大时容易超过设置的内存上限而触发系统杀死进程。若用户反复出现策略因内存占用超限而被终止的情况，可以考虑在initialize函数中调用disable_cache来关闭缓存机制。

注意在关闭缓存后会导致策略运行速度明显下降。

为了方便用户进行策略研究，我们开放了部分实验性的设置项。开启这些设置项后，系统将允许策略进行一些不符合交易规则的非常规操作。

# T+0模式，A股买入后可以立刻卖出
set_option("t0_mode", True) 
# 总是撮合市价单，支持在非交易时间下市价单，按照最新的数据立即撮合
set_option("always_match_market_order", True) 
# 强制撮合，仅支持限价单。使用限价单进行委托时将不对委托价格和成交数量进行任何检查而直接成交，当开启此设置项时，市价单的成交价也不会受滑点的影响
set_option("match_by_signal", True) 

set_option("avoid_future_data", True)

设置回测是否开启避免未来数据模式，默认关闭
【API解析】避免未来数据

参数

• False, 关闭，回测可能带入未来数据
• True,开启，系统会提示或者处理未来数据

未来函数，未来数据
回测中能够引入未来数据的函数，即可以返回未来数据的函数；通过未来函数获取到的数据为未来数据；例如开盘使用get_price获取当天的收盘价，则get_price为未来函数，当天的收盘价为未来数据。
更多的数据可以参考数据更新频率

使用方法
在策略中使用set_option("avoid_future_data", True)来开启此功能，该选项默认为False，表示关闭。开启此功能之后，如果用户在策略中调用API的过程中，尝试通过API获取未来数据，就会抛出FutureDataError。

未来数据类型及处理方法

• 可以通过时间参数避免的未来数据：回测中使用我们提供的包含时间参数的API去取current_dt之后的数据（比如get_bars取current_dt之后的分钟数据）；设置"avoid_future_data"为True后，如果获取未来数据则抛出异常；
• 没法通过时间参数主动避免的未来数据：对于用户没法通过函数参数主动避免的未来数据（比如get_call_auction）；设置"avoid_future_data"为True后，如果获取未来数据，我们会将返回结果中的未来数据剔除掉，而不会抛出异常。

注意

• avoid_future_data只是帮助大家在写策略过程中，避免一些常见引入未来数据的问题；
• avoid_future_data不是万能的，不是包含所有检测未来数据的方法；
• 写策略过程中，如果引入外部数据(自己本地数据、连网获取数据等)也有可能带入未来数据，这些使用avoid_future_data是检测不到的；
• 策略中设置固定的股票池，设置固定时间点交易一些标的，也有可能引入未来数据，例如设置一些历史上涨幅比较大的标的在低点买入高点卖出；

因子来源

根据 WorldQuant LLC 发表的论文 101 Formulaic Alphas 中给出的 101 个 Alphas 因子公式，我们将公式编写成了函数，方便大家使用。

详细介绍

函数计算公式、API 调用方法，输入输出值详情请见:数据字典 - Alpha 101.

使用方法

# 导入 Alpha101 库
>>> from jqlib.alpha101 import *

# 获取沪深300成分股的 alpha_001 因子值
>>> a = alpha_001('2017-03-10','000300.XSHG')

# 查看前5行的因子值
>>> a.head()
000001.XSHE   -0.496667
000002.XSHE    0.226667
000008.XSHE   -0.043333
000009.XSHE   -0.093333
000027.XSHE   -0.030000
Name: rank_value_boolean, dtype: float64

# 查看平安银行的因子值
>>> a['000001.XSHE']
-0.49666666666666665

# 获取所有股票 alpha_007 的因子值
>>> a = alpha_007('2014-10-22')
# 查看欣旺达(300207)的因子值
>>> a['300207.XSHE']
0.8

# 查询函数说明
>>> alpha_101?
Type:        cython_function_or_method
String form: <cyfunction alpha_101 at 0x7f037a0167d0>
Docstring:
公式：
((close - open) / ((high - low) + .001))

Inputs:
    enddate: 查询日期
    index: 股票池

Outputs:
    因子的值

因子来源

根据国泰君安数量化专题研究报告 - 基于短周期价量特征的多因子选股体系给出了 191 个短周期交易型阿尔法因子，方便大家使用。

详细介绍

函数计算公式、API 调用方法，输入输出值详情请见:数据字典 - Alpha 191.

使用方法

# 导入 Alpha191 库
>>> from jqlib.alpha191 import *

# 获取所有股票 alpha_007 的因子值
>>>end_date = '2017-04-04'
>>>code = list(get_all_securities(['stock'],date=end_date).index)
>>> a = alpha_007(code,end_date)
# 查看欣旺达(300207)的因子值
>>> a['300207.XSHE']
1.2494895018526142

# 查询函数说明
>>> alpha_001?
Signature: alpha_001(code, end_date=None)
Docstring:
公式：
    (-1 * CORR(RANK(DELTA(LOG(VOLUME),1)),RANK(((CLOSE-OPEN)/OPEN)),6)
Inputs:
    code: 股票池
    end_date: 查询日期
Outputs:
    因子的值
File:      ~/alpha191.py
Type:      function

因子说明 为了让用户有更多可直接调用的技术分析指标因子，我们计划基于通达信、东方财富、同花顺等的公式，来完善我们的技术分析指标因子库。

我们给出了公式的API、参数说明、返回值的结果及类型说明、备注（相较于上述三家结果及算法的比对）、用法注释及示例，旨在帮助您更方便、更快速的在策略研究中使用这些因子函数。

技术指标常见问题-动态复权与技术指标

详细介绍 函数计算公式、API 调用方法，用法注释， 输入输出值详情请见:数据字典 - 技术分析指标.

使用方法

# 导入 Alpha101 库
>>> from jqlib.technical_analysis import *

# 定义股票池列表
security_list1 = '000001.XSHE'
security_list2 = ['000001.XSHE','000002.XSHE','601211.XSHG','603177.XSHG']


# 计算并输出 security_list1 的 GDX 值，分别返回：济安线、压力线和支撑线的值。
gdx_jax, gdx_ylx, gdx_zcx = GDX(security_list1,check_date='2017-01-04', N = 30, M = 9)
print(gdx_jax[security_list1])
print(gdx_ylx[security_list1])
print(gdx_zcx[security_list1])

# 输出 security_list2 的 GDX 值
gdx_jax, gdx_ylx, gdx_zcx = GDX(security_list2,check_date='2017-01-04', N = 30, M = 9)
for stock in security_list2:
    print(gdx_jax[stock])
    print(gdx_ylx[stock])
    print(gdx_zcx[stock])

# 查询函数说明
>>> GDX?
Signature: GDX(security_list, check_date, N=30, M=9)
Docstring:
 计算公式：
    AA:=ABS((2*CLOSE+HIGH+LOW)/4-MA(CLOSE,N))/MA(CLOSE,N); 
    JAX:DMA(CLOSE,AA);
    压力线:(1+M/100)*JAX; 
    支撑线:(1-M/100)*JAX; 
    AA赋值:(2*收盘价+最高价+最低价)/4-收盘价的N日简单移动平均的绝对值/收盘价的N日简单移动平均
    输出济安线 = 以AA为权重收盘价的动态移动平均
    输出压力线 = (1+M/100)*JAX
    输出支撑线 = (1-M/100)*JAX
输入：
    security_list:股票列表
    check_date：要查询数据的日期
    N：统计的天数 N
    M：统计的天数 M
输出：
    济安线、压力线和支撑线的值。
输出结果类型：
    字典(dict)：键(key)为股票代码，值(value)为数据。

neutralize(series, how=None, date=None, axis=1, fillna=None, add_constant=False)

参数

• data: pd.Series/pd.DataFrame , 待中性化的序列，序列的 index 为股票的 code

• how: str list 。 中性化使用的因子名称列表。默认为 ['jq_l1', 'market_cap'] 支持的内容包括：

  • 财务数据：如 'market_cap', 'net_profit'等；也可以输入对数市值'ln_market_cap' 和 对数流通市值 'ln_circulating_market_cap';

  • 行业数据：可输入行业分类代码（如 'jq_l1', 'sw_l1'）或行业代码（如 'HY001'）

    行业代码分类会被替换为行业代码，例如输入 how=['jq_l1'] 和 how=['HY001','HY002','HY003','HY004','HY005','HY006','HY007', 'HY008','HY009','HY010','HY011'] 是等价的

    • 'jq_l1'： 聚宽一级行业
    • 'jq_l2'： 聚宽二级行业
    • 'sw_l1'： 申万一级行业
    • 'sw_l2'： 申万二级行业
    • 'sw_l3'： 申万三级行业

  • 聚宽因子库因子名称，如 'operating_profit_ttm', 'VOL240'

  • 风险因子：可以使用的风险因子包括： ['size', 'beta', 'momentum', 'residual_volatility', 'non_linear_size', 'book_to_price_ratio', 'liquidity', 'earnings_yield', 'growth', 'leverage']

• date: 日期格式 str 将用 date 这天的相关变量数据对 series 进行中性化；请注意date不要为实时数据中的天（例如设置date=datetime.date.today())，因为此时处理依赖的当天财务数据还没有更新，默认依赖数据为Nan；如果依赖数据为Nan , 直接忽略,返回原始数据, 不中性化；

• axis: 默认为 1。仅在 data 为 pd.DataFrame 时生效。 表示沿哪个方向做中性化，0 为对每列做中性化，1 为对每行做中性化

• fillna: 缺失值填充方式，默认为None，表示不填充。支持的值：

  • 'jq_l1'： 聚宽一级行业
  • 'jq_l2'： 聚宽二级行业
  • 'sw_l1'： 申万一级行业
  • 'sw_l2'： 申万二级行业
  • 'sw_l3'： 申万三级行业 表示使用某行业分类的均值进行填充。

• add_constant: 中性化时是否添加常数项, 默认为 False

返回

中性化后的因子数据

示例

# 导入需要的函数库
import pandas as pd
import numpy as np
from jqfactor import neutralize
# 生成数据
data = pd.DataFrame(np.random.rand(3,300), columns=get_index_stocks('000300.XSHG', date='2018-05-02'),index=['a', 'b', 'c'])
# 数据中性化
neutralize(data, how=['jq_l1', 'market_cap'], date='2018-05-02', axis=1)

winsorize(series, scale=None, range=None, qrange=None, inclusive=True, inf2nan=True, axis=1)

参数

• data: pd.Series/pd.DataFrame/np.array, 待缩尾的序列
• scale: 标准差倍数，与 range，qrange 三选一，不可同时使用。会将位于 [mu - scale * sigma, mu + scale * sigma] 边界之外的值替换为边界值
• range: 列表， 缩尾的上下边界。与 scale，qrange 三选一，不可同时使用。
• qrange: 列表，缩尾的上下分位数边界，值应在 0 到 1 之间，如 [0.05, 0.95]。与 scale，range 三选一，不可同时使用。
• inclusive: 是否将位于边界之外的值替换为边界值，默认为 True。如果为 True，则将边界之外的值替换为边界值，否则则替换为 np.nan
• inf2nan: 是否将 np.inf 和 -np.inf 替换成 np.nan，默认为 True如果为 True，在缩尾之前会先将 np.inf 和 -np.inf 替换成 np.nan，缩尾的时候不会考虑 np.nan，否则 inf 被认为是在上界之上，-inf 被认为在下界之下
• axis: 在 data 为 pd.DataFrame 时使用，沿哪个方向做标准化，默认为 1。 0 为对每列做缩尾，1 为对每行做缩尾。

返回

去极值处理之后的因子数据

示例

# 导入需要的函数库
import pandas as pd
import numpy as np
from jqfactor import winsorize
# 生成数据
data = pd.DataFrame(np.random.rand(3,300), columns=get_index_stocks('000300.XSHG', date='2018-05-02'),index=['a', 'b', 'c'])
# 数据去极值
winsorize(data, qrange=[0.05,0.93], inclusive=True, inf2nan=True, axis=1)

winsorize_med(series, scale=1, inclusive=True, inf2nan=True, axis=1)

参数

• data: pd.Series/pd.DataFrame/np.array, 待缩尾的序列
• scale: 倍数，默认为 1.0。会将位于 [med - scale * distance, med + scale * distance] 边界之外的值替换为边界值/np.nan
• inclusive bool 是否将位于边界之外的值替换为边界值，默认为 True。 如果为 True，则将边界之外的值替换为边界值，否则则替换为 np.nan
• inf2nan: 是否将 np.inf 和 -np.inf 替换成 np.nan，默认为 True。如果为 True，在缩尾之前会先将 np.inf 和 -np.inf 替换成 np.nan，缩尾的时候不会考虑 np.nan，否则 inf 被认为是在上界之上，-inf 被认为在下界之下
• axis: 在 data 为 pd.DataFrame 时使用，沿哪个方向做标准化，默认为 1。0 为对每列做缩尾，1 为对每行做缩尾

返回

中位数去极值之后的因子数据

示例

# 导入需要的函数库
import pandas as pd
import numpy as np
from jqfactor import winsorize_med
# 生成数据
data = pd.DataFrame(np.random.rand(3,300), columns=get_index_stocks('000300.XSHG', date='2018-05-02'),index=['a', 'b', 'c'])
# 数据中位数去极值
winsorize_med(data, scale=1, inclusive=True, inf2nan=True, axis=0)

standardlize(series, inf2nan=True, axis=1)

参数

• data: pd.Series/pd.DataFrame/np.array, 待标准化的序列
• inf2nan: 是否将 np.inf 和 -np.inf 替换成 np.nan。默认为 True
• axis=1: 在 data 为 pd.DataFrame 时使用，如果 series 为 pd.DataFrame，沿哪个方向做标准化。0 为对每列做标准化，1 为对每行做标准化

返回

标准化后的因子数据

示例

# 导入需要的函数库
import pandas as pd
import numpy as np
from jqfactor import standardlize
# 生成数据
data = pd.DataFrame(np.random.rand(3,300), columns=get_index_stocks('000300.XSHG', date='2018-05-02'),index=['a', 'b', 'c'])
# 数据标准化
standardlize(data, inf2nan=True, axis=0)

• MinVariance(count=250) - 组合风险最小化（最小化组合方差）

  ​ 最小化组合方差

  • 参数：

    count: 默认为 250，向前取 returns 的天数

  • 示例：

    target = MinVariance(count=250)

• MaxProfit(count=250) - 组合收益最大化

  • 参数：

    count: 默认为 250，向前取 returns 的天数

  • 示例：

    target = MaxProfit(count=250)

• MaxSharpeRatio(rf=0.0, weight_sum_equal=1.0, count=250) - 组合夏普比率最大化

  • 参数：

    rf: 年化无风险利率，默认为 0

    weight_sum_equal：组合总权重的值（默认值为1.0），在该权重下进行优化，使得组合的夏普比率最大化

    count: 默认为 250，向前取 returns 的天数

  • 示例：

    target = MaxSharpeRatio(count=250)

• MinTrackingError(benchmark, count=250) - 追踪误差最小化

  • 参数：

    benchmark: 基准的 ticker，例如 '000300.XSHG'

    count: 默认为 250，向前取 returns 的天数

  • 示例：

    target = MinTrackingError(benchmark='000300.XSHG', count=250)

• RiskParity(count=250, risk_budget=None) - 风险平价

  风险平价（Risk Parity）是对投资组合中不同资产分配相同的风险权重的一种资产配置理念，资产配置的风险平价方法允许投资者针对具体的风险水平，并在整个投资组合中平均分配风险，以实现每个投资者的最佳投资组合多元化。

  • 参数：

    count: 默认为 250，向前取 returns 的天数

    risk_budget: pandas.Series，风险预算，股票的每只对组合风险的贡献，risk_budget 为 None默认为每只股票贡献相等

  • 示例：

    target = RiskParity(count=250, risk_budget=pd.Series([0.3, 0.3, 0.4], index=['000001.XSHE', '000002.XSHE', '000005.XSHE']))

• MaxScore(scores) - 打分最大化

  在满足约束条件的情况下，给予打分高的标的更高权重（前提假设：用户已知晓打分大的标的表现更好）。

  如有经过因子分析检验，打分越高越有正向效果的[A,B,C] 三只标的，打分分别为 [3,2,1] , 约束条件为年化波动率小于15%。 如果组合全部配置A可获得最高的收益，但波动率大于15%，不满足约束条件；通过优化器优化，则会配置一定比例的B与C，在满足波动率小于15%的条件下，获得最高收益。

  • 参数：

    scores: pandas.Series，每只股票的打分

  • 示例：

    target = MaxScore(scores=pd.Series([0.1, 0.2, 0.3], index=['000001.XSHE', '000002.XSHE', '000005.XSHE']))

• MinScore(scores) - 打分最小化

  在满足约束条件的情况下，给予打分低的标的更高权重（前提假设：用户已知晓打分小的标的表现更好）。可参考 [打分最大化] 的示例说明。

  • 参数：

    scores: pandas.Series，每只股票的打分

  • 示例：

    target = MinScore(scores=pd.Series([0.1, 0.2, 0.3], index=['000001.XSHE', '000002.XSHE', '000005.XSHE']))

• MaxFactorValue(factor, count=1) - 因子值最大化(只支持股票)

  在满足约束条件的情况下，给予因子值大的标的更高权重（前提假设：用户已知晓因子值大的标的表现更好）。可参考 [打分最大化] 的示例说明。

  • 参数：

    factor: Factor 的子类

    count: 默认为 1，用过去几天的因子取平均

  • 示例：

    from jqfactor import Factor
    # 定义因子：人气指标5日均值
    class AR(Factor):
        name = 'AR_M5'
        # 每天获取过去五日的数据
        max_window = 5
        # 获取的数据是人气指标
        dependencies = ['AR']
        def calc(self, data):
            return data['AR'].mean()
  
    target = MaxFactorValue(factor=AR, count=1)
  

• MinFactorValue(factor, count=1) - 因子值最小化(只支持股票)

  在满足约束条件的情况下，给予因子值小的标的更高权重（前提假设：用户已知晓因子值小的标的表现更好）。可参考 [打分最大化] 的示例说明。

  • 参数：

    factor: Factor 的子类

    count: 默认为 1，用过去几天的因子取平均

  • 示例：

    参考 [因子值最大化] 的示例

• WeightConstraint(low=0.0, high=1.0) - 组合总权重限制

  设定组合优化结果总权重的上下限，即优化结果的总权重在此范围间。

  • 参数：

    low: 默认为 0.0，权重下限

    high: 默认为 1.0，权重上限

  • 示例：

    constraint = WeightConstraint(low=0.5, high=0.9)

• WeightEqualConstraint(limit=1.0) - 组合总权重和限制

  设定组合优化结果总权重的和，即优化结果的总权重等于该值。

  • 参数：

    limit: 默认为 1.0，组合权重等式约束

  • 示例：

    constraint = WeightEqualConstraint(limit=0.5)

• AnnualStdConstraint(limit, count=250) - 组合年化收益率标准差限制

  • 参数：

    limit: 标准差上限

    count: 默认为 250，向前取 returns 的天数

  • 示例：

    constraint = AnnualStdConstraint(limit=0.15, count=250)

• AnnualProfitConstraint(limit, count=250) - 组合年化收益率预期限制

  • 参数：

    limit: 收益率预期下限

    count: 默认为 250，向前取 returns 的天数

  • 示例：

    constraint = AnnualProfitConstraint(limit=0.1, count=250)

• IndustryConstraint(industry_code, low=0.0, high=1.0) - 组合行业权重限制

  • 参数：

    industry_code: 单一或多个行业代码，如 'HY001'。如果为多个行业代码的列表，则表示所有属于列表中行业的股票的权重之和满足限制条件

    low: 默认为 0.0，行业权重下限

    high: 默认为 1.0，行业权重上限

  • 示例：

    constraint = IndustryConstraint(['HY007'], low=0.0, high=0.2)

• IndustriesConstraint(industry_code, low=0.0, high=1.0)- 组合行业分类权重限制

  • 参数：

    industry_code: 行业分类代码，如 'jq_l1'。表示这个行业分类下的所有行业都需满足权重限制

    low: 默认为 0.0，行业权重下限

    high: 默认为 1.0，行业权重上限

  • 示例：

    constraint = IndustriesConstraint('jq_l1', low=0.0, high=0.2)

• MarketConstraint(market_type, low=0.0, high=1.0) - 组合市场权重限制

  • 参数：

    market_type: ('stock', 'index', 'fund', 'futures', 'etf', 'lof', 'fja', 'fjb', 'open_fund', 'bond_fund', 'stock_fund', 'QDII_fund', 'money_market_fund', 'mixture_fund') 中的一种

    low: 默认为 0.0，市场权重下限

    high: 默认为 1.0，市场权重上限

  • 示例：

    constraint = MarketConstraint('stock', low=0.0, high=0.2)

• ExposureConstraint(factor, low=0.0, high=1.0, count=1) - 因子暴露限制

  • 参数：

    factor: Factor 的子类

    low: 默认为 0.0，因子暴露度下限

    high: 默认为 1.0，因子暴露度上限

    count: 默认为 1，用过去几天的因子取平均

  • 示例：

    from jqfactor import Factor
    # 定义因子：人气指标5日均值
    class AR(Factor):
        name = 'AR_M5'
        # 每天获取过去五日的数据
        max_window = 5
        # 获取的数据是人气指标
        dependencies = ['AR']
        def calc(self, data):
            return data['AR'].mean()
  
    constraint = ExposureConstraint(AR, low=0.0, high=10.0, count=1)
  

• 风险暴露限制函数 - BarraConstraint(size=None, beta=None, momentum=None, residual_volatility=None, no_linear_size=None, book_to_price=None, liquidity=None, earning_yield=None, growth=None, leverage=None, standardlize=True, winsorize=True)

  • 参数：

    • 其中 size/beta/momentum/residual_volatility/no_linear_size/book_to_price/liquidity/earning_yield/growth/leverage
      • 分别代表'市值因子'/'贝塔因子'/'动量因子'/'残差波动因子'/'非线性市值因子'/'账面市值比因子'/'流动性因子'/'盈利预期因子'/'成长因子'/'杠杆因子'；
      • 需传入长度为2的列表, 代表对应因子的上下限, 如 [-0.5, 0.5], 默认为 None, 即无限制
    • standardlize: 是否对因子值进行标准化处理, 默认为 True
    • winsorize: 是否对因子值去极值, 默认为 True, 即将因子值 [MED-3MEDMED, MED+3MEDMED] 之外的因子值赋成边界值 (MED 为因子值的中位数, MEDMED 为 ABS(因子值-MED) 的中位数)

  • 示例：

    constraint = BarraConstraint(size=[-0.5, 0.5], beta=[None, 1.5], winsorize=False)
  

• IndustryDeviationConstraint - 行业偏离度限制

  某一行业权重与基准权重偏离度限制

  IndustryDeviationConstraint(industry_code, benchmark, limit)

  • 参数：

    industry_code: 单一行业代码或者行业代码的列表，如 'HY001'。

    benchmark: 基准指数代码

    limit: 偏离度限制

  • 例子：

    constraint = IndustryDeviationConstraint(industry_code='HY001', benchmark='000300.XSHG', limit=0.05)

• IndustriesDeviationConstraint - 行业分类偏离度限制

  行业分类权重与基准权重偏离度限制

  IndustriesDeviationConstraint(industry_code, benchmark, limit)

  • 参数：

    industry_code: 行业分类代码，如 'jq_l1'。表示这个行业分类下的所有行业都需满足权重限制

    benchmark: 基准指数代码

    limit: 偏离度限制

  • 例子：

    constraint = IndustriesDeviationConstraint(industry_code='HY001', benchmark='000300.XSHG', limit=0.05)

• TrackingErrorConstraint - 追踪误差限制

  TrackingErrorConstraint(benchmark, limit, count=250)

  • 参数：

    benchmark: 基准的 ticker，例如 '000001.XSHE'

    limit: (年化)追踪误差限制

    count: 默认为 250，向前取 returns 的天数

  • 例子：

    constraint = TrackingErrorConstraint(benchmark='000001.XSHE', limit=0.1, count=250)

• TurnoverConstraint - 换手率限制

  TurnoverConstraint(limit, current_portfolio=None)

  • 参数：

    limit: 换手率限制

    current_portfolio: 默认为 None，当前投资组合权重，如果为 None 则认为是空仓

  • 例子：

    constraint = TurnoverConstraint(limit=0.5, current_portfolio=pd.Series([0.1, 0.2, 0.3, 0.4], index=['000001.XSHE', '000002.XSHE', '000004.XSHE', '000005.XSHE']))

• RatioConstraint - 比率限制

  RatioConstraint(ratio, low=None, high=None, rf=None, benchmark=None, count=250)

  • 参数：

    ratio: 比率名称，可选 "sharpe_ratio" / "information_ratio" / "calmar_ratio" / "omega_ratio" / "sortino_ratio" / "var" / "cvar"

    low: 默认为 None，比率的下限，如果为 None 则无下限

    high: 默认为 None，比率的上限，如果为 None 则无上限

    rf: 默认为 None, 无风险利率，适用于 "sharpe_ratio" / "omega_ratio"，如果为 None 则认为是 0

    benchmark: 默认为 None, 基准，适用于 "information_ratio"。如果为 None 则认为是 '000300.XSHG'

    count: 默认为 250，向前取 returns 的天数

  • 例子：

    constraint = RatioConstraint('var', low=-0.03)

    constraint = RatioConstraint('sharpe_ratio', low=1, rf=0.02, count=300)

• MaxDrawdownConstraint(limit, count=250) - 最大回撤限制

  • 参数：

    limit: 最大回撤限制，如 -0.25

    count: 默认为 250，向前取 returns 的天数

  • 例子：

    constraint = MaxDrawdownConstraint(-0.25)

• Bound(low=0.0, high=1.0) - 每只标的的权重限制

  • 参数：

    low: 默认为 0.0，每只标的的权重下限

    high: 默认为 1.0，每只标的的权重上限

  • 示例：

    bound = Bound(low=0.0, high=0.1)

• IndustryBound(industry_code, low=0.0, high=1.0) - 属于某一行业的每只股票的权重限制

  • 参数：

    industry_code: 单一行业代码或者行业代码的列表。

    low: 默认为 0.0，如果一只股票属于所选行业，则股票权重的下限为 low，否则下限为 0

    high: 默认为 1.0，如果一只股票属于所选行业，则股票权重的上限为 high，否则上限为 1

  • 示例：

    bound = IndustryBound(['HY001', 'HY007'], low=0.0, high=0.05)

• LiquidityBound(limit, capital, count=1, subset=None) - 流动性限制

  购买数量不超过成交量的百分比

  • 参数：

    limit: 成交量百分比限制，如 0.5

    capital: 目前可用资金，如 1000000

    count: 前几个交易日的平均成交量，默认为 1

    subset: 股票代码的列表，限制只有特定的股票需要满足流动性限制，如 ['000001.XSHE', '000002.XSHE']，默认为 None，即所有股票都要满足流动性限制

  • 例子：

    bound = LiquidityBound(0.5, capital=1000000)
    
    bound = LiquidityBound(0.25, capital=1000000, count=5, subset=['000001.XSHE', '000002.XSHE'])
    

• CapBound(limit, capital, count=1, subset=None) - 市值限制

  购买金额不超过总市值的百分比

  • 参数：

    limit: 市值百分比限制，如 0.025

    capital: 目前可用资金，如 100000000

    count: 前几个交易日的平均市值，默认为 1

    subset: 股票代码的列表，限制只有特定的股票需要满足市值限制，如 ['000001.XSHE', '000002.XSHE']，默认为 None，即所有股票都要满足市值限制

  • 例子：

    bound = CapBound(0.025, capital=100000000, subset=['000001.XSHE', '000002.XSHE'])

# 导入函数库
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='09:00', reference_security='000300.XSHG')
      # 开盘运行
    run_monthly(market_open, monthday=1, time='09: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) # 调整标的至目标权重

order(security, amount, style=None, side='long', pindex=0, close_today=False)

买卖标的。调用成功后, 您将可以调用[get_open_orders]取得所有未完成的交易, 也可以调用[cancel_order]取消交易

参数

• security: 标的代码
• amount: 交易数量, 正数表示买入, 负数表示卖出
• style: 参见OrderStyle, None代表MarketOrder
• side: 'long'/'short'，操作多单还是空单。默认为多单，股票、基金暂不支持开空单。
• pindex: 在使用set_subportfolios创建了多个仓位时，指定subportfolio 的序号, 从 0 开始, 比如 0 指定第一个 subportfolio, 1 指定第二个 subportfolio，默认为0。
• close_today: 平今字段，close_today: 平今字段，仅对上海国际能源中心，上海期货交易所，中金所生效，其他交易所将会报错（其他交易所没有区分平今与平昨，均按照先开先平的方法处理）。
  • 对上海国际能源中心，上海期货交易所，中金所的标的：
    • close_today = True, 只平今仓，今仓不足的时候，订单将会被废单。
    • close_today = False, 优先平昨仓，昨仓不足部分平今仓
  • 不管close_today是True还是False，此函数只会产生一个订单，区别在于平仓时的手续费计算，平昨仓使用close_commission对应手续费率，平今仓使用close_today_commission手续费率。

返回 Order对象或者None, 如果创建订单成功, 则返回Order对象, 失败则返回None

示例

#买入平安银行股票100股
order('000001.XSHE', 100) # 下一个市价单
order('000001.XSHE', 100, MarketOrderStyle()) # 下一个市价单, 功能同上(科创板市价单需要指定保护价)
order('688001.XSHG', 100, MarketOrderStyle(10)) #科创板设置保护价, 买入时成交价不得高于10元
order('000001.XSHE', 100, LimitOrderStyle(10.0)) # 以10块价格下一个限价单

可能的失败原因:

1. 股票数量经调整后变成0 (请看下面的说明)
2. 股票停牌
3. 股票未上市或者退市
4. 股票不存在
5. 为股票、基金开了空单
6. 选择了不存在的仓位号，如没有建立多个仓位，而设定pindex的数大于0
7. 科创板市价单未指定保护价

注意:

• 因为下列原因, 有时候实际买入或者卖出的股票数量跟您设置的不一样，这个时候我们会在您的log中添加警告信息。

1. 买入时会根据您当前的现金来限制您买入的数量
2. 卖出时会根据您持有股票的数量来限制您卖出的数量
3. 我们会遵守A股交易规则: 每次交易数量只能是100的整数倍, 但是卖光所有股票时不受这个限制(科创板200起可交易200以上的零散股)

• 根据交易所规则, 每天结束时会取消所有未完成交易

order_target(security, amount, style=None, side='long', pindex=0, close_today=False)

买卖标的, 使最终标的的数量达到指定的amount，注意使用此接口下单时若指定的标的有未完成的订单，则先前未完成的订单将会被取消

参数

• security: 标的代码
• amount: 期望的最终数量
• style: 参见OrderStyle, None代表MarketOrder
• side: 'long'/'short'，操作多单还是空单。默认为多单。默认为多单，股票、基金暂不支持开空单。
• pindex: 在使用set_subportfolios创建了多个仓位时，指定subportfolio 的序号, 从 0 开始, 比如 0为 指定第一个 subportfolio, 1 为指定第二个 subportfolio，默认为0。
• close_today: 平今字段，close_today: 平今字段，仅对上海国际能源中心，上海期货交易所，中金所生效，其他交易所将会报错（其他交易所没有区分平今与平昨，均按照先开先平的方法处理）。
  • 对上海国际能源中心，上海期货交易所，中金所的标的：
    • close_today = True, 只平今仓，今仓不足的时候，订单将会被废单。
    • close_today = False, 优先平昨仓，昨仓不足部分平今仓
  • 不管close_today是True还是False，此函数只会产生一个订单，区别在于平仓时的手续费计算，平昨仓使用close_commission对应手续费率，平今仓使用close_today_commission手续费率。

返回 Order对象或者None, 如果创建委托成功, 则返回Order对象, 失败则返回None

示例

# 卖出平安银行所有股票
order_target('000001.XSHE', 0)
# 买入平安银行所有股票到100股
order_target('000001.XSHE', 100)
order_target('688001.XSHG', 100, MarketOrderStyle(10)) #科创板设置保护价, 买入时成交价不得高于10

order_value(security, value, style=None, side='long', pindex=0, close_today=False)

买卖价值为value的标的。

参数

• security: 股票名字

• value: 股票价值，value = 最新价 * 手数 * 保证金率（股票为1） * 乘数（股票为100）

• style: 参见OrderStyle, None代表MarketOrder

• side: 'long'/'short'，操作多单还是空单。默认为多单。默认为多单，股票、基金暂不支持开空单。

• pindex: 在使用set_subportfolios创建了多个仓位时，指定subportfolio 的序号, 从 0 开始, 比如 0为 指定第一个 subportfolio, 1 为指定第二个 subportfolio，默认为0。

• close_today: 平今字段，close_today: 平今字段，仅对上海国际能源中心，上海期货交易所，中金所生效，其他交易所将会报错（其他交易所没有区分平今与平昨，均按照先开先平的方法处理）。

  • 对上海国际能源中心，上海期货交易所，中金所的标的：
    • close_today = True, 只平今仓，今仓不足的时候，订单将会被废单。
    • close_today = False, 优先平昨仓，昨仓不足部分平今仓
  • 不管close_today是True还是False，此函数只会产生一个订单，区别在于平仓时的手续费计算，平昨仓使用close_commission对应手续费率，平今仓使用close_today_commission手续费率。

返回 Order对象或者None, 如果创建委托成功, 则返回Order对象, 失败则返回None

示例

#卖出价值为10000元的平安银行股票
order_value('000001.XSHE', -10000)
#买入价值为10000元的平安银行股票
order_value('000001.XSHE', 10000)
order_value('688001.XSHG', 100, MarketOrderStyle(10)) #科创板设置保护价, 买入时成交价不得高于10元

order_target_value(security, value, style=None, side='long', pindex=0, close_today=False)

调整标的仓位到value价值，注意使用此接口下单时若指定的标的有未完成的订单，则先前未完成的订单将会被取消

参数

• security: 标的名字
• value: 期望的标的最终价值，value = 最新价 * 手数 * 保证金率（股票为1） * 乘数（股票为100）
• style: 参见OrderStyle, None代表MarketOrder
• side: 'long'/'short'，操作多单还是空单。默认为多单。
• pindex: 在使用set_subportfolios创建了多个仓位时，指定subportfolio 的序号, 从 0 开始, 比如 0为 指定第一个 subportfolio, 1 为指定第二个 subportfolio，默认为0。
• close_today: 平今字段，close_today: 平今字段，仅对上海国际能源中心，上海期货交易所，中金所生效，其他交易所将会报错（其他交易所没有区分平今与平昨，均按照先开先平的方法处理）。
  • 对上海国际能源中心，上海期货交易所，中金所的标的：
    • close_today = True, 只平今仓，今仓不足的时候，订单将会被废单。
    • close_today = False, 优先平昨仓，昨仓不足部分平今仓
  • 不管close_today是True还是False，此函数只会产生一个订单，区别在于平仓时的手续费计算，平昨仓使用close_commission对应手续费率，平今仓使用close_today_commission手续费率。

返回 Order对象或者None, 如果创建委托成功, 则返回Order对象, 失败则返回None

示例

#卖出平安银行所有股票
order_target_value('000001.XSHE', 0)
#调整平安银行股票仓位到10000元价值
order_target_value('000001.XSHE', 10000)
order_target_value('688001.XSHG', 100, MarketOrderStyle(10)) #科创板设置保护价, 买入时成交价不得高于10元

cancel_order(order)

取消订单

参数

• order: [Order]对象或者order_id

返回 Order对象或者None, 如果取消委托成功, 则返回Order对象, 委托不存在返回None

示例

#每个交易日结束运行
def after_trading_end(context):
    # 得到当前未完成订单
    orders = get_open_orders()
    # 循环，撤销订单
    for _order in orders.values():
        cancel_order(_order)

get_open_orders()

获得当天的所有未完成的订单

参数 无

返回 返回一个dict, key是order_id, value是[Order]对象

示例

#每个交易日结束运行
def after_trading_end(context):
    #得到当前未完成订单
    orders = get_open_orders()
    for _order in orders.values():
        log.info(_order.order_id)

get_orders(order_id=None, security=None, status=None)

获取当天的所有订单

参数

• order_id: 订单 id
• security: 标的代码，可以用来查询指定标的的所有订单
• status: [OrderStatus]， 查询特定订单状态的所有订单

返回 返回一个dict, key是order_id, value是[Order]对象

示例

#每个交易日结束运行
def after_trading_end(context):
    #得到当天所有订单
    orders = get_orders()
    for _order in orders.values():
        log.info(_order.order_id)

    # 根据订单id查询订单
    get_orders(order_id='1517627499')   

    # 查询所有标的为 000002.XSHE 的订单
    get_orders(security='000002.XSHE')  

    # 查询订单状态为 OrderStatus.held 的所有订单
    get_orders(status=OrderStatus.held)

    # 查询标的为 000002.XSHE 且状态为 OrderStatus.held 的所有订单
    get_orders(security='000002.XSHE', status=OrderStatus.held)

get_trades()

获取当天的所有成交记录, 一个订单可能分多次成交

参数 无

返回 返回一个dict, key是trade_id, value是[Trade]对象

示例

#每个交易日结束运行
def after_trading_end(context):
    #得到当天所有成交记录
    trades = get_trades()
    for _trade in trades.values():
        log.info(_trade.trade_id)

inout_cash(cash, pindex=0)

账户转入或转出资金，当日的出入金从当日开始记入成本，用于计算收益，即当日结束计算收益时的本金是包含当日出入金金额的；

参数

• cash： 可正可负，正为入金，负为出金。
• pindex： 在使用set_subportfolios创建了多个仓位时，指定subportfolio 的序号, 从 0 开始, 比如 0为 指定第一个 subportfolio, 1 为指定第二个 subportfolio，默认为0。

示例

# 查看账户可用资金
log.info('账户可用资金：',context.portfolio.subportfolios[0].available_cash)
# 增加资金：6666
inout_cash(6666, pindex=0)
# 查看增加资金之后账户的可用资金
log.info('账户可用资金：',context.portfolio.subportfolios[0].available_cash)

batch_submit_orders(orders)

对一系列标的进行批量委托，委托时会对每一个委托进行验资验券，若其中任一个委托校验失败，则整个委托将会失败

参数

orders: 一个list，元素是包含订单信息的dict

[{
'security': 'xxxx',
'amount': 'xxxx',     # amount > 0 为买入，< 0 为卖出
'style': xxxx,  # 同 order()的style参数, 可选, 默认是 None
 'side': 'long', # 默认是'long'
},
 ...
]

• security: 标的代码
• amount: 交易数量, 正数表示买入, 负数表示卖出
• style: 参见[order styles], None代表MarketOrder
• side: 'long'/'short'，操作多单还是空单。默认为多单，股票、基金暂不支持开空单。
• pindex: 在使用set_subportfolios创建了多个仓位时，指定subportfolio 的序号, 从 0 开始, 比如 0 指定第一个 subportfolio, 1 指定第二个 subportfolio，默认为0。
• close_today: 平今字段。
  • 对上海国际能源中心，上海期货交易所，中金所的标的：
    • close_today = True, 只平今仓
    • close_today = False, 优先平昨仓，昨仓不足部分平今仓
  • 对其他交易所标的：
    • close_today = True, 优先平今，超出则平昨仓
    • close_today = False, 优先平昨，超出则平今仓

返回 一个包含Order对象的list

示例

#买入平安银行和福耀玻璃各股票100股
orders=[{
        "security":"000001.XSHE",
        "amount":100,
        "pindex":0},
{
        "security":"600660.XSHG",
        "amount":100,
        "pindex":0},
]

batch_submit_orders(orders)

batch_cancel_orders(orders)

批量撤单

参数

• orders：列表，包含订单对象或订单ID。

全局对象 g，用来存储用户的各类可被pickle.dumps函数序列化的全局数据

在模拟盘中，进程每天都会重启，我们会使用[pickle.dumps]序列化所有的g下面的变量内容, 保存到磁盘中，再启动的时候模拟盘就不会有任何数据影响。如果没有用g声明，会出现模拟盘重启后，变量数据丢失的问题。

如果不想 g 中的某个变量被序列化, 可以让变量以 '__' 开头, 这样, 这个变量在序列化时就会被忽略
注意保存的大小有限制,上限30M,超出后将报错
注意避免对context及其下属的order/trade/position等对象进行持久化保存，因为账户信息是可变的,这种操作可能导致异常
注意尽量不要将全局变量的声明/初始化放在函数体外, 否则每次进程重启时都会被执行

更多模拟盘细节, 请看 模拟盘注意事项.

def initialize(context):
    g.security = "000001.XSHE"
    g.count = 1
    g.flag = 0

def process_initialize(context):
    # 保存不能被序列化的对象, 进程每次重启都初始化, 更多信息, 请看 [process_initialize]
    g.__q = query(valuation)

def handle_data(context, data):
    log.info(g.security)
    log.info(g.count)
    log.info(g.flag)

• subportfolios: 当前单个操作仓位的资金、标的信息，是一个SubPortfolio 的数组

• portfolio: 账户信息，即subportfolios 的汇总信息, Portfolio对象，单个操作仓位时，portfolio 指向 subportfolios[0]

• current_dt: 当前单位时间的开始时间, [datetime.datetime]对象

• previous_date: 前一个交易日, [datetime.date]对象, 注意, 这是一个日期, 是 date, 而不是 datetime

• universe: 查询set_universe()设定的股票池, 比如: ['000001.XSHE', '600000.XSHG']

• run_params: 表示此次运行的参数, 有如下属性

  • start_date: 回测/模拟开始日期, [datetime.date]对象
  • end_date: 回测/模拟结束日期, [datetime.date]对象
  • type: 运行方式, 如下四个字符串之一
    'simple_backtest': 回测, 通过点击'编译运行'运行
    'full_backtest': 回测, 通过点击'运行回测'运行
    'sim_trade': 模拟交易
  • frequency: 运行频率, 如下三个字符串之一
    'day'
    'minute'
    'tick'

• 为了让从其他平台迁移过来的同学更顺手的使用系统, 我们对此对象也做了和 [g] 一样的处理:

  • 可以添加自己的变量, 每次进程关闭时持久保存, 进程重启时恢复.
  • 以 '__' 开头的变量不会被持久保存
  • 如果添加的变量与系统的冲突, 将覆盖掉系统变量, 如果想恢复系统变量, 请删除自己的变量. 示例:

  def handle_data(context, data):
      # 执行下面的语句之后, context.portfolio 的整数 1
      context.portfolio = 1
      log.info(context.portfolio)
      # 要恢复系统的变量, 只需要使用下面的语句即可
      del context.portfolio
      # 此时, context.portfolio 将变成账户信息.
      log.info(context.portfolio.total_value)
  

• 我们以后可能会往 context 添加新的变量来支持更多功能, 为了减少不必要的迷惑, 还是建议大家使用 g

• context对象综述及获取方法

示例

def handle_data(context, data):

    #获得当前回测相关时间
    year = context.current_dt.year
    month = context.current_dt.month
    day = context.current_dt.day
    hour = context.current_dt.hour
    minute = context.current_dt.minute
    second = context.current_dt.second
    #得到"年-月-日"格式
    date = context.current_dt.strftime("%Y-%m-%d")
    #得到周几
    weekday = context.current_dt.isoweekday()

    # 获取总账户的持仓价值
    positions_value = context.portfolio.positions_value

    # 总权益的累计收益
    returns = context.portfolio.returns

    # 获取仓位subportfolios[0]的可用资金
    available_cash = context.subportfolios[0].available_cash

    # 获取subportfolios[0]中多头仓位的security的持仓成本
    hold_cost = context.subportfolios[0].long_positions[security].hold_cost

    # 这是一个dict,键是标的代码,值是对应的position对象
    long_positions_dict  = context.subportfolios[0].long_positions    
    for position in list(long_positions_dict.values()):  
        print("标的:{0},总仓位:{1},标的价值:{2}".format(position.security,position.total_amount,position.value))

  某个仓位的资金，标的信息，如未使用 SubPortfolioConfig 设置多仓位，默认只有subportfolios[0]一个仓位，Portfolio 指向该仓位。

• inout_cash: 累计出入金, 比如初始资金 1000, 后来转移出去 100, 则这个值是 1000 - 100
• available_cash: 可用资金, 可用来购买证券的资金
• transferable_cash: 可取资金, 即可以提现的资金, 不包括今日卖出证券所得资金
• locked_cash: 挂单锁住资金
• type: 账户所属类型
• long_positions: 多单的仓位, 一个 dict, key 是标的代码, value 是 [Position]对象
• short_positions: 空单的仓位, 一个 dict, key 是标的代码, value 是 [Position]对象
• positions_value: 持仓价值
• total_value: 总资产, 包括现金, 保证金(期货)或者仓位(股票)的总价值, 可用来计算收益
• total_liability: 总负债, 等于融资负债、融券负债、利息总负债的总和
• net_value: 净资产, 等于总资产减去总负债
• cash_liability: 融资负债
• sec_liability: 融券负债
• interest: 利息总负债
• maintenance_margin_rate: 维持担保比例
• available_margin: 融资融券可用保证金
• margin: 保证金，股票、基金保证金都为100%；融资融券保证金为0；期货保证金会实时更新, 总是等于当前期货价值 乘以 保证金比率, 当保证金不足时, 强制平仓. 平仓顺序是: 亏损多的(相对于开仓均价)先平仓

print("累计出入金:{0}".format(context.subportfolios[0].inout_cash))
print("可用资金:{0}".format(context.subportfolios[0].available_cash))
print("可取资金:{0}".format(context.subportfolios[0].transferable_cash))
print("挂单锁住资金:{0}".format(context.subportfolios[0].locked_cash))
print("账户所属类型:{0}".format(context.subportfolios[0].type))
# 这是一个dict,键是标的代码,值是对应的position对象
long_positions_dict  = context.subportfolios[0].long_positions    
for position in list(long_positions_dict.values()):  
    print("    标的:{0},总仓位:{1},标的价值:{2}".format(position.security,position.total_amount,position.value))
print("持仓价值:{0}".format(context.subportfolios[0].positions_value))
print("总资产:{0}".format(context.subportfolios[0].total_value))

账户当前的资金，标的信息，即所有标的操作仓位的信息汇总。如未使用 SubPortfolioConfig 设置多仓位，默认只有subportfolios[0]一个仓位，Portfolio 指向该仓位。注意区分多仓和空仓。

• inout_cash: 累计出入金, 比如初始资金 1000, 后来转移出去 100, 则这个值是 1000 - 100
• available_cash: 可用资金, 可用来购买证券的资金
• transferable_cash: 可取资金, 即可以提现的资金, 不包括今日卖出证券所得资金
• locked_cash: 挂单锁住资金
• margin: 保证金，股票、基金保证金都为100%
• positions: 等同于 long_positions
• long_positions: 多单的仓位, 一个 dict, key 是证券代码, value 是 [Position]对象
• short_positions: 空单的仓位, 一个 dict, key 是证券代码, value 是 [Position]对象
• total_value: 总的权益, 包括现金, 保证金(期货)或者仓位(股票)的总价值, 可用来计算收益
• returns: 前一日总权益的累计收益；（前一交易日total_value / inout_cash) ；
• starting_cash: 初始资金, 现在等于 inout_cash
• positions_value: 持仓价值
• cash: 已过时，等价于 available_cash
• portfolio_value: 已过时，等价于 total_value
• unsell_positions: 已过时, 请使用 positions 代替, 当前持有的不可以卖出的持仓(比如在A股T+1市场, 今天购票的股票), 并没有考虑股票今天是否停牌, 一个dict, key是股票代码, value是[Position]对象.

print("多单的仓位:{0}".format(context.portfolio.long_positions)) 
print("空单的仓位:{0}".format(context.portfolio.short_positions))
print("总权益:{0}".format(context.portfolio.total_value))
print("总权益的累计收益:{0}".format(context.portfolio.returns))
print("初始资金:{0}".format(context.portfolio.starting_cash))
print("持仓价值:{0}".format(context.portfolio.positions_value))

持有的某个标的的信息,注意区分多仓和空仓

• security: 标的代码
• price: 最新行情价格
• acc_avg_cost 是累计的持仓成本，在清仓/减仓时也会更新，该持仓累积的收益都会用于计算成本（一开始acc_avg_cost为0，amount也为0），加仓：new_acc_avg_cost = (acc_avg_cost * amount + trade_value + commission) / (amount + trade_amount)；减仓：new_acc_avg_cost = (acc_avg_cost * amount - trade_value + commission) / (amount - trade_amount) 说明：commission是本次买入或者卖出的手续费
• avg_cost 是当前持仓成本，只有在开仓/加仓时会更新： new_avg_cost = (position_value + trade_value + commission) / (position_amount + trade_amount)
  每次买入后会调整avg_cost, 卖出时avg_cost不变. 这个值也会被用来计算浮动盈亏.
• hold_cost: 当日持仓成本，计算方法：当日无收益：hold_cost = 前收价 （清算后），加仓：hold_cost = (hold_cost * amount + trade_value)/(amount + trade_amount)，减仓：hold_cost = (hold_cost * amount - trade_value)/(amount - trade_amount)；trade_value = trade_price * trade_amount
• init_time: 建仓时间，格式为 datetime.datetime
• transact_time: 最后交易时间，格式为 datetime.datetime
• locked_amount: 挂单冻结仓位
• total_amount: 总仓位, 但不包括挂单冻结仓位( 如果要获取当前持仓的仓位,需要将locked_amount和total_amount相加)
• closeable_amount: 可卖出的仓位
• today_amount: 今天开的仓位
• value: 标的价值，计算方法是: price * total_amount * multiplier, 其中股票、基金的multiplier为1，期货为相应的合约乘数
• side: 多/空，'long' or 'short'
• pindex: 仓位索引，subportfolio index
• sellable_amount: 已过时, 为了向前兼容, 等同于 closeable_amount
• amount: 已过时, 为了向前兼容, 等同于 closeable_amount

  print(type(context.portfolio.long_positions))
  long_positions_dict = context.portfolio.long_positions
  for position in list(long_positions_dict.values()):  
      print("标的:{0},总仓位:{1},标的价值:{2}, 建仓时间:{3}".format(position.security, position.total_amount, position.value, position.init_time))
  print(type(context.subportfolios[0].short_positions))
  short_positions_dict = context.portfolio.short_positions
  for position in list(short_positions_dict.values()):  
      print("标的:{0},总仓位:{1},标的价值:{2}, 建仓时间:{3}".format(position.security, position.total_amount, position.value, position.init_time))
  

一个单位时间内的股票的数据

为了向前兼容，保留data对象，由于效率问题不推荐使用

基本属性

以下属性也能通过history/attribute_history/get_price获取到

• open: 时间段开始时价格(当天天级别的开盘价至少需要09:27分之后才可获取)
• close: 时间段结束时价格
• low: 时间段中的最低价
• high: 时间段中的最高价
• volume: 时间段中的成交的股票数量
• money: 时间段中的成交的金额
• factor: 前复权因子, 我们提供的价格都是前复权后的, 但是利用这个值可以算出原始价格, 方法是价格除以factor, 比如: close/factor
• high_limit: 时间段中的涨停价
• low_limit: 时间段中的跌停价
• avg: 这段时间的平均价。计算方法（1）天级别：股票是成交额除以成交量；期货是直接从CTP行情获取的，计算方法为成交额除以成交量再除以合约乘数；（2）分钟级别：用该分钟所有tick的现价乘以该tick的成交量加起来之后，再除以该分钟的成交量。
• price: 已经过时, 为了向前兼容, 等同于 avg
• pre_close: 前一个单位时间结束时的价格, 按天则是前一天的收盘价（期货中pre_close是前前一天结算价，建议使用get_extras获取结算价）, 注意：在分钟频率下pre_close=open；
• paused: bool值, 这只股票是否停牌, 停牌时open/close/low/high/pre_close依然有值,都等于停牌前的收盘价, volume=money=0

额外的属性和方法

• security: 股票代码, 比如'000001.XSHE'
• returns: 股票在这个单位时间的相对收益比例, 等于 (close-pre_close)/pre_close
• isnan(): 数据是否有效, 当股票未上市或者退市时, 无数据, isnan()返回True
• mavg(days, field='close'): 过去days天的每天收盘价的平均值, 把field设成'avg'(等同于已过时的'price')则为每天均价的平均价, 下同
• vwap(days): 过去days天的每天均价的加权平均值, 以days=2为例子, 算法是:

  (avg1 * volume1 + avg2 * volume2) / (volume1 + volume2)
  

• stddev(days): 过去days天的每天收盘价的标准差
• 注：mavg/vwap/stddev:都会跳过停牌日期, 如果历史交易天数不足, 则返回nan

一个 tick 所包含的信息。 tick 中的信息是在 tick 事件发生时， 盘面的一个快照。

• code: 标的的代码
• datetime: tick 发生的时间
• current: 最新价
• open：当日开盘价
• high: 截至到当前时刻的最高价
• low: 截至到当前时刻的最低价
• volume: 截至到当前时刻的成交量
• money: 截至到当前时刻的成交额
• position: 截至到当前时刻的持仓量，只适用于期货 tick 对象
• a1_v ~ a5_v: 卖一量到卖五量，对于期货，只有卖一量
• a1_p ~ a5_p: 卖一价到卖五价，对于期货，只有卖一价
• b1_v ~ b5_v: 买一量到买五量，对于期货，只有买一量
• b1_p ~ b5_p: 买一价到买五价，对于期货，只有买一价

订单的一次交易记录,一个订单可能分多次交易
关于order/trader对象及订单处理

• time: 交易时间, [datetime.datetime]对象
• security：标的代码
• amount: 交易数量
• price: 交易价格
• trade_id: 交易记录id
• order_id: 对应的订单id

trades = get_trades()
for _trade in trades.values():
    print('成交记录：'+str(_trade))
    print('交易时间：{0}'.format(_trade.time))
    print('对应的订单id：{0}'.format(_trade.order_id))

买卖订单
关于order/trader对象及订单处理
以csv格式保存order、trade、position数据

• status: 状态, 一个OrderStatus值
• add_time: 订单添加时间, [datetime.datetime]对象
• is_buy: bool值, 买还是卖，对于期货:
  开多/平空 -> 买
  开空/平多 -> 卖
• amount: 下单数量, 不管是买还是卖, 都是正数
• filled: 已经成交的股票数量, 正数
• security: 股票代码
• order_id: 订单ID
• price: 平均成交价格, 已经成交的股票的平均成交价格(一个订单可能分多次成交)
• avg_cost: 卖出时表示下卖单前的此股票的持仓成本, 用来计算此次卖出的收益. 买入时表示此次买入的均价(等同于price).
• side: 多/空，'long'/'short'
• action: 开/平， 'open'/'close'
• commission：交易费用（佣金、税费等）

orders = order('000001.XSHE', 100)
print(orders)
if orders is None:
    print("创建订单失败...")
else:
    print("交易费用单：{0}".format(orders.commission))
    print("是否买单：{0}".format(orders.is_buy))
    print("订单状态：{0}".format(orders.status))
    print("订单平均成交价格：{0}".format(orders.price))

注意

• 不可以在策略中保存当天的订单信息到下一个或者之后的交易日使用；

订单状态, Enum特性使用的第三方库(https://pypi.python.org/pypi/enum34)
获取订单状态的方法请参考上面Order对象

class OrderStatus(Enum):
    # 订单新创建未委托，用于盘前/隔夜单，订单在开盘时变为 open 状态开始撮合
    new = 8

    # 订单未完成, 无任何成交
    open = 0

    # 订单未完成, 部分成交
    filled = 1

    # 订单完成, 已撤销, 可能有成交, 需要看 Order.filled 字段
    canceled = 2

    # 订单完成, 交易所已拒绝, 可能有成交, 需要看 Order.filled 字段
    rejected = 3

    # 订单完成, 全部成交, Order.filled 等于 Order.amount
    held = 4

注意
订单状态数据类型为Enum，判断时可以转为字符串，示例代码如下：

def initialize(context):
    run_daily(market_open, time='every_bar')

def market_open(context):
    orders = order('000001.XSHE', 100)
    print(orders)
    # 如果创建订单成功, 则返回Order对象, 失败则返回None
    if orders is None:
        print("创建订单成功失败...")
    else:
        print(orders.is_buy)
        print(orders.price)
        print(orders.status)
        # 注意返回的status数据类型为，enum 'OrderStatus'
        print(type(orders.status))
        # 判断订单的状态是否指定的状态，需要先转换为str类型
        print(str(orders.status) == 'open')
        print(str(orders.status) == 'held')
    print('='*50)

具体订单处理方法请查看订单处理>>>
下单方式, 有如下子类

• 市价单

class MarketOrderStyle(OrderStyle):
   def __init__(self, limit_price=None):
        self.limit_price = limit_price

市价单示例

参数：

• limit_price：科创板市价单的保护价，对非科创板标的无效。

 # 在仓位0，以市价单买入平安银行股票100股
order('000001.XSHE', 100) 
# 在仓位0，以市价单买入平安银行股票100股G
order('000001.XSHE', 100, MarketOrderStyle()) 
# 在仓位0中开一手沪深300指数期货的多单
order('IF1412.CCFX', 1 , side='long', pindex=0)
# 在仓位0，以市价单买入科创板天准科技股票200股，保护价为200
order('688003.XSHG', 200, MarketOrderStyle(200))

科创板保护价逻辑：
市价买入时成交的最高价格不高于本价格，若最优一档的价格高于该价格，剩余未成交部分撤单；
市价卖出时成交的最低价格不低于本价格，若最优一档的价格低于该价格，剩余未成交部分撤单；

• 限价单

class LimitOrderStyle(OrderStyle):
    def __init__(self, limit_price):
        self.limit_price = limit_price

限价单示例

# 以10块价格下一个限价单
order('000001.XSHE', 100, LimitOrderStyle(10.0)) 
# 在仓位1中以3600的限价单，平一手沪深300指数期货的空单
order('IF1412.CCFX', -1 , LimitOrderStyle(3600.0), side='short', pindex=1)

• 停止单 StopMarketOrderStyle(mode, stop_price) StopLimitOrderStyle(mode, stop_price, limit_price)

使用方法： 在order/order_target/order_value/order_target_value函数中指定委托类型为停止单。停止单会在标的价格突破（向上或向下）时转化为对应的市价单或限价单

参数 mode："stop_loss", "take_profit"，指定该停止单是止盈模式还是止损模式，具体解释见下文 stop_price：停止单被触发的价格，当价格突破（向上或向下）时将停止单转为对应种类（市价单/限价单）的订单 limit_price：限价，同限价单

止盈模式与止损模式 若为止损单模式，平空、做多或买入时触发价必须大于最新价，平多、做空或卖出时触发价必须小于最新价； 若为止盈单模式，平多、做空或卖出时触发价必须大于最新价，平空、做多或买入时触发价必须小于最新价； 若触发价不满足条件，该停止单会立即触发

备注

• 停止单不会提前锁定持仓和资金，触发时不满足委托条件（如资金不足或可交易数量不足）直接委托失败
• 订单生效的时间仅限于标的交易时间，当天未完成的停止单盘后撤销
• order_value/order_target_value使用停止单进行委托时，由value计算实际委托数量的规则：
  • 实际委托数量 = value / 价格 / 保证金率 / 乘数
  • StopMarketOrderStyle以stop_price计算实际委托数量
  • StopLimitOrderStyle以limit_price计算实际委托数量

DividendsEvent - 分红送股事件

属性

• name：事件的名称，这里为Dividends
• pindex：子账户索引
• security：标的代码
• side：仓位方向，long/short
• dividends：分红配送信息，一个字典列表，直接从数据中获取，通常只有一个元素。例如，税前分红可以用dividends[0]['bonus_pre_tax']表示，所有可能的key如下：
  • date：发生分红送股的日期
  • scale_factor：配送股比例（股票，场内基金）
  • bonus_pre_tax：税前分红（股票，场内基金）
  • bonus_post_tax：税后分红（场内基金）

ForcedLiquidationEvent：强行平仓事件

属性

• name：事件的名称，这里为ForcedLiquidation
• pindex：子账户索引
• security：标的
• side：仓位方向，long/short
• amount：平仓数量

record(**kwargs)

回测环境/模拟专用API

如调用该函数，需要从回测开始时调用，不支持在回测周期中间时段调用

我们会帮您在图表上画出收益曲线和基准的收益曲线，您也可以调用record函数来描画额外的曲线。 因为我们是按天展现的，如果您使用按分钟回测，我们画出的点是您最后一次调用record的值（不是每分钟的）。 以16:00为界限，16:00之后绘制的属于第二天。

参数 一个或多个key=value形式的参数，key为曲线名称，value为值（不能是列表）

返回 None

示例

# 初始化函数，设定基准等等
def initialize(context):
    # 开启动态复权模式(真实价格)
    set_option('use_real_price', True)
    # 设置日志级别为info
    log.set_level('order', 'info')

def handle_data(context, data):
    d = data['000001.XSHE']
    # d是一个SecurityUnitData结构体，会画出每个单元时间(天或分钟)的平均价,开始价,结束价
    record(price=d.price, open=d.open, close=d.close)
    # 也可以画一条值为100的直线
    record(price=100)

send_message(message, channel='weixin')

聚宽官网实时运行模拟交易专用API

给用户自己发送消息, 暂时只支持微信消息.

参数 message: 消息内容. 字符串. channel: 消息渠道, 暂时只支持微信: weixin. 默认值是 weixin

返回值 True/False, 表示是否发送成功. 当发送失败时, 会在日志中显示错误信息.

注意

• 要使用模拟交易发送微信功能, 必须绑定及开启微信通知；
• 此功能只能在 聚宽官网的实时运行模拟交易 中使用, 回测中使用会直接忽略, 无任何提示；有关实时和延时运行
• 请注意区分自定义消息和下单通知，send_message对应的是自定义微信消息，下单通知是模拟交易策略有下单时（交易详情页面有下单记录）同时发送微信消息；
• 自定义消息只要绑定了微信，都会发送；下单信息只有开启具体模拟交易的微信通知开关，此策略才发送微信消息；
• 下单通知：每个账号每天最多60条；自定义消息每个账号每天最多 5 条, 超出会发送失败，需要更多条数可以使用积分兑换
• 自定义消息长度不得超过 200 个字符, 也不能包含回车和换行这些特殊字符，否则会发送失败
• 一个账号模拟交易只能被一个用户绑定，多个微信绑定后，前面失效，以最后一个绑定的微信号为准

示例

send_message("测试消息")

log.error(content)
log.warn(content)
log.info(content)
log.debug(content)
print(content1, content2, ...)

分级别打log,跟python的logging模块一致 print输出的结果等同于log.info, 但是print后面的每一个元素会占用一行

参数 参数可以是字符串、对象等

返回 None

示例

log.info(history(10)) # 打印出 history(10)返回的结果
log.info("Selling %s, amount=%s", security, amount) # 打印出一个格式化后的字符串
print(history(10), data, context.portfolio)

设定log级别：log.set_level

log.set_level(name, level)

设置不同种类的log的级别, 低于这个级别的log不会输出. 所有log的默认级别是debug，为了降低排查问题的难度，建议日志级别保持为默认级别(不设置日志级别，或者设置log.set_level('order', 'info'))。

参数 name: 字符串, log种类, 必须是'order', 'history', 'strategy'中的一个, 含义分别是:

• order: 调用order系列API产生的log
• history: 调用history系列API(history/attribute_history/get_price)产生的log
• strategy: 您自己在策略代码中打的log
• system：系统日志，除以上三类之外的日志

level: 字符串, 必须是'debug', 'info', 'warning', 'error'中的一个, 级别: debug < info < warning < error

返回 None

示例

# 设置日志级别为debug
log.set_level('order', 'debug')

**注意**  
 - 尽量设置日志级别为debug，或者不设置（使用系统默认级别），有利于您快速的发现问题；
 - 模拟交易中，需要修改日志级别，可以在after_code_changed中，重新设置日志级别。

write_file(path, content, append=False)

将回测或者模拟交易的数据写入投资研究path文件, 写入后, 您可以立即在研究模块中看到这个文件,默认在投资研究的根目录
在回测及模拟交易中读取/写入研究中不同格式的文件

参数

• path: 相对路径, 相对于您的私有空间的根目录的路径
• content: 文件内容, str或者unicode, 如果是unicode, 则会使用UTF-8编码再存储.可以是二进制内容.
• append: 是否是追加模式, 当为False会清除原有文件内容，默认为False.

返回 None 如果写入失败(一般是因为路径不合法), 会抛出异常

示例

write_file("test.txt", "hello world")

# 写入沪深300的股票到HS300.stocks.json文件中
import json
write_file('HS300.stocks.json', json.dumps(get_index_stocks('000300.XSHG')))

# 把 DataFrame 表保存到文件
df = attribute_history('000001.XSHE', 5, '1d') #获取DataFrame表
write_file('df.csv', df.to_csv(), append=False) #写到文件中

## 详细用法可以参考文档：https://www.joinquant.com/post/580 以及 https://www.joinquant.com/view/community/detail/a9f7577b37265f78ffc2c6bb2467d47e?type=1

read_file(path)

在回测及模拟交易中读取你的私有文件(您的私有文件可以在研究模块中看到)
在回测及模拟交易中读取/写入研究中不同格式的文件

参数 path: 相对路径, 相对于您的私有空间的根目录的路径

返回 返回文件的原始内容, 不做任何decode.

示例

#解析json文件
import json
content = read_file('HS300.stocks.json')
securities = json.loads(content)
log.info(securities)

#解析csv文件（python2环境）
import pandas as pd
from six import StringIO
body=read_file("open.csv")
data=pd.read_csv(StringIO(body))

#解析csv文件（python3环境）
import pandas as pd
from six import BytesIO
body=read_file("open.csv")
data=pd.read_csv(BytesIO(body))

## 详细用法可以参考文档：https://www.joinquant.com/post/580

注意

• 不能在官网的回测及模拟中读取您本地的文件，本地文件需要上传到官网的投资研究中；
• 支持读取csv, excel, json等格式文件，具体教程参考在回测及模拟交易中读取研究中不同格式的文件；
• 注意区分Python2和Python3，

您可以在把.py文件放在'研究'的根目录, 然后在回测中就可以通过import的方式来引用此文件. 比如

研究根目录/mylib.py:

#-*- coding: utf-8 -*-
# 如果你的文件包含中文, 请在文件的第一行使用上面的语句指定你的文件编码

# 用到策略及数据相关API请加入下面的语句(如果要兼容研究使用可以使用 try except导入 
from kuanke.user_space_api import *

my_stocks = get_index_stocks('000300.XSHG')

在策略代码中:

# 导入自己创建的库
from mylib import *

def initialize(context):
    log.info(my_stocks)

注意

• 此方法主要用来读取研究根目录中的.py文件，读取其他格式的文件请参考read_file;
• 暂时只能import研究根目录下的.py文件, 还不能import子目录下的文件(比如通过 import a.b.c 来引用a/b/c.py)

create_backtest(algorithm_id, start_date, end_date, frequency="day", initial_cash=10000, initial_positions=None, extras=None, name=None, code="", benchmark=None, python_version=2, use_credit=False)

通过一个策略ID从研究中创建回测，只能在研究中使用，目前不支持在回测及模拟交易中使用；

参数：

• algorithm_id: 策略ID，从策略编辑页的 url 中获取, 比如 '/algorithm/index/edit?algorithmId=xxxx'，则策略ID为: xxxx。如下图所示：
  
• start_date: 回测开始日期
• end_date: 回测结束日期
• frequency: 数据频率，支持 day, minute, tick
• initial_cash: 初始资金
• extras: 额外参数，一个 dict， 用于设置全局的 g 变量，如 extras={'x':1, 'y':2}，则回测中 g.x = 1, g.y = 2，需要注意的是，该参数的值是在 initialize 函数执行之后才设置给 g 变量的，所以这会覆盖掉 initialize 函数中 g 变量同名属性的值
• name: 回测名, 用于指定回测名称, 如果没有指定则默认采用策略名作为回测名
• initial_positions: 初始持仓。持仓会根据价格换成现金加到初始资金中，如果没有给定价格则默认获取股票最近的价格。格式如下:

initial_positions = [
    {
        'security':'000001.XSHE',
        'amount':'100',
    },
    {
        'security':'000063.XSHE',
        'amount':'100',
        'avg_cost': '1.0'
    },
]

• code：策略代码。现在支持从研究中传入策略代码进行回测。指定之后将使用传入的代码来创建回测。
• benchmark: 为回测设置基准。默认为None，表示使用策略中原有set_benchmark设置的基准。若不为None，则表示使用当前传入的基准覆盖原策略的基准。benchmark支持的基准同set_benchmark
• python_version: 创建回测的python的版本，已废弃参数,目前只支持python3内核
• use_credit:是否允许消耗积分新建回测。当每个自然日内编译运行、回测超过免费时间时，继续运行每30分钟需消耗2积分。默认为False，表示不允许消耗积分新建回测，设为True表示接受消耗积分新建回测。需注意，对于已经在运行中的回测，此配置不生效。

返回：

一个字符串, 即 backtest_id

示例一：

algorithm_id = "xxxx"
extra_vars = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
initial_positions = [
    {
        'security':'000001.XSHE',
        'amount':'100',
    },
    {
        'security':'000063.XSHE',
        'amount':'100',
        'avg_cost': '1.0'
    },
]

params = {
    "algorithm_id": algorithm_id,
    "start_date": "2015-10-01",
    "end_date": "2016-07-31",
    "frequency": "day",
    "initial_cash": "1000000",
    "initial_positions": initial_positions,
    "extras": extra_vars,
}

created_bt_id = create_backtest(**params)
print(created_bt_id)

示例二，在研究中指定回测用策略代码：

code = """
# 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
    # 设定沪深300作为基准
    set_benchmark('000300.XSHG')
    # 开启动态复权模式(真实价格)
    set_option('use_real_price', True)
    # 输出内容到日志 log.info()
    log.info('初始函数开始运行且全局只运行一次')
    # 过滤掉order系列API产生的比info级别低的log
    # log.set_level('order', 'info')

    ### 股票相关设定 ###
    # 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣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='09:00', reference_security='000300.XSHG') 
      # 开盘时运行
    run_daily(market_open, time='09:30', reference_security='000300.XSHG')
      # 收盘后运行
    run_daily(after_market_close, time='15:30', 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 = 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:
        # 记录这次买入
        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('##############################################################')

"""


algorithm_id = "xxxx"
extra_vars = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
initial_positions = [
    {
        'security':'000001.XSHE',
        'amount':'100',
    },
    {
        'security':'000063.XSHE',
        'amount':'100',
        'avg_cost': '1.0'
    },
]

params = {
    "algorithm_id": algorithm_id,
    "start_date": "2015-10-01",
    "end_date": "2016-07-31",
    "frequency": "day",
    "initial_cash": "1000000",
    "initial_positions": initial_positions,
    "extras": extra_vars,
}

created_bt_id = create_backtest(code=code, **params)

gt = get_backtest(backtest_id)

研究中获取回测与模拟交易信息，只能在研究中使用，目前不支持在回测及模拟交易中使用；使用方法及参考教程：

• 参数优化及并行回测参考教程
• 区分create_backtest(策略ID)和get_backtest(回测ID)
• create_backtest与get_backtest

参数：

• backtest_id: 回测ID，从回测详情页以及模拟交易详情页的 url 中获取, 比如 '/algorithm/backtest/detail?backtestId='以及'/algorithm/live/index?backtestId='，则回测ID为:xxxx。如下图所示：

返回：

• gt.get_status():获取回测状态. 返回一个字符串，其含义分别为：

  • none: 未开始
  • running: 正在进行
  • done: 完成
  • failed: 失败
  • canceled: 取消
  • paused: 暂停
  • deleted: 已删除

• gt.get_params()：获得回测参数. 返回一个 dict, 包含调用 create_backtest 时传入的所有信息. (注： algorithm_id，initial_positions，extras 只有在研究中创建的回测才能取到)

• gt.get_results()：获得收益曲线. 返回一个 list，每个交易日是一个 dict，键的含义如下：

  • time: 时间
  • returns: 收益
  • benchmark_returns: 基准收益
  • 如果没有收益则返回一个空的 list

• gt.get_positions(start_date=None, end_date=None)：获得持仓详情. 返回一个 list，默认取所有回测时间段内的数据。每个交易日为一个 dict，键的含义为：

  • time: 时间
  • amount: 持仓数量,
  • avg_cost: 开场均价,
  • closeable_amount: 可平仓数量,
  • daily_gains: 当日收益,
  • gains: 累积收益,
  • hold_cost: 持仓成本（期货）,
  • margin: 保证金,
  • price: 当前价格,
  • security: 标的代码,
  • security_name: 标的名,
  • side: 仓位方向,
  • today_amount: 今开仓量
  • 如果没有持仓则返回一个空的 list

• gt.get_orders(start_date=None, end_date=None)：获得交易详情. 返回一个 list，默认取所有回测时间段内的数据。每个交易日为一个 dict，键的含义为：

  • time: 时间

  • action: 开平仓，'open'/'close',

  • amount: 数量,

  • commission: 手续费,

  • filled: 已成交量,

  • gains: 收益,

  • limit_price: 限价单委托价,

  • match_time: 最新成交时间,

  • price: 成交价,

  • security: 标的代码,

  • security_name: 标的名,

  • side: 仓位方向,

  • status: 订单状态,

  • time: 委托时间,

  • type: 委托方式，市价单/限价单

  • 如果没有交易则返回一个空的 list

• gt.get_records()：获得所有 record 记录. 返回一个 list，每个交易日为一个 dict，键是 time 以及调用 record() 函数时设置的值.

• gt.get_risk()：获得总的风险指标. 返回一个 dict，键是各类收益指标数据，如果没有风险指标则返回一个空的 dict.

• gt.get_period_risks()：获得分月计算的风险指标. 返回一个 dict，键是各类指标, 值为一个 pandas.DataFrame. 如果没有风险指标则返回一个空的 dict.

• gt.get_balances(start_date=None, end_date=None): 获取回测每日市值. 返回一个 list，默认取所有回测时间段内的数据。每个交易日为一个 dict

示例：

gt = get_backtest("xxxx")

gt.get_status()        # 获取回测状态
gt.get_params()        # 获取回测参数
gt.get_results()       # 获取收益曲线
gt.get_positions()     # 获取所有持仓列表
gt.get_orders()        # 获取交易列表
gt.get_records()       # 获取所有record()记录
gt.get_risk()          # 获取总的风险指标
gt.get_period_risks()  # 获取分月计算的风险指标
gt.get_balances()      # 获取回测每日市值

normalize_code()

将其他形式的股票代码转换为聚宽可用的股票代码形式。

仅适用于A股市场股票代码、期货以及场内基金代码，输入字符串格式或int格式的其他形式标的代码,也支持list或tuple来转换多个标的代码

示例

#输入
codes =  ('000001', 'SZ000001', '000001SZ', '000001.sz', '000001.XSHE')
print(normalize_code(codes ))

#输出
['000001.XSHE', '000001.XSHE', '000001.XSHE', '000001.XSHE', '000001.XSHE']

enable_profile()

回测环境专用API

开启性能分析功能, 请在所有代码之前调用这句话(即在策略编译页面的代码编辑框最上方放置该代码), 只在点击 '运行回测' 运行的时候才能看到性能分析结果. 开启性能分析之后, 你会在回测结果页面看到性能分析结果. 请注意, 不需要时, 请不要调用此函数, 因为它本身会影响程序性能. 对于耗时较长的回测, 建议开启性能分析后先回测一个较短的周期比如一周来分析耗时优化代码, 避免运行时间过长 结果示例(真实输出中没有中文说明):

// 时间单位: 微秒
Timer unit: 1e-06 s

// 函数执行总时间
Total time: 0.00277 s
// 文件名
File: user_code.py
// 函数名
Function: initialize at line 3

//  行号, 这一行执行次数,总执行时间,每次执行时间, 这一行执行时间在整个函数的比例
Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     3                                           def initialize(context):
     4                                               # 定义一个全局变量, 保存要操作的股票
     5                                               # 000001(股票:平安银行)
     6         1           31     31.0      1.1      g.security = '000001.XSHE'
     7                                               # 初始化此策略
     8                                               # 设置我们要操作的股票池, 这里我们只操作一支股票
     9         1         2739   2739.0     98.9      set_universe([g.security])

Total time: 0.426325 s
File: user_code.py
Function: handle_data at line 12

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    12                                           def handle_data(context, data):
    13       122          398      3.3      0.1      security = g.security
    14                                               # 取得过去五天的平均价格
    15       122       168565   1381.7     39.5      average_price = data[security].mavg(5)
    16                                               # 取得上一时间点价格
    17       122          493      4.0      0.1      current_price = data[security].price
    18                                               # 取得当前的现金
    19       122          240      2.0      0.1      cash = context.portfolio.available_cash
    20
    21                                               # 如果上一时间点价格高出五天平均价1%, 则全仓买入
    22       122          396      3.2      0.1      if current_price > 1.01*average_price:
    23                                                   # 计算可以买多少只股票
    24        30          124      4.1      0.0          number_of_shares = int(cash/current_price)
    25                                                   # 购买量大于0时，下单
    26        30           56      1.9      0.0          if number_of_shares > 0:
    27                                                       # 买入股票
    28        30        83190   2773.0     19.5              order(security, +number_of_shares)
    29                                                       # 记录这次买入
    30        30        16202    540.1      3.8              log.info("Buying %s" % (security))
    31                                               # 如果上一时间点价格低于五天平均价, 则空仓卖出
    32        92         1119     12.2      0.3      elif current_price < average_price and context.portfolio.positions[security].amount > 0:
    33                                                   # 卖出所有股票,使这只股票的最终持有量为0
    34        13        86702   6669.4     20.3          order_target(security, 0)
    35                                                   # 记录这次卖出
    36        13         8210    631.5      1.9          log.info("Selling %s" % (security))
    37                                               # 画出上一时间点价格
    38       122        60630    497.0     14.2      record(stock_price=data[security].price)

set_subportfolios([SubPortfolioConfig(cash,type), ... ])

初始化或者修改 subportfolios 的配置，只能在 initialize 中调用, 每个 SubPortfolioConfig 中 cash 的和应该等于总的初始资金

SubPortfolioConfig 参数

SubPortfolioConfig(cash,type)

• cash: 仓位初始资金
• type: 可操作标的的类型，'stock' / 'index_futures' / 'futures' / 'stock_margin' / 其中 stock 包括股票和基金，index_futures 指金融期货，futures 包含股指期货和商品期货，stock_margin 为融资融券账户
  示例

    ## 设置多个账户
    # 获取初始资金，并等分为三份
    init_cash = context.portfolio.starting_cash/3
    # 设定subportfolios[0]为 股票和基金仓位，初始资金为 init_cash 变量代表的数值
    # 设定subportfolios[1]为 金融期货仓位，初始资金为 init_cash 变量代表的数值
    # 设定subportfolios[2]为 融资融券账户，初始资金为 init_cash 变量代表的数值
    set_subportfolios([SubPortfolioConfig(cash=init_cash, type='stock'),\
                       SubPortfolioConfig(cash=init_cash, type='futures'),\
                       SubPortfolioConfig(cash=init_cash, type='stock_margin')])

某个仓位的资金，标的信息，如不使用 SubPortfolioConfig 设置多仓位，默认只有subportfolios[0]一个仓位，Portfolio 指向该仓位。每个策略最多可以创建100个 subportfolio。

有关 SubPortfolio 详情见对象 - SubPortfolio

transfer_cash(from_pindex, to_pindex, cash)

从序号为 from_pindex 的 subportfolio 转移 cash 到序号为 to_pindex 的 subportfolio 资金转移及时到账

示例

# 从subportfolio[0] 向 subportfolio[1] 转移 500000
transfer_cash(from_pindex=0, to_pindex=1, cash=500000)

handle_tick(context, tick)

该函数在策略订阅的标的产生 tick 事件时被调用一次。如果没有 tick 事件， 则不会被调用。

参数

• context: context 对象, 存放有当前的账户/标的持仓信息
• tick: tick 对象， 存放了触发 handle_tick 事件的 tick 数据。

返回