InplusTrader 1.0 Documentation

License

InplusTrader 从数据获取、数据分析、算法交易、回测引擎、实盘模拟、实盘交易，为程序化交易者提供了全套解决方案。

InplusTrader 具有灵活的配置方式，强大的扩展性，用户可以非常容易地定制专属于自己的程序化交易系统。

InplusTrader 结合最新人工智能、机器学习等技术，助力量化投资。

特点

  • 易于使用
  • 稳定的环境
  • 灵活的配置
  • 强大的扩展性

项目状态

  • Third-party Tools Integration
    • ✅ 集成 Keras –> keras
  • Web Demo
    • 🚫 网页演示

获取帮助

关于InplusTrader的任何问题可以通过以下途径来获取帮助

感谢

项目参考了Github开源项目，在此对开源作者表示感谢。

  • Vnpy
  • RQAlpha

介绍

InplusTrader

安装指南

准备Ubuntu

建议使用一个新安装干净的Ubuntu环境，作者使用环境如下：

  • Memory: 16 GiB
  • Processor: Intel® Core™ i7-4790K CPU @ 4.00GHz × 8
  • Graphics: Intel® Haswell Desktop
  • OS type: 64-bit
  • Disk: 2 TB

安装Anaconda

在Continuum官网下载Python 2.7版本Linux 64-Bit的Anaconda，我这里下载完成后的文件名为Anaconda2-4.0.0-Linux-x86_64.sh。

打开Terminal（终端），进入文件所在的目录，输入如下命令:

bash Anaconda2-4.0.0-Linux-x86_64.sh

设置方面除了最后一个选择可以一路回车，到最后一项设置是否要将Anaconda添加到bash的PATH中时，注意选yes。

安装其他依赖

使用pip安装MongoDB驱动和Qt黑色主题，注意不要加sudo:

pip install pymongo qdarkstyle

使用apt-get安装编译API相关的工具：

sudo apt-get install git build-essential libboost-all-dev python-dev cmake

运行InplusTrader

使用git从Github上下载InplusTrader框架:

git clone http://github.com/zhengwsh/InplusTrader_Linux.git

教程

在本教程中，我们假设 InplusTrader 已经正确安装在您的系统中，并且已经完成了相应回测数据的同步，如果有任何安装相关的问题，请首先查看 安装指南

策略运行流程

我们从 策略示例 中选取 第一个策略-买入&持有 来进行回测。

在进行回测的过程中需要明确以下几个回测要素，您可通过生成config.yml传参 intro-config 或者通过命令行传参：

  • 数据源路径
  • 策略文件路径
  • 回测起始时间
  • 回测结束时间
  • 起始资金
  • Benchmark

假如我们的策略存放在了 ./rqalpha/examples/buy_and_hold.py 路径下， 数据源存放在 ./rqalpha/bundle/ 路径下，回测的起始时间为 2016-06-01, 结束时间为 2016-12-01，我们给策略分配的起始资金为 100000, Benchmark 设置为 000300.XSHG

那么我们通过如下命令来运行回测

rqalpha run -f ./rqalpha/examples/buy_and_hold.py -d ./rqalpha/bundle/ -s 2016-06-01 -e 2016-12-01 --stock-starting-cash 100000 --benchmark 000300.XSHG

如果我们想要以图形的方式查看回测的结果， 则增加 --plot 参数

rqalpha run -f ./rqalpha/examples/buy_and_hold.py -d ./rqalpha/bundle/ -s 2016-06-01 -e 2016-12-01 --stock-starting-cash 100000 --benchmark 000300.XSHG --plot
https://raw.githubusercontent.com/ricequant/rq-resource/master/rqalpha/buy_and_hold.png

如果想把回测的数据保存下来，可以通过 -o 参数将结果保存成 pkl 文件。

rqalpha run -f ./rqalpha/examples/buy_and_hold.py -d ./rqalpha/bundle/ -s 2016-06-01 -e 2016-12-01 --stock-starting-cash 100000 --benchmark 000300.XSHG --plot -o result.pkl

等回测结束后可以通过 pandas.read_pickle 函数来读取数据进行之后的数据分析。

1
2
3
4
5
6
import pandas as pd

result_dict = pd.read_pickle('result.pkl')

result_dict.keys()
# [out]dict_keys(['total_portfolios', 'summary', 'benchmark_portfolios', 'benchmark_positions', 'stock_positions', 'trades', 'stock_portfolios'])

策略编写流程

RQAlpha 抽离了策略框架的所有技术细节，以API的方式提供给策略研发者用于编写策略，从而避免陷入过多的技术细节，而非金融程序建模本身。

RQAlpha 的 API 主要分为三类：约定函数、数据查询和交易接口。

  • 约定函数: 作为 API 的入口函数，用户必须实现对应的约定函数才可以正确的使用RQAlpha
    • init() : 初始化方法，会在程序启动的时候执行
    • handle_bar(): bar数据更新时会自动触发调用
    • before_trading(): 会在每天策略交易开始前调用
    • after_trading(): 会在每天交易结束后调用
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
# 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
def init(context):
    # 在context中保存全局变量
    context.s1 = "000001.XSHE"
    # 实时打印日志
    logger.info("RunInfo: {}".format(context.run_info))

# before_trading此函数会在每天策略交易开始前被调用，当天只会被调用一次
def before_trading(context):
    logger.info("开盘前执行before_trading函数")

# 你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新
def handle_bar(context, bar_dict):
    logger.info("每一个Bar执行")
    logger.info("打印Bar数据：")
    logger.info(bar_dict[context.s1])

# after_trading函数会在每天交易结束后被调用，当天只会被调用一次
def after_trading(context):
    logger.info("收盘后执行after_trading函数")

至此，我们写出了一个“完整”的策略，但是该策略实际上什么也没有做。

接下来，我们需要获取数据，根据数据来确定我们的仓位逻辑，因此会使用到数据查询的 API 接口。

  • 数据查询
    • all_instruments() : 获取所有合约基础信息数据
    • instruments() : 获取合约详细数据
    • history_bars() : 获取某一合约的历史数据
    • current_snapshot() : 获取当前快照数据
    • get_future_contracts() : 获取期货可以交易合约列表
    • get_trading_dates(): 获取交易日列表
    • get_previous_trading_date() : 获取上一日交易日
    • get_next_trading_date() : 获取下一个交易日
    • get_yield_curve(): 获取收益率曲线
    • is_suspended() : 判断某股票当天是否停牌
    • is_st_stock() : 判断某股票是否为 *st

Ricequant 金融、财务、合约历史数据等数据接口请查看 模拟/实盘 API

  • bar_dict: 在 handle_bar() 中我们可以使用 bar_dict 来获取相应的 Bar 数据，bar_dict 是一个字典类型变量，直接通过传 key 的方式就可以获取到对应的 Bar 数据。
  • 我们可以引用第三方库来帮我们生成相应的指标序列，比如使用 TA-Lib 来获取移动平均线序列。TA-Lib 的安装可以参考 intro-detail-install-talib 相应文档。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import talib

# 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
def init(context):
    # 在context中保存全局变量
    context.s1 = "000001.XSHE"
    # 实时打印日志
    logger.info("RunInfo: {}".format(context.run_info))

    # 设置这个策略当中会用到的参数，在策略中可以随时调用，这个策略使用长短均线，我们在这里设定长线和短线的区间，在调试寻找最佳区间的时候只需要在这里进行数值改动
    context.SHORTPERIOD = 20
    context.LONGPERIOD = 120


# before_trading此函数会在每天策略交易开始前被调用，当天只会被调用一次
def before_trading(context):
    logger.info("开盘前执行before_trading函数")

# 你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新
def handle_bar(context, bar_dict):
    logger.info("每一个Bar执行")
    logger.info("打印Bar数据：")
    logger.info(bar_dict[context.s1])

    # 因为策略需要用到均线，所以需要读取历史数据
    prices = history_bars(context.s1, context.LONGPERIOD+1, '1d', 'close')

    # 使用talib计算长短两根均线，均线以array的格式表达
    short_avg = talib.SMA(prices, context.SHORTPERIOD)
    long_avg = talib.SMA(prices, context.LONGPERIOD)

    plot("short avg", short_avg[-1])
    plot("long avg", long_avg[-1])

    # 计算现在portfolio中股票的仓位
    cur_position = context.portfolio.positions[context.s1].quantity
    # 计算现在portfolio中的现金可以购买多少股票
    shares = context.portfolio.cash/bar_dict[context.s1].close

    # 如果短均线从上往下跌破长均线，也就是在目前的bar短线平均值低于长线平均值，而上一个bar的短线平均值高于长线平均值
    if short_avg[-1] - long_avg[-1] < 0 and short_avg[-2] - long_avg[-2] > 0 and cur_position > 0:
        # 进行清仓
        logger.info("进行清仓")

    # 如果短均线从下往上突破长均线，为入场信号
    if short_avg[-1] - long_avg[-1] > 0 and short_avg[-2] - long_avg[-2] < 0:
        # 满仓入股
        logger.info("满仓入股")

# after_trading函数会在每天交易结束后被调用，当天只会被调用一次
def after_trading(context):
    logger.info("开盘前执行after_trading函数")

至此，我们已经获取到了开仓和平仓的信号，那么接下来就需要调用交易接口来进行交易了。

  • 交易接口: 我们提供了多种交易接口，以方便不同的使用需求
    • order_shares(): 【股票专用】指定股数交易
    • order_lots(): 【股票专用】指定手数交易
    • order_value(): 【股票专用】指定价值交易
    • order_percent():【股票专用】 一定比例下单
    • order_target_value(): 【股票专用】按照目标价值下单
    • order_target_percent(): 【股票专用】按照目标比例下单
    • buy_open(): 【期货专用】买开
    • sell_close():【期货专用】 平买仓
    • sell_opem(): 【期货专用】卖开
    • buy_close(): 【期货专用】平卖仓
    • cancel_order(): 撤单
    • get_open_orders(): 获取未成交订单数据

我们分别使用 order_target_value() 和 order_shares() 进行平仓和开仓的操作，顺便把日志相关的代码删除，就是一个完整的 Golden Cross算法示例 了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import talib

# 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
def init(context):
    # 在context中保存全局变量
    context.s1 = "000001.XSHE"

    # 设置这个策略当中会用到的参数，在策略中可以随时调用，这个策略使用长短均线，我们在这里设定长线和短线的区间，在调试寻找最佳区间的时候只需要在这里进行数值改动
    context.SHORTPERIOD = 20
    context.LONGPERIOD = 120


# before_trading此函数会在每天策略交易开始前被调用，当天只会被调用一次
def before_trading(context):
    pass

# 你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新
def handle_bar(context, bar_dict):

    # 因为策略需要用到均线，所以需要读取历史数据
    prices = history_bars(context.s1, context.LONGPERIOD+1, '1d', 'close')

    # 使用talib计算长短两根均线，均线以array的格式表达
    short_avg = talib.SMA(prices, context.SHORTPERIOD)
    long_avg = talib.SMA(prices, context.LONGPERIOD)

    plot("short avg", short_avg[-1])
    plot("long avg", long_avg[-1])

    # 计算现在portfolio中股票的仓位
    cur_position = context.portfolio.positions[context.s1].quantity
    # 计算现在portfolio中的现金可以购买多少股票
    shares = context.portfolio.cash/bar_dict[context.s1].close

    # 如果短均线从上往下跌破长均线，也就是在目前的bar短线平均值低于长线平均值，而上一个bar的短线平均值高于长线平均值
    if short_avg[-1] - long_avg[-1] < 0 and short_avg[-2] - long_avg[-2] > 0 and cur_position > 0:
        # 进行清仓
        order_target_value(context.s1, 0)

    # 如果短均线从下往上突破长均线，为入场信号
    if short_avg[-1] - long_avg[-1] > 0 and short_avg[-2] - long_avg[-2] < 0:
        # 满仓入股
        order_shares(context.s1, shares)

# after_trading函数会在每天交易结束后被调用，当天只会被调用一次
def after_trading(context):
    pass

可以看到，我们使用 plot 函数绘制内容，也出现在了输出的结果中。

$ rqalpha run -s 2014-01-01 -e 2016-01-01 -f rqalpha/examples/golden_cross.py -sc 100000 -p -bm 000001.XSHE
https://raw.githubusercontent.com/ricequant/rq-resource/master/rqalpha/golden_cross.png

策略示例

在下面我们列举一些常用的算法范例，您可以通过RQAlpha运行，也可以直接登录 Ricequant 在线进行回测或模拟交易。

第一个策略-买入&持有

万事开头难，这是一个最简单的策略：在回测开始的第一天买入资金量的100%的平安银行并且一直持有。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
def init(context):
    logger.info("init")
    context.s1 = "000001.XSHE"
    update_universe(context.s1)
    # 是否已发送了order
    context.fired = False
    context.cnt = 1


def before_trading(context, bar_dict):
    logger.info("Before Trading", context.cnt)
    context.cnt += 1


# 你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新
def handle_bar(context, bar_dict):
    context.cnt += 1
    logger.info("handle_bar", context.cnt)
    # 开始编写你的主要的算法逻辑

    # bar_dict[order_book_id] 可以拿到某个证券的bar信息
    # context.portfolio 可以拿到现在的投资组合状态信息

    # 使用order_shares(id_or_ins, amount)方法进行落单

    # TODO: 开始编写你的算法吧！
    if not context.fired:
        # order_percent并且传入1代表买入该股票并且使其占有投资组合的100%
        order_percent(context.s1, 1)
        context.fired = True

Golden Cross算法示例

以下是一个我们使用TALib编写的golden cross算法的示例，使用了simple moving average方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import talib


# 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
def init(context):
    context.s1 = "000001.XSHE"

    # 设置这个策略当中会用到的参数，在策略中可以随时调用，这个策略使用长短均线，我们在这里设定长线和短线的区间，在调试寻找最佳区间的时候只需要在这里进行数值改动
    context.SHORTPERIOD = 20
    context.LONGPERIOD = 120


# 你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新
def handle_bar(context, bar_dict):
    # 开始编写你的主要的算法逻辑

    # bar_dict[order_book_id] 可以拿到某个证券的bar信息
    # context.portfolio 可以拿到现在的投资组合状态信息

    # 使用order_shares(id_or_ins, amount)方法进行落单

    # TODO: 开始编写你的算法吧！

    # 因为策略需要用到均线，所以需要读取历史数据
    prices = history_bars(context.s1, context.LONGPERIOD+1, '1d', 'close')

    # 使用talib计算长短两根均线，均线以array的格式表达
    short_avg = talib.SMA(prices, context.SHORTPERIOD)
    long_avg = talib.SMA(prices, context.LONGPERIOD)

    plot("short avg", short_avg[-1])
    plot("long avg", long_avg[-1])

    # 计算现在portfolio中股票的仓位
    cur_position = context.portfolio.positions[context.s1].quantity
    # 计算现在portfolio中的现金可以购买多少股票
    shares = context.portfolio.cash/bar_dict[context.s1].close

    # 如果短均线从上往下跌破长均线，也就是在目前的bar短线平均值低于长线平均值，而上一个bar的短线平均值高于长线平均值
    if short_avg[-1] - long_avg[-1] < 0 and short_avg[-2] - long_avg[-2] > 0 and cur_position > 0:
        # 进行清仓
        order_target_value(context.s1, 0)

    # 如果短均线从下往上突破长均线，为入场信号
    if short_avg[-1] - long_avg[-1] > 0 and short_avg[-2] - long_avg[-2] < 0:
        # 满仓入股
        order_shares(context.s1, shares)

单股票 MACD 算法示例

以下是一个我们使用TALib编写的单股票MACD算法示例，使用了TALib的MACD方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import talib


# 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
def init(context):
    context.s1 = "000001.XSHE"

    # 使用MACD需要设置长短均线和macd平均线的参数
    context.SHORTPERIOD = 12
    context.LONGPERIOD = 26
    context.SMOOTHPERIOD = 9
    context.OBSERVATION = 100


# 你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新
def handle_bar(context, bar_dict):
    # 开始编写你的主要的算法逻辑

    # bar_dict[order_book_id] 可以拿到某个证券的bar信息
    # context.portfolio 可以拿到现在的投资组合状态信息

    # 使用order_shares(id_or_ins, amount)方法进行落单

    # TODO: 开始编写你的算法吧！

    # 读取历史数据，使用sma方式计算均线准确度和数据长度无关，但是在使用ema方式计算均线时建议将历史数据窗口适当放大，结果会更加准确
    prices = history_bars(context.s1, context.OBSERVATION,'1d','close')

    # 用Talib计算MACD取值，得到三个时间序列数组，分别为macd, signal 和 hist
    macd, signal, hist = talib.MACD(prices, context.SHORTPERIOD,
                                    context.LONGPERIOD, context.SMOOTHPERIOD)

    plot("macd", macd[-1])
    plot("macd signal", signal[-1])

    # macd 是长短均线的差值，signal是macd的均线，使用macd策略有几种不同的方法，我们这里采用macd线突破signal线的判断方法

    # 如果macd从上往下跌破macd_signal

    if macd[-1] - signal[-1] < 0 and macd[-2] - signal[-2] > 0:
        # 计算现在portfolio中股票的仓位
        curPosition = context.portfolio.positions[context.s1].quantity
        #进行清仓
        if curPosition > 0:
            order_target_value(context.s1, 0)

    # 如果短均线从下往上突破长均线，为入场信号
    if macd[-1] - signal[-1] > 0 and macd[-2] - signal[-2] < 0:
        # 满仓入股
        order_target_percent(context.s1, 1)

多股票RSI算法示例

以下是一个我们使用TALib编写的多股票RSI算法示例，使用了TALib的RSI方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import talib


# 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
def init(context):

    # 选择我们感兴趣的股票
    context.s1 = "000001.XSHE"
    context.s2 = "601988.XSHG"
    context.s3 = "000068.XSHE"
    context.stocks = [context.s1, context.s2, context.s3]

    context.TIME_PERIOD = 14
    context.HIGH_RSI = 85
    context.LOW_RSI = 30
    context.ORDER_PERCENT = 0.3


# 你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新
def handle_bar(context, bar_dict):
    # 开始编写你的主要的算法逻辑

    # bar_dict[order_book_id] 可以拿到某个证券的bar信息
    # context.portfolio 可以拿到现在的投资组合状态信息

    # 使用order_shares(id_or_ins, amount)方法进行落单

    # TODO: 开始编写你的算法吧！

    # 对我们选中的股票集合进行loop，运算每一只股票的RSI数值
    for stock in context.stocks:
        # 读取历史数据
        prices = history_bars(stock, context.TIME_PERIOD+1, '1d', 'close')

        # 用Talib计算RSI值
        rsi_data = talib.RSI(prices, timeperiod=context.TIME_PERIOD)[-1]

        cur_position = context.portfolio.positions[stock].quantity
        # 用剩余现金的30%来购买新的股票
        target_available_cash = context.portfolio.cash * context.ORDER_PERCENT

        # 当RSI大于设置的上限阀值，清仓该股票
        if rsi_data > context.HIGH_RSI and cur_position > 0:
            order_target_value(stock, 0)

        # 当RSI小于设置的下限阀值，用剩余cash的一定比例补仓该股
        if rsi_data < context.LOW_RSI:
            logger.info("target available cash caled: " + str(target_available_cash))
            # 如果剩余的现金不够一手 - 100shares，那么会被ricequant 的order management system reject掉
            order_value(stock, target_available_cash)

海龟交易系统

海龟交易系统也是非常经典的一种策略，我们也放出了范例代码如下，而关于海龟交易系统的介绍也可以参照 这篇帖子 。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import numpy as np
import talib
import math


def get_extreme(array_high_price_result, array_low_price_result):
    np_array_high_price_result = np.array(array_high_price_result[:-1])
    np_array_low_price_result = np.array(array_low_price_result[:-1])
    max_result = np_array_high_price_result.max()
    min_result = np_array_low_price_result.min()
    return [max_result, min_result]


def  get_atr_and_unit( atr_array_result,  atr_length_result, portfolio_value_result):
    atr =  atr_array_result[ atr_length_result-1]
    unit = math.floor(portfolio_value_result * .01 / atr)
    return [atr, unit]


def get_stop_price(first_open_price_result, units_hold_result, atr_result):
    stop_price = first_open_price_result - 2 * atr_result \
                 + (units_hold_result - 1) * 0.5 * atr_result
    return stop_price


def init(context):
    context.trade_day_num = 0
    context.unit = 0
    context.atr = 0
    context.trading_signal = 'start'
    context.pre_trading_signal = ''
    context.units_hold_max = 4
    context.units_hold = 0
    context.quantity = 0
    context.max_add = 0
    context.first_open_price = 0
    context.s = '000300.XSHG'
    context.open_observe_time = 55
    context.close_observe_time = 20
    context.atr_time = 20


def handle_bar(context, bar_dict):
    portfolio_value = context.portfolio.portfolio_value
    high_price = history_bars(context.s, context.open_observe_time+1, '1d', 'high')
    low_price_for_atr = history_bars(context.s, context.open_observe_time+1, '1d', 'low')
    low_price_for_extreme = history_bars(context.s, context.close_observe_time+1, '1d', 'low')
    close_price = history_bars(context.s, context.open_observe_time+2, '1d', 'close')
    close_price_for_atr = close_price[:-1]

    atr_array = talib.ATR(high_price, low_price_for_atr, close_price_for_atr, timeperiod=context.atr_time)

    maxx = get_extreme(high_price, low_price_for_extreme)[0]
    minn = get_extreme(high_price, low_price_for_extreme)[1]
    atr = atr_array[-2]

    if context.trading_signal != 'start':
        if context.units_hold != 0:
            context.max_add += 0.5 * get_atr_and_unit(atr_array, atr_array.size, portfolio_value)[0]
    else:
        context.max_add = bar_dict[context.s].last

    cur_position = context.portfolio.positions[context.s].quantity
    available_cash = context.portfolio.cash
    market_value = context.portfolio.market_value

    if (cur_position > 0 and
            bar_dict[context.s].last < get_stop_price(context.first_open_price, context.units_hold, atr)):
        context.trading_signal = 'stop'
    else:
        if cur_position > 0 and bar_dict[context.s].last < minn:
            context.trading_signal = 'exit'
        else:
            if (bar_dict[context.s].last > context.max_add and context.units_hold != 0 and
                    context.units_hold < context.units_hold_max and
                    available_cash > bar_dict[context.s].last*context.unit):
                context.trading_signal = 'entry_add'
            else:
                if bar_dict[context.s].last > maxx and context.units_hold == 0:
                    context.max_add = bar_dict[context.s].last
                    context.trading_signal = 'entry'

    atr = get_atr_and_unit(atr_array, atr_array.size, portfolio_value)[0]
    if context.trade_day_num % 5 == 0:
        context.unit = get_atr_and_unit(atr_array, atr_array.size, portfolio_value)[1]
    context.trade_day_num += 1
    context.quantity = context.unit

    if (context.trading_signal != context.pre_trading_signal or
            (context.units_hold < context.units_hold_max and context.units_hold > 1) or
            context.trading_signal == 'stop'):
        if context.trading_signal == 'entry':
            context.quantity = context.unit
            if available_cash > bar_dict[context.s].last*context.quantity:
                order_shares(context.s, context.quantity)
                context.first_open_price = bar_dict[context.s].last
                context.units_hold = 1

        if context.trading_signal == 'entry_add':
            context.quantity = context.unit
            order_shares(context.s, context.quantity)
            context.units_hold += 1

        if context.trading_signal == 'stop':
            if context.units_hold > 0:
                order_shares(context.s, -context.quantity)
                context.units_hold -= 1

        if context.trading_signal == 'exit':
            if cur_position > 0:
                order_shares(context.s, -cur_position)
                context.units_hold = 0

    context.pre_trading_signal = context.trading_signal

股指期货MACD日回测

以下是一个使用TALib进行股指期货主力合约日级别回测MACD算法示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# 可以自己import我们平台支持的第三方python模块，比如pandas、numpy等
import talib


# 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递
def init(context):
    # context内引入全局变量s1，存储目标合约信息
    context.s1 = 'IF1606'

    # 使用MACD需要设置长短均线和macd平均线的参数
    context.SHORTPERIOD = 12
    context.LONGPERIOD = 26
    context.SMOOTHPERIOD = 9
    context.OBSERVATION = 50

    #初始化时订阅合约行情。订阅之后的合约行情会在handle_bar中进行更新
    subscribe(context.s1)


# 你选择的期货数据更新将会触发此段逻辑，例如日线或分钟线更新
def handle_bar(context, bar_dict):
    # 开始编写你的主要的算法逻辑
    # 获取历史收盘价序列，history_bars函数直接返回ndarray，方便之后的有关指标计算
    prices = history_bars(context.s1, context.OBSERVATION, '1d', 'close')

    # 用Talib计算MACD取值，得到三个时间序列数组，分别为macd,signal 和 hist
    macd, signal, hist = talib.MACD(prices, context.SHORTPERIOD,
                                    context.LONGPERIOD, context.SMOOTHPERIOD)

    # macd 是长短均线的差值，signal是macd的均线，如果短均线从下往上突破长均线，为入场信号，进行买入开仓操作
    if macd[-1] - signal[-1] > 0 and macd[-2] - signal[-2] < 0:
        sell_qty = context.portfolio.positions[context.s1].sell_quantity
        # 先判断当前卖方仓位，如果有，则进行平仓操作
        if sell_qty > 0:
            buy_close(context.s1, 1)
        # 买入开仓
        buy_open(context.s1, 1)

    if macd[-1] - signal[-1] < 0 and macd[-2] - signal[-2] > 0:
        buy_qty = context.portfolio.positions[context.s1].buy_quantity
        # 先判断当前买方仓位，如果有，则进行平仓操作
        if buy_qty > 0:
            sell_close(context.s1, 1)
        # 卖出开仓
        sell_open(context.s1, 1)

商品期货跨品种配对交易

该策略为分钟级别回测。运用了简单的移动平均以及布林带（Bollinger Bands）作为交易信号产生源。有关对冲比率（HedgeRatio）的确定，您可以在我们的研究平台上面通过import statsmodels.api as sm引入 statsmodels 中的OLS方法进行线性回归估计。具体估计窗口，您可以根据自己策略需要自行选择。

策略中的移动窗口选择为60分钟，即在每天开盘60分钟内不做任何交易，积累数据计算移动平均值。当然，这一移动窗口也可以根据自身需要进行灵活选择。下面例子中使用了黄金与白银两种商品期货进行配对交易。简单起见，例子中期货的价格并未做对数差处理。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
import numpy as np


# 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
def init(context):
    context.s1 = 'AG1612'
    context.s2 = 'AU1612'

    # 设置全局计数器
    context.counter = 0

    # 设置滚动窗口
    context.window = 60

    # 设置对冲手数,通过研究历史数据进行价格序列回归得到该值
    context.ratio = 15

    context.up_cross_up_limit = False
    context.down_cross_down_limit = False

    # 设置入场临界值
    context.entry_score = 2

    # 初始化时订阅合约行情。订阅之后的合约行情会在handle_bar中进行更新
    subscribe([context.s1, context.s2])


# before_trading此函数会在每天交易开始前被调用，当天只会被调用一次
def before_trading(context):
    # 样例商品期货在回测区间内有夜盘交易,所以在每日开盘前将计数器清零
    context.counter = 0


# 你选择的期货数据更新将会触发此段逻辑，例如日线或分钟线更新
def handle_bar(context, bar_dict):

    # 获取当前一对合约的仓位情况。如尚未有仓位,则对应持仓量都为0
    position_a = context.portfolio.positions[context.s1]
    position_b = context.portfolio.positions[context.s2]

    context.counter += 1
    # 当累积满一定数量的bar数据时候,进行交易逻辑的判断
    if context.counter > context.window:

        # 获取当天历史分钟线价格队列
        price_array_a = history_bars(context.s1, context.window, '1m', 'close')
        price_array_b = history_bars(context.s2, context.window, '1m', 'close')

        # 计算价差序列、其标准差、均值、上限、下限
        spread_array = price_array_a - context.ratio * price_array_b
        std = np.std(spread_array)
        mean = np.mean(spread_array)
        up_limit = mean + context.entry_score * std
        down_limit = mean - context.entry_score * std

        # 获取当前bar对应合约的收盘价格并计算价差
        price_a = bar_dict[context.s1].close
        price_b = bar_dict[context.s2].close
        spread = price_a - context.ratio * price_b

        # 如果价差低于预先计算得到的下限,则为建仓信号,'买入'价差合约
        if spread <= down_limit and not context.down_cross_down_limit:
            # 可以通过logger打印日志
            logger.info('spread: {}, mean: {}, down_limit: {}'.format(spread, mean, down_limit))
            logger.info('创建买入价差中...')

            # 获取当前剩余的应建仓的数量
            qty_a = 1 - position_a.buy_quantity
            qty_b = context.ratio - position_b.sell_quantity

            # 由于存在成交不超过下一bar成交量25%的限制,所以可能要通过多次发单成交才能够成功建仓
            if qty_a > 0:
                buy_open(context.s1, qty_a)
            if qty_b > 0:
                sell_open(context.s2, qty_b)
            if qty_a == 0 and qty_b == 0:
                # 已成功建立价差的'多仓'
                context.down_cross_down_limit = True
                logger.info('买入价差仓位创建成功!')

        # 如果价差向上回归移动平均线,则为平仓信号
        if spread >= mean and context.down_cross_down_limit:
            logger.info('spread: {}, mean: {}, down_limit: {}'.format(spread, mean, down_limit))
            logger.info('对买入价差仓位进行平仓操作中...')

            # 由于存在成交不超过下一bar成交量25%的限制,所以可能要通过多次发单成交才能够成功建仓
            qty_a = position_a.buy_quantity
            qty_b = position_b.sell_quantity
            if qty_a > 0:
                sell_close(context.s1, qty_a)
            if qty_b > 0:
                buy_close(context.s2, qty_b)
            if qty_a == 0 and qty_b == 0:
                context.down_cross_down_limit = False
                logger.info('买入价差仓位平仓成功!')

        # 如果价差高于预先计算得到的上限,则为建仓信号,'卖出'价差合约
        if spread >= up_limit and not context.up_cross_up_limit:
            logger.info('spread: {}, mean: {}, up_limit: {}'.format(spread, mean, up_limit))
            logger.info('创建卖出价差中...')
            qty_a = 1 - position_a.sell_quantity
            qty_b = context.ratio - position_b.buy_quantity
            if qty_a > 0:
                sell_open(context.s1, qty_a)
            if qty_b > 0:
                buy_open(context.s2, qty_b)
            if qty_a == 0 and qty_b == 0:
                context.up_cross_up_limit = True
                logger.info('卖出价差仓位创建成功')

        # 如果价差向下回归移动平均线,则为平仓信号
        if spread < mean and context.up_cross_up_limit:
            logger.info('spread: {}, mean: {}, up_limit: {}'.format(spread, mean, up_limit))
            logger.info('对卖出价差仓位进行平仓操作中...')
            qty_a = position_a.sell_quantity
            qty_b = position_b.buy_quantity
            if qty_a > 0:
                buy_close(context.s1, qty_a)
            if qty_b > 0:
                sell_close(context.s2, qty_b)
            if qty_a == 0 and qty_b == 0:
                context.up_cross_up_limit = False
                logger.info('卖出价差仓位平仓成功!')

回测 API

基本方法

init
init(context)

【必须实现】

初始化方法 - 在回测和实时模拟交易只会在启动的时候触发一次。你的算法会使用这个方法来设置你需要的各种初始化配置。 context 对象将会在你的算法的所有其他的方法之间进行传递以方便你可以拿取到。

参数:context (StrategyContext object) – 策略上下文
Example: 
1
2
3
def init(context):
    # cash_limit的属性是根据用户需求自己定义的，你可以定义无限多种自己随后需要的属性，系统默认只是会占用context.portfolio的关键字来调用策略的投资组合信息
    context.cash_limit = 5000
handle_bar
handle_bar(context, bar_dict)

【必须实现】

bar数据的更新会自动触发该方法的调用。策略具体逻辑可在该方法内实现，包括交易信号的产生、订单的创建等。在实时模拟交易中，该函数在交易时间内会每分钟被触发一次。

参数:
  • context (StrategyContext object) – 策略上下文
  • bar_dict (BarDict object) – key为order_book_id，value为bar数据。当前合约池内所有合约的bar数据信息都会更新在bar_dict里面
Example: 
1
2
3
4
5
def handle_bar(context, bar_dict):
    # put all your algorithm main logic here.
    # ...
    order_shares('000001.XSHE', 500)
    # ...
before_trading
before_trading(context)

【选择实现】

每天在策略开始交易前会被调用。不能在这个函数中发送订单。需要注意，该函数的触发时间取决于用户当前所订阅合约的交易时间。

举例来说，如果用户订阅的合约中存在有夜盘交易的期货合约，则该函数可能会在前一日的20:00触发，而不是早晨08:00.

参数:context (StrategyContext object) – 策略上下文
Example: 
1
2
def before_trading(context, bar_dict):
    logger.info("This is before trading")
after_trading
after_trading(context)

【选择实现】

每天在收盘后被调用。不能在这个函数中发送订单。您可以在该函数中进行当日收盘后的一些计算。

在实时模拟交易中，该函数会在每天15:30触发。

参数:context (StrategyContext object) – 策略上下文

交易相关函数

🆕 order - 智能下单「通用」
🆕 order_to - 智能下单「通用」
order_shares - 指定股数交易「股票专用」
order_lots - 指定手数交易「股票专用」
order_value - 指定价值交易「股票专用」
order_percent - 一定比例下单「股票专用」
order_target_value - 目标价值下单「股票专用」
order_target_percent - 目标比例下单「股票专用」
buy_open - 买开「期货专用」
sell_close - 平买仓「期货专用」
sell_open - 卖开「期货专用」
buy_close - 平卖仓「期货专用」
cancel_order - 撤单
get_open_orders - 获取未成交订单数据

scheduler定时器

scheduler.run_daily - 每天运行
scheduler.run_daily(function)

每日运行一次指定的函数，只能在init内使用。

注意，schedule一定在其对应时间点的handle_bar之后执行。

参数:function (func) – 使传入的function每日运行。注意，function函数一定要包含（并且只能包含）context, bar_dict两个输入参数
Example:

以下的范例代码片段是一个非常简单的例子，在每天交易后查询现在portfolio中剩下的cash的情况:

1
2
3
4
5
6
7
8
#scheduler调用的函数需要包括context, bar_dict两个输入参数
def log_cash(context, bar_dict):
    logger.info("Remaning cash: %r" % context.portfolio.cash)

def init(context):
    #...
    # 每天运行一次
    scheduler.run_daily(log_cash)
scheduler.run_weekly - 每周运行
scheduler.run_weekly(function, weekday=x, tradingday=t)

每周运行一次指定的函数，只能在init内使用。

注意：

  • tradingday中的负数表示倒数。
  • tradingday表示交易日。如某周只有四个交易日，则此周的tradingday=4与tradingday=-1表示同一天。
  • weekday和tradingday不能同时使用。
参数:
  • function (func) – 使传入的function每日交易开始前运行。注意，function函数一定要包含（并且只能包含）context, bar_dict两个输入参数。
  • weekday (int) – 1~5 分别代表周一至周五，用户必须指定
  • tradingday (int) – 范围为[-5,1],[1,5] 例如，1代表每周第一个交易日，-1代表每周倒数第一个交易日，用户可以不填写。
Example:

以下的代码片段非常简单，在每周二固定运行打印一下现在的portfolio剩余的资金:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#scheduler调用的函数需要包括context, bar_dict两个参数
def log_cash(context, bar_dict):
    logger.info("Remaning cash: %r" % context.portfolio.cash)

def init(context):
    #...
    # 每周二打印一下剩余资金：
    scheduler.run_weekly(log_cash, weekday=2)
    # 每周第二个交易日打印剩余资金：
    #scheduler.run_weekly(log_cash, tradingday=2)
scheduler.run_monthly - 每月运行
scheduler.run_monthly(function, tradingday=t)

每月运行一次指定的函数，只能在init内使用。

注意:

  • tradingday的负数表示倒数。
  • tradingday表示交易日，如某月只有三个交易日，则此月的tradingday=3与tradingday=-1表示同一。
参数:
  • function (func) – 使传入的function每日交易开始前运行。注意，function函数一定要包含（并且只能包含）context, bar_dict两个输入参数。
  • tradingday (int) – 范围为[-23,1], [1,23] ，例如，1代表每月第一个交易日，-1代表每月倒数第一个交易日，用户必须指定。
Example:

以下的代码片段非常简单的展示了每个月第一个交易日的时候我们进行一次财务数据查询，这样子会非常有用在一些根据财务数据来自动调节仓位股票组合的算法来说:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#scheduler调用的函数需要包括context, bar_dict两个参数
def query_fundamental(context, bar_dict):
        # 查询revenue前十名的公司的股票并且他们的pe_ratio在25和30之间。打fundamentals的时候会有auto-complete方便写查询代码。
    fundamental_df = get_fundamentals(
        query(
            fundamentals.income_statement.revenue, fundamentals.eod_derivative_indicator.pe_ratio
        ).filter(
            fundamentals.eod_derivative_indicator.pe_ratio > 25
        ).filter(
            fundamentals.eod_derivative_indicator.pe_ratio < 30
        ).order_by(
            fundamentals.income_statement.revenue.desc()
        ).limit(
            10
        )
    )

    # 将查询结果dataframe的fundamental_df存放在context里面以备后面只需：
    context.fundamental_df = fundamental_df

    # 实时打印日志看下查询结果，会有我们精心处理的数据表格显示：
    logger.info(context.fundamental_df)
    update_universe(context.fundamental_df.columns.values)

 # 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
def init(context):
    # 每月的第一个交易日查询以下财务数据，以确保可以拿到最新更新的财务数据信息用来调整仓位
    scheduler.run_monthly(query_fundamental, tradingday=1)
time_rule - 定时间运行

scheduler还可以用来做定时间运行，比如在每天开盘后的一小时后或一分钟后定时运行，这里有很多种组合可以让您达到各种自己想要达到的定时运行的目的。

使用的方法是和上面的 scheduler.run_daily() , scheduler.run_weekly() 和 scheduler.run_monthly() 进行组合加入time_rule来一起使用。

注意:

  • market_open与market_close都跟随中国A股交易时间进行设置，即09:31~15:00。
  • 使用time_rule定时运行只会在分钟级别回测和实时模拟交易中有定义的效果，在日回测中只会默认依然在该天运行，并不能在固定的时间运行。
  • 在分钟回测中如未指定time_rule,则默认在开盘后一分钟运行,即09:31分。
  • 如果两个schedule，分别使用market_open 与market_close规则，但规则触发时间在同一时刻，则market_open的handle一定在market_close的handle前执行。
  • 目前暂不支持开盘交易(即 09:30分交易) ,所以time_rule(minute=0) 和time_rule(hour=0) 将不会触发任何事件。
  • market_open(minute=120)将在11:30执行， market_open(minute=121)在13:01执行，中午休市的区间会被忽略。
  • time_rule=’before_trading’表示在开市交易前运行scheduler函数。该函数运行时间将在before_trading函数运行完毕之后handle_bar运行之前。

time_rule: 定时具体几点几分运行某个函数。time_rule=’before_trading’ 表示开始交易前运行；market_open(hour=x, minute=y)表示A股市场开市后x小时y分钟运行，market_close(hour=x, minute=y)表示A股市场收市前x小时y分钟运行。如果不设置time_rule默认的值是中国A股市场开市后一分钟运行。

market_open, market_close参数如下：

参数 类型 注释
hour int - option [1,4] 具体在market_open/market_close后/前第多少小时执行, 股票的交易时间为[9:31 - 11:30],[13:01 - 15:00]共240分钟，所以hour的范围为 [1,4]
minute int - option [1,240] 具体在market_open/market_close的后/前第多少分钟执行,同上，股票每天交易时间240分钟，所以minute的范围为 [1,240],中午休市的时间区间会被忽略。
example:

  • 每天的开市后10分钟运行:

    1
    scheduler.run_daily(function, time_rule=market_open(minute=10))

  • 每周的第t个交易日闭市前1小时运行:

    1
    scheduler.run_weekly(function, tradingday=t, time_rule=market_close(hour=1))

  • 每月的第t个交易日开市后1小时运行:

    1
    scheduler.run_monthly(function, tradingday=t, time_rule=market_open(hour=1))

  • 每天开始交易前运行:

    1
    scheduler.run_daily(function, time_rule='before_trading')

数据查询相关函数

all_instruments - 所有合约基础信息
instruments - 合约详细信息
industry - 行业股票列表
rqalpha.api.industry(industry_code)

获得属于某一行业的所有股票列表。

参数:industry_code (str) – 行业名称或行业代码。例如，农业可填写industry_code.A01 或 ‘A01’
返回:list of order_book_id 获得属于某一行业的所有股票

我们目前使用的行业分类来自于中国国家统计局的 国民经济行业分类 ，可以使用这里的任何一个行业代码来调用行业的股票列表：

行业代码 行业名称
A01 农业
A02 林业
A03 畜牧业
A04 渔业
A05 农、林、牧、渔服务业
B06 煤炭开采和洗选业
B07 石油和天然气开采业
B08 黑色金属矿采选业
B09 有色金属矿采选业
B10 非金属矿采选业
B11 开采辅助活动
B12 其他采矿业
C13 农副食品加工业
C14 食品制造业
C15 酒、饮料和精制茶制造业
C16 烟草制品业
C17 纺织业
C18 纺织服装、服饰业
C19 皮革、毛皮、羽毛及其制品和制鞋业
C20 木材加工及木、竹、藤、棕、草制品业
C21 家具制造业
C22 造纸及纸制品业
C23 印刷和记录媒介复制业
C24 文教、工美、体育和娱乐用品制造业
C25 石油加工、炼焦及核燃料加工业
C26 化学原料及化学制品制造业
C27 医药制造业
C28 化学纤维制造业
C29 橡胶和塑料制品业
C30 非金属矿物制品业
C31 黑色金属冶炼及压延加工业
C32 有色金属冶炼和压延加工业
C33 金属制品业
C34 通用设备制造业
C35 专用设备制造业
C36 汽车制造业
C37 铁路、船舶、航空航天和其它运输设备制造业
C38 电气机械及器材制造业
C39 计算机、通信和其他电子设备制造业
C40 仪器仪表制造业
C41 其他制造业
C42 废弃资源综合利用业
C43 金属制品、机械和设备修理业
D44 电力、热力生产和供应业
D45 燃气生产和供应业
D46 水的生产和供应业
E47 房屋建筑业
E48 土木工程建筑业
E49 建筑安装业
E50 建筑装饰和其他建筑业
F51 批发业
F52 零售业
G53 铁路运输业
G54 道路运输业
G55 水上运输业
G56 航空运输业
G57 管道运输业
G58 装卸搬运和运输代理业
G59 仓储业
G60 邮政业
H61 住宿业
H62 餐饮业
I63 电信、广播电视和卫星传输服务
I64 互联网和相关服务
I65 软件和信息技术服务业
J66 货币金融服务
J67 资本市场服务
J68 保险业
J69 其他金融业
K70 房地产业
L71 租赁业
L72 商务服务业
M73 研究和试验发展
M74 专业技术服务业
M75 科技推广和应用服务业
N76 水利管理业
N77 生态保护和环境治理业
N78 公共设施管理业
O79 居民服务业
O80 机动车、电子产品和日用产品修理业
O81 其他服务业
P82 教育
Q83 卫生
Q84 社会工作
R85 新闻和出版业
R86 广播、电视、电影和影视录音制作业
R87 文化艺术业
R88 体育
R89 娱乐业
S90 综合
Example: 
1
2
3
4
5
def init(context):
    stock_list = industry('A01')
    logger.info("农业股票列表：" + str(stock_list))

#INITINFO 农业股票列表：['600354.XSHG', '601118.XSHG', '002772.XSHE', '600371.XSHG', '600313.XSHG', '600672.XSHG', '600359.XSHG', '300143.XSHE', '002041.XSHE', '600762.XSHG', '600540.XSHG', '300189.XSHE', '600108.XSHG', '300087.XSHE', '600598.XSHG', '000998.XSHE', '600506.XSHG']
sector - 板块股票列表
rqalpha.api.sector(code)

获得属于某一板块的所有股票列表。

参数:code – 板块名称或板块代码。例如，能源板块可填写’Energy’、’能源’或sector_code.Energy :type code: str | sector_code
返回:list of order_book_id 属于该板块的股票列表

目前支持的板块分类如下，其取值参考自MSCI发布的全球行业标准分类:

板块代码 中文板块名称 英文板块名称
Energy 能源 energy
Materials 原材料 materials
ConsumerDiscretionary 非必需消费品 consumer discretionary
ConsumerStaples 必需消费品 consumer staples
HealthCare 医疗保健 health care
Financials 金融 financials
InformationTechnology 信息技术 information technology
TelecommunicationServices 电信服务 telecommunication services
Utilities 公共服务 utilities
Industrials 工业 industrials
Example: 
1
2
3
4
5
6
7
8
def init(context):
    ids1 = sector("consumer discretionary")
    ids2 = sector("非必需消费品")
    ids3 = sector("ConsumerDiscretionary")
    assert ids1 == ids2 and ids1 == ids3
    logger.info(ids1)
#INIT INFO
#['002045.XSHE', '603099.XSHG', '002486.XSHE', '002536.XSHE', '300100.XSHE', '600633.XSHG', '002291.XSHE', ..., '600233.XSHG']
concept - 概念股票列表
rqalpha.api.concept(concept_name1, concept_name2, ...)

获取属于某个或某几个概念的股票列表。

参数:concept_names – 概念名称。可以从概念列表中选择一个或多个概念填写 :type concept_names: str | 多个 str
返回:属于该概念的股票 order_book_id 或者 list[order_book_id]

概念列表:

含H股        深圳本地        含B股        农村金融        东亚自贸        海工装备        绿色照明        稀土永磁        内贸规划        3D打印
页岩气        三网融合        风能概念        金融改革        猪肉            水域改革        风能            赛马概念        社保重仓        物联网
民营医院        黄河三角        固废处理        甲型流感        丝绸之路        融资融券        黄金概念        抗癌            国企改革        碳纤维
保障房        智能电网        石墨烯        空气治理        京津冀        分拆上市        装饰园林        振兴沈阳        智能家居        阿里概念
股期概念        新能源        生物疫苗        特斯拉        国产软件        互联金融        锂电池        保险重仓        粤港澳        自贸区
安防服务        广东自贸        汽车电子        超大盘        低碳经济        云计算        婴童概念        建筑节能        土地流转        智能机器
未股改        触摸屏        天津自贸        生物质能        前海概念        抗流感        卫星导航        多晶硅        出口退税        参股金融
准ST股        食品安全        智能穿戴        业绩预降        污水处理        重组概念        上海自贸        外资背景        信托重仓        本月解禁
体育概念        维生素        基金重仓        充电桩        IPV6概念        资产注入        生态农业        基因概念        图们江        O2O模式
铁路基建        摘帽概念        股权激励        电子支付        机器人概念    油气改革        风沙治理        央企50        水利建设        养老概念
QFII重仓        迪士尼        业绩预升        宽带提速        长株潭        超导概念        网络游戏        含可转债        4G概念        送转潜力
奢侈品        新三板        皖江区域        核电核能        海峡西岸        次新股        高校背景        券商重仓        基因测序        节能
三沙概念        日韩贸易        氢燃料        陕甘宁        文化振兴        民营银行        苹果概念        稀缺资源        基因芯片        循环经济
聚氨酯        金融参股        沿海发展        智能交通        海上丝路        ST板块        涉矿概念        蓝宝石        博彩概念        电商概念
整体上市        草甘膦        创投概念        超级细菌        信息安全        生物燃料        武汉规划        节能环保        成渝特区        军工航天
地热能        上海本地        生物育种        燃料电池        海水淡化
Example:
  • 得到一个概念的股票列表:
1
2
3
4
5
6
7
concept('民营医院')
#[Out]
#['600105.XSHG',
#'002550.XSHE',
#'002004.XSHE',
#'002424.XSHE',
#...]
  • 得到某几个概念的股票列表:
1
2
3
4
5
6
concept('民营医院', '国企改革')
#[Out]
#['601607.XSHG',
#'600748.XSHG',
#'600630.XSHG',
#...]
history_bars - 某一合约历史数据
current_snapshot - 当前快照数据
get_future_contracts - 期货可交易合约列表
get_trading_dates - 交易日列表
get_previous_trading_date - 上一交易日
get_next_trading_date - 下一交易日
get_yield_curve - 收益率曲线
is_suspended - 全天停牌判断
is_st_stock - ST股判断

其他方法

update_universe
subscribe
unsubscribe

Context属性

类

Bar
Snapshot
Order
Portfolio
StockAccount
FutureAccount
StockPosition
FuturePosition
Instrument
class rqalpha.model.Instrument
order_book_id

【str】股票：证券代码，证券的独特的标识符。应以’.XSHG’或’.XSHE’结尾，前者代表上证，后者代表深证。期货：期货代码，期货的独特的标识符（郑商所期货合约数字部分进行了补齐。例如原有代码’ZC609’补齐之后变为’ZC1609’）。主力连续合约UnderlyingSymbol+88，例如’IF88’ ；指数连续合约命名规则为UnderlyingSymbol+99

symbol

【str】股票：证券的简称，例如’平安银行’。期货：期货的简称，例如’沪深1005’。

abbrev_symbol

【str】证券的名称缩写，在中国A股就是股票的拼音缩写，例如：’PAYH’就是平安银行股票的证券名缩写；在期货市场中例如’HS1005’，主力连续合约与指数连续合约都为’null’。

round_lot

【int】股票：一手对应多少股，中国A股一手是100股。期货：一律为1。

sector_code（股票专用）

【str】板块缩写代码，全球通用标准定义

sector_code_name（股票专用）

【str】以当地语言为标准的板块代码名

industry_code（股票专用）

【str】国民经济行业分类代码，具体可参考下方“Industry列表”

industry_name（股票专用）

【str】国民经济行业分类名称

listed_date

【str】股票：该证券上市日期。期货：期货的上市日期，主力连续合约与指数连续合约都为‘0000-00-00’。

de_listed_date

【str】股票：退市日期。期货：交割日期。

type

【str】合约类型，目前支持的类型有: ‘CS’, ‘INDX’, ‘LOF’, ‘ETF’, ‘FenjiMu’, ‘FenjiA’, ‘FenjiB’, ‘Future’

concept_names（股票专用）

【str】概念股分类，例如：’铁路基建’，’基金重仓’等

exchange

【str】交易所。股票：’XSHE’ - 深交所, ‘XSHG’ - 上交所。期货：’DCE’ - 大连商品交易所, ‘SHFE’ - 上海期货交易所，’CFFEX’ - 中国金融期货交易所, ‘CZCE’- 郑州商品交易所

board_type（股票专用）

【str】板块类别，’MainBoard’ - 主板,’GEM’ - 创业板

status（股票专用）

【str】合约状态。’Active’ - 正常上市, ‘Delisted’ - 终止上市, ‘TemporarySuspended’ - 暂停上市, ‘PreIPO’ - 发行配售期间, ‘FailIPO’ - 发行失败

special_type（股票专用）

【str】特别处理状态。’Normal’ - 正常上市, ‘ST’ - ST处理, ‘StarST’ - *ST代表该股票正在接受退市警告, ‘PT’ - 代表该股票连续3年收入为负，将被暂停交易, ‘Other’ - 其他

contract_multiplier（期货专用）

【float】合约乘数，例如沪深300股指期货的乘数为300.0

underlying_order_book_id（期货专用）

【str】合约标的代码，目前除股指期货(IH, IF, IC)之外的期货合约，这一字段全部为’null’

underlying_symbol（期货专用）

【str】合约标的名称，例如IF1005的合约标的名称为’IF’

maturity_date（期货专用）

【str】期货到期日。主力连续合约与指数连续合约都为‘0000-00-00’

settlement_method（期货专用）

【str】交割方式，’CashSettlementRequired’ - 现金交割, ‘PhysicalSettlementRequired’ - 实物交割

product（期货专用）

【str】产品类型，’Index’ - 股指期货, ‘Commodity’ - 商品期货, ‘Government’ - 国债期货

Instrument对象也支持如下方法：

合约已上市天数：

instruments(order_book_id).days_from_listed()

如果合约首次上市交易，天数为0；如果合约尚未上市或已经退市，则天数值为-1

合约距离到期天数。:

instruments(order_book_id).days_to_expire()

如果策略已经退市，则天数值为-1

枚举常量

ORDER_STATUS - 订单状态
class rqalpha.model.ORDER_STATUS
PENDING_NEW

待报

ACTIVE

可撤

FILLED

全成

CANCELLED

已撤

REJECTED

拒单

SIDE - 买卖方向
class rqalpha.model.SIDE
BUY

买

SELL

卖

POSITION_EFFECT - 开平
class rqalpha.model.POSITION_EFFECT
OPEN

开仓

CLOSE

平仓

ORDER_TYPE - 订单类型
class rqalpha.model.ORDER_TYPE
MARKET

市价单

LIMIT

限价单

RUN_TYPE - 策略运行类型
class rqalpha.model.RUN_TYPE
BACKTEST

回测

PAPER_TRADING

实盘模拟

MATCHING_TYPE - 撮合方式
class rqalpha.model.MATCHING_TYPE
CURRENT_BAR_CLOSE

以当前bar收盘价撮合

NEXT_BAR_OPEN

以下一bar数据开盘价撮合

模拟/实盘 API

init