Raquant-python平台介绍

回测

  • 准备好您的策略, 在 init方法 里选择要操作的股票池, 实现相关 定时函数
  • 选定一个回测开始日期, 开始回测
  • 引擎根据您选择的股票池和日期, 取得股票数据, 然后在您指定的定时函数里调用您的处理逻辑,
  • 在回测过程中您可以通过API获得现金、持仓情况和股票在上一天或者分钟的数据.
  • 使用data对象下面的各个方法, 您可以获取当天、前几天任意一天，多天的历史数据,
  • 下单后您可以调用 get_trades 取得所有成功的订单
  • 您可以在您的代码里面调用 record 函数记录某些数据, 它会用图表形式来辅助您做判断
  • 您可以在任何时候调用log.info/warn/error函数来打印一些日志
  • 回测过程中我们会画出您的收益和基准(参见 context.bench_mark )收益的曲线, 记录每日持仓,每日交易和一系列风险数据。

数据

我们拥有2012至今A股数据。
当日的16:00更新完毕最新数据。

复权、停牌

您获取的数据已经是前复权的数据。停牌的数据自动用停牌前的数据来填充,但成交量为0。

交易税费

默认万三手续费，千一印花税

滑点

风险指标

风险指标数据有利于您对策略进行一个客观的评价。
注意: 无论是回测还是模拟, 所有风险指标(alpha/beta/sharpe/max_drawdown等指标)都只会
每天更新一次, 也只根据每天收盘后的收益计算, 并不考虑每天盘中的收益情况.
例外:
  • 分钟模拟盘每分钟会更新策略收益和基准收益
  • 按天模拟盘每天开盘后和收盘后会更新策略收益和基准收益
那么可能会造成这种现象: 模拟时收益曲线中有回撤, 但是 max_drawdown 可能为0
maxDropDown（最大回撤)
描述策略可能出现的最糟糕的情况，最极端可能的亏损情况。
Max Drawdown=Max(Px−Py)/Px
Px,Py=策略某日股票和现金的总价值，y>x
total returns（策略收益）
Total Returns=(Pend−Pstart)/Pstart∗100%
Pend=策略最终股票和现金的总价值
Pstart=策略开始股票和现金的总价值
benchmark returns（基准收益）
Benchmark Returns=(Mend−Mstart)/Mstart∗100%
Mend=基准最终价值
Mstart=基准开始价值
Sharp（夏普比率）
Sharpe Ratio=(Rp−Rf)/σp
Rp=策略年化收益率
Rf=无风险利率(默认0.04)
σp=策略收益波动率
VolatilityDownside Risk（下行波动率）
策略收益下行波动率。和普通收益波动率相比，下行标准差区分了好的和坏的波动。
rp=策略每日收益率
rp=策略每日收益率
rpi¯=策略至第i日平均收益率=1i∑j=1irj
rpi¯=策略至第i日平均收益率=1i∑j=1irj
n=策略执行天数
n=策略执行天数
m=策略收益低于rpi¯天数
m=策略收益低于rpi¯天数
f(t)=1 if rp<rpi¯
f(t)=1 if rp<rpi¯
f(t)=0 if rp>=rpi¯
Alpha（阿尔法）
投资中面临着系统性风险（即Beta）和非系统性风险（即Alpha），Alpha是投资者获得与市场波动无关的回报。比如投资者获得了15%的回报，其基准获得了10%的回报，那么Alpha或者价值增值的部分就是5%。

Beta=βp=Cov(Dp,Dm)/Var(Dm)

Alpha=α=Rp−[Rf+βp(Rm−Rf)]
Rp=策略年化收益率
Rm=基准年化收益率
Rf=无风险利率（默认0.04）

βp=策略beta值

Alpha值 解释

α>0 策略相对于风险，获得了超额收益
α=0 策略相对于风险，获得了适当收益
α<0 策略相对于风险，获得了较少收益
Beta（贝塔）
表示投资的系统性风险，反映了策略对大盘变化的敏感性。例如一个策略的Beta为1.5，则大盘涨1%的时候，策略可能涨1.5%，反之亦然；如果一个策略的Beta为-1.5，说明大盘涨1%的时候，策略可能跌1.5%，反之亦然。

Beta=βp=Cov(Dp,Dm)/Var(Dm)

Dp=策略每日收益
Dp=策略每日收益
Dm=基准每日收益
Dm=基准每日收益
Cov(Dp,Dm)=策略每日收益与基准每日收益的协方差
Cov(Dp,Dm)=策略每日收益与基准每日收益的协方差

Var(Dm)=基准每日收益的方差

Beta值 解释

β<0 投资组合和基准的走向通常反方向，如空头头寸类
β=0 投资组合和基准的走向没有相关性，如固定收益类
0<β<1 投资组合和基准的走向相同，但是比基准的移动幅度更小
β=1 投资组合和基准的走向相同，并且和基准的移动幅度贴近
β>1 投资组合和基准的走向相同，但是比基准的移动幅度更大

最简单的策略

1
2
3
4
def init(context):
schedule_function(my_func,DateRule.every_day(),TimeRule.once_per_day(10,30))
def my_func(context,data):
log.info("%s %s" % (data.days_current("sha-601318")["sha-601318"],data.now) )
它实现了在每天10：30打印中国平安的股价。
这是一个完整的策略，实现一个策略只需两步:
  • 1)在init中注册自己的定时处理函数
  • 2)在自己的处理函数中加入自己的逻辑

添加交易逻辑

1
2
3
4
5
6
7
8
9
def init(context):
    schedule_function(test,DateRule.every_day(),TimeRule.market_open(30) )
    context.bench_mark="sha-600498"
    context.stock1="sha-600000"
def test(context,data):
    if  context.portfolio.positions.has_key(context.stock1):
        order_target_percent(context.stock1, 0)
    else:
        order_target_percent(context.stock1, 100)
这个策略判断当没有持仓的时候全仓买入sha-600000,
如果有股票持仓则全部卖出,这个策略的结果是当天买入第二天卖出。
估计巴菲特会骂残这个交易策略。下面我们来看一个更复杂的例子。

更复杂的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def init(context):
    # 定义一个全局变量, 保存要操作的股票
    # 000001(股票:平安银行)
    context.stock1 = 'sza-000001'
    # 定义每天开盘之后30分钟调用
    schedule_function(test_func,DateRule.every_day(),TimeRule.once_per_day() )
    #定义
    ma5=EMAFactor(5,'close')
    reg_factor("ma5",ma5)
def test_func(context, data):
    output=factor_output("ma5",context.stock1)
    sma5=output["ma5"]
    current_price=data.days_current("sza-000001")
    if current_price>1.01*sma5:
        order(context.stock1,10000)
    record("ma5",sma5)

API 文档

主要的一些概念

init方法

1
2
3
4
def init(context):
        lst=find_by_group("all-stocks")
        context.benchMark="sha-600498"
        context.slippage=0.003
init只会在一次回测中被调用一次，用来初始化一些变量。
在init方法里可以在context存储一些变量，比如自己想要操作的股票。
也可以设置一些参数，如基准线(比如设置上证指数、hs300为基准）、手续费等等

声明股票集合

镭矿平台里并没有全局股票集的概念，而是调用具体方法的时候，传入股票集合。例：

1
2
context.stocks=["sha-600000","sza-000001"]
current_prices=data.days_current(context.stocks,"close")
镭矿系统里的沪市代码都带有前缀 sha- ,深市代码里都带有前缀 sza-

Data对象

Data对象可以随时随地获取任何时间级别的数据（日线、小时线、分钟线数据）。

data.days(stock_list,field,num,df) 返回日线历史数据，数组
data.days_current(stock_list) 当前日线数据
data.days_prior(stock_list,offset) 前期日线数据,offset为偏移量，一个正数，表示前几天
data.hours(stock_list,field,num,df) 返回小时线历史数据，数组
data.hours_current 当前小时线数据
data.hours_prior 前期 小时线数据,offset为偏移量，一个正数，表示前几天
data.minutes(stock_list,field,num,df) 返回分钟线历史数据，数组
data.minutes_current 当前分钟线数据
data.minutes_prior 前期分钟线数据,offset为偏移量，一个正数，表示前几天

示例代码如下:

1
2
3
4
    context.stocks=["sha-600498"]
    lst=data.minutes(context.stocks,"close",10)["sha-600498"]
    curr=data.hours_current(context.stocks,"close")["sha-600498"]
    prior=data.days_prior(context.stocks,"close",2)["sha-600498"]

其中，lst为数组，数组元素为float类型，返回sha-600498前10天的收盘价

最佳实践：注意这里传入的参数是股票代码数组，别自己一个一个传股票代码了，也注意不要在方法循环里重复调用获取重复的数据。

context

context存储了本次测试的相关环境，另外你可以使用context存储你需要的全局变量

例如 context.my_stock=1
再如 context.my_lst=[3,4,5,6,7,8]
请使用context存储你的全局变量，而不是global关键字。

context.bench_mark

我们选定了股票 sha-601988 的作为判断您策略好坏和一系列风险值计算的基准. 您也可以使用 context.bench_mark 指定其他股票/指数的价格作为基准,示例代码如下:

1
context.bench_mark="sha-601318"
这段代码设置以中国平安为基准线

context.portfolio

查看当前持仓信息
  • cash 当前持有的现金
  • positions当前持有的股票仓位信息，是一个dict，key是股票代码，value是一个Position对象

Position

1
2
3
if context.portfolio.cash > 0:
    order_percent(context.s,100)
    log.info(context.portfolio.positions[context.s][price])
显示一只股票的当前仓位
security 股票代码
price 当前价格
avg_cost 平均成本
amount 持有数量

context.commision

可以设置手续费

context.slippage

可以设置测试时交易产生的浮点

交易相关

order

order(stockCode,num,comment=None)
下单某只股票
num为正买入，num为负卖出相应数量的证券

order_percent

order_percent(stockCode,percent,comment=None)
下单某只股票
percent为正表示买入/为负表示卖出 占仓位一定百分比percent的证券

order_value

order_value(stockCode,value,comment=None)
下单某只股票
value为正买入，value为负卖出金额为value的证券

order_target

order_target(stockCode,num,comment=None)
下单使某只股票到达指定数量num

order_target_percent

order_target_percent(stockCode,percent,comment=None)
下单使某只股票到达指定仓位percent

order_target_value

order_target_value(stockCode,value,comment=None)
下单使某只股票到达指定金额value

其他API

record

1
record("kpi",kpiValue);
record可以记录回测过程中的变量，并展现到界面上
kpiValue为一个float类型的数
在分钟、小时级别上record，系统为了效率，界面上仍然只会显示日线级别的record数据

log

你可以使用 log.infolog.debuglog.warnlog.error
因为在网页上打印log，会碰到带’<>’打印不出来的问题，你可以使用txt方法,log.info(txt(“<dict> objct”))
同样因为在网页上，你可以使用log.info(“<font color=’gold’>some text</font>”) 打印带颜色的日志

Position

1
2
3
if context.portfolio.cash > 0:
    order_percent(context.s,100)
    log.info(context.portfolio.positions[context.s][price])
显示一只股票的当前仓位
security 股票代码
price 当前价格
avg_cost 平均成本
amount 持有数量

get_trades

示例代码如下:

1
2
    order_percent(context.s,40)
    log.info( get_trades(context.s)[0])
get_trades(security=None)
方法返回一个数组。获得所有成交数据,如果security不为空则获得security的所有成交数据
返回数组元素是一个 Trade 对象

 

Trade

Trade 对象,可以获取成交数据

time 交易时间
amount 交易证券的数量
security 证券名称
price 成交价格
is_buy True表示是买入成交单，Fasle表示是卖出成交单
comment 买入时代码里写入的注释文本

get_open_assets

示例代码如下:

1
2
3
order_value("sha-601318",1000)
df=pd.DataFrame(get_open_assets("sha-601318"))
log.info(df.loc("sha-601318"))
get_open_assets(security)
方法返回当前持有证券的买入价格、买入时间等详细信息
返回一个数组，数组元素为 Asset 对象
如果不传入参数get_open_assets() 返回当前所有的Asset
为了方便统计观察，设定在交易过程中最先卖出的asset为最先买入的asset

get_closed_assets

示例代码如下:

1
2
3
    order_value("sha-601318",1000)
    df=pd.DataFrame(get_closed_assets("sha-601318"))
    log.info(df.loc("sha-601318"]))
get_closed_assets(security)
方法返回当前已经卖出的证券的买入价格、买入时间，卖出时间，卖出价格等详细信息
返回一个数组，数组元素为 Asset 对象
如果不传入参数get_closed_assets() 返回当前所有的Asset
为了方便统计观察，设定在交易过程中最先卖出的asset为最先买入的asset

 

Asset

datafreme 对象，包含以下字段

entry_time 买入时间
entry_time 卖出时间
amount 交易证券的数量
security 证券名称

find_by_group

find_by_group(groupName)
根据股票组名称寻找到相应的股票
find_by_group(“all-stocks”) 返回所有股票代码
find_by_group(“hs300”)返回沪深300成份股代码
1
2
lst1=find_by_group("all-stocks")
lst2=find_by_group("hs300")
例如上面所示，lst1,lst2都是数组，分别为所有股票的数组，沪深300成分股的数组

schedule_function

1
schedule_function(func=None,date_rule=None,time_rule=None)

定时函数需传入函数名，DateRule,TimeRule 示例：

1
2
3
4
def init(context):
    schedule_function(test_func,DateRule.every_day(),TimeRule.MarketOpenRule())
def test_func(context,data):
    log.info(data.dt)

如上，想schedule_function里传入了test_func，这就是自定义方法的方法名。这段代码定义了每天市场开盘后都打印一下当前时间。

DateRule

DateRule定义了定时事件具体到天怎么执行。

1
DateRule.every_day()

这个方法返回一个代表每天执行的DateRule

1
DateRule.month(offset)

这个方法返回一个代表每个月执行的DateRule,offset 代表当月的第几个交易日,DateRule.month(1) 代表每月的第一个交易日执行

1
DateRule.week(offset)

这个方法返回一个代表每个星期执行的DateRule,offset 代表每个星期的第几个交易日,

DateRule.week(1) 代表每周的第一个交易日执行(大多数情况下是周一）

1
DateRule.last_day()

这个方法表示只在上一个交易日执行。一般用于选股、计算等一次性任务。

TimeRule

TimeRule定义了定时事件具体到当天的时间点怎么执行。现在有5个方法。

1
TimeRule.MarketOpenRule(offset_minutes=0)

这个方法返回一个Rule,代表开盘后候执行。offset_minutes表示开盘后多少分钟时执行

 

1
TimeRule.MarketCloseRule(offset_minutes=0)

这个方法返回一个Rule,代表收盘前执行。offset_minutes表示收盘前多少分钟时执行

1
TimeRule.once_per_day(hours=0,minutes=0)

这个方法返回一个Rule，代表一天的某一个时间点执行一次。当被错误地指定为非交易时间时，系统将强制修正为10：00执行。

1
TimeRule.every_hour()

这个方法返回一个Rule，代表每个小时时刻执行一次。

1
TimeRule.every_minute()

这个方法返回一个Rule，代表每一分钟执行一次。

一般仅做一些短线止损止盈，不做太复杂的逻辑。

快捷定时函数

除了以上使用DateRule,TimeRule自定义定时函数之外，镭矿还提供几个保留函数名，这几个函数名声明后就会被自动注册为定时函数的方法名。

1
2
3
every_day
every_hour
every_minute

因子操作

如果你需要根据一些指标进行预处理，然后排序，然后选取一些证券做买入卖出操作，
那么你可能可以使用管道来进行操作.这是一个比较复杂的概念，我们来看一个例子
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from factors.max_factor import MAXFactor
from factors.min_factor import MINFactor
def init(context):
    context.lst=find_by_group("all-stocks")
    universe.extend(lst)
    context.bench_mark="sha-601918"
    context.slippage=0.003
    context.num=0
    f1=MAXFactor(30,"close")
    f2=MINFactor(30,"close")
    add_pipeline("max",f1)
    add_pipeline("min",f2)
    add_pipeline_expr("rate","max/min")
    add_pipeline_expr("rate2","int(rate*100)")
def every_day(context,data):
    lst=factor_output("rate",context.lst).sort("rate",ascending=[1]).head(5).index
    for stock in lst:
        mark(stock)
        log.info(stock)
代码有点费解，看看下面怎么说

Factor

Factor 定义了在每个时间点下，对某个固定窗口长度的数据的特定的运算。
如MaxFactor(30,”close”),MinFactor(30,”close”)表示计算当前时间的
前30个时间点收盘价数据的最大值和最小值
SMAFactor(22,”high”) 表示计算前22个时间点的最高价做算数平均。
镭矿自带Factor列表:

EMAFactor

EMAFactor ( window_length , field ) 返回时间区间的EMA

Note

EMA（Exponential Moving Average），指数平均数指标。也叫EXPMA指标，它也是一种趋向类指标，指数平均数指标是以指数式递减加权的移动平均。在EMA指标中，每天价格的权重系数以指数等比形式缩小。时间越靠近当今时刻，它的权重越大，说明EMA函数对近期的价格加强了权重比，更能及时反映近期价格波动情况。

  • 参数:
  • window_length:类型int,历史时间窗口长度
  • field:可为’open’,’close’,’high’,’low’,’volume’
  • 返回： 类型float,返回时间区间中field字段的EMA值

例如示例代码如下:

1
2
3
4
5
6
7
def init(context):
    context.s="sha-601998"
    f1=EMAFactor(14,'close')
    reg_factor("ema",f1)
def every_day(context,data):
    data=factor_output("ema",context.s)
    log.info("\n%s"%data)

会打印出如下结果：

1
2
3
2016-07-14 11:18:48,498 INFO:ema
sha-601988   3.684187
sha-601318  32.875111

RSIFactor

RSIFactor ( window_length , field )返回RSI，Relative Strength Index，强弱指标

Note

RSI的原理简单来说是以数字计算的方法求出买卖双方的力量对比，譬如有100个人面对一件商品，如果50个人以上要买，竞相抬价，商品价格必涨。相反，如果50个人以上争着卖出，价格自然下跌。
强弱指标理论认为，任何市价的大涨或大跌，均在0-100之间变动，根据常态分配，认为RSI值多在30-70之间变动，通常80甚至90时被认为市场已到达超买状态，至此市场价格自然会回落调整。当价格低跌至30以下即被认为是超卖状态，市价将出现反弹回升。

  • 参数:
  • window_length:类型int,历史时间窗口长度
  • field:可为’open’,’close’,’high’,’low’,’volume’
  • 返回： 类型float,返回时间区间中field字段的RSI值

例如示例代码如下:

1
2
3
4
5
6
7
def init(context):
    context.s="sha-601998"
    f1=RSIFactor(14,'close')
    reg_factor("rsi",f1)
def every_day(context,data):
    data=factor_output("rsi",context.s)
    log.info("\n%s"%data)

会打印出如下结果：

1
2
3
2016-07-14 11:27:35,511 INFO:rsi
sha-601988  53.376574
sha-601318  51.919554

DMIFactor

DMIFactor ( window_length)返回DMI指标

Note

DMI指标共有+DI、-DI、ADX、ADXR四条线,也是它的四个参数值,它分为多空指标(+DI、-DI)和趋向指标(ADX、ADXR)两组指标.

  • 参数:
  • window_length:类型int,历史时间窗口长度
  • field:可为’open’,’close’,’high’,’low’,’volume’
  • 返回： 类型float,返回时间区间中的DMI.DMI是一组指标，它产生的数据列名以factor的名称为前缀
例如，如下的代码:
1
2
3
4
5
6
7
def init(context):
    lst=find_by_group("sz50")
    f1=DMIFactor(14)
    reg_factor("abc",f1)
def every_day(context,data):
    alldata=factor_output("abc_mdi",lst)
    log.info("\n%s"%alldata.head(3))
会打印出如下结果：
1
2
3
4
abc_adx   abc_adxr    abc_mdi    abc_pdi
sha-601998  54.469246  60.264924   9.037369  34.450496
sha-601857  56.354691  59.094876  10.986684  41.589345
sha-601688  61.831469  74.606265  13.149323  32.051018

BBANDSFactor

BBANDSFactor ( window_length , field )返回指定field的布林带

  • 参数:
  • window_length:类型int,历史时间窗口长度
  • field:可为’open’,’close’,’high’,’low’,’volume’
  • 返回: BBands(布林带)是一组指标，它产生的数据列名以factor的名称为前缀
例如如下代码中，使用alldata[“abc_lowerband”],alldata[“abc_middleband”],alldata[“abc_upperband”]
分别获得布林带的下轨、中轨、上轨,并画到网页上。
1
2
3
4
5
6
7
8
9
10
11
12
def init(context):
    context.stocks=[]
    context.stocks.extend(['sha-600000', 'sza-300207', 'sza-002030', 'sza-300033', 'sha-600677', 'sha-600340', 'sza-300024', 'sha-600650', 'sza-300133', 'sza-000002', 'sha-600703', 'sza-300275', 'sza-002280', 'sha-600887','shz-000001' ])
    context.bench_mark="sha-601318"
    context.slippage=0.003
    f1=BBANDSFactor(14,"close")
    reg_factor("abc",f1)
def every_day(context,data):
    alldata=factor_output("abc","shz-000001")
    record("lowerband",alldata["abc_lowerband"])
    record("middleband",alldata["abc_middleband"])
    record("upperband",alldata["abc_upperband"])

全部Factor列表

点击这里可以查看所有Factor的详细文档。我们拥有越来越多的Factor可供你直接使用。

reg_factor

reg_factor(name,factor)
添加一个名为name的factor

reg_expr

reg_expr(name,expr)
reg_expr可以使用已经添加过的factor进行表达式计算
而这个表达式计算会在每个时间点都会被触发
添加一个expr（运算表达式）的一个factor

factor_output

factor_output(factor_name,stock_list)
factor_name为Factor的名称；stock_list为一个数组。
此方法在every_day下调用可获得已经添加的所有的factor,
返回值为一个DataFrame,index为factor的name
比如上面返回结果就是
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
max    min      rate  rate2
sza-300189   8.20   6.71  1.222057    122
sza-300188  32.58  25.60  1.272656    127
sza-300187  34.66  29.60  1.170946    117
sza-300186   8.88   7.78  1.141388    114
sza-300185   6.74   5.55  1.214414    121
sza-300184  14.85  11.62  1.277969    127
sza-300183  52.69  47.42  1.111135    111
sza-300182  24.30  17.16  1.416084    141
sza-300181  16.14  12.49  1.292234    129
sza-300180   9.78   8.47  1.154664    115
sza-300061  18.24  16.29  1.119705    111
sza-002481  18.45  14.82  1.244939    124
sha-600297  10.05   6.87  1.462882    146
sza-002483  12.74  11.21  1.136485    113
sha-600295   9.54   8.48  1.125000    112
当然，这个函数也支持offset，取前几日的值。比如这样调用

1
prev_ma60=factor_output("sma60",stock,"d1",-3)["sma60"]

factor_output_df

factor_output_df是factor_output返回DataFrame格式的版本

获取基本面数据

get_fundamentals(field_list,date_str) 返回 指定时间，所有股票集的指定财务数据字段

Note

简单来说就是以DataFrame存储所有股票相关指标的指定时间的数据信息，例如，查询股票sha-600000，2016年02月02号的 income_statDate，balance_capital_reserve_fund，valuation_pe_ratio字段信息，则可以调用此接口实现。查询到的有些结果是当天能看到的数据，而并不一定是当天发布的数据。比如一些季度数据，只是季度末发布。但你用任何日期都可以查询到结果，结果返回的就是你能看到的最近的季度数据。

  • 参数：
  • field_list：字符串类型，需要查询的字段列表，例 :”brief_bps,brief_roic”
  • date_str：字符串类型,指定查询日期，格式为：20150331
  • 也即：df=get_fundamentals(“brief_bps,brief_roic”,”20150331″)
  • 返回：
  • 返回类型DataFrame结构中,示例如下：
1
2
3
INFO:            brief_bps  brief_roic
sza-300662       2.48       29.09
sza-300663       3.61        8.58

财务数据比率

get_fundamentals_ratio(field1,field2,date_str=None) 返回 指定时间，所有股票集的指定财务数据字段field1与field2的比值

Note

很多财务字段看绝对值没有办法跟其他公司比较，这里提供了一个比值计算，方便用这个计算结果进行不同公司的比较。

主要财务指标

1
2
3
4
5
6
7
8
9
10
11
| brief_basic_eps                      | eps                            | brief    |
| brief_bps                            | bps                            | brief    |
| brief_roe_fully_diluted              | roe摊薄                         | brief    |
| brief_roe_weighted_average           | 加权roe                         | brief    |
| brief_roet                           | ROET                           | brief    |
| brief_roic                           | ROIC                           | brief    |
| brief_assets_liability_ratio         | 资产负债比                       | brief    |
| brief_liquid_ratio                   | 流动比率                         | brief    |
| brief_quick_ratio                    | 速动比率                         | brief    |
| brief_equity_multiplier              | 权益乘数                         | brief    |
| brief_net_profit_gross_revenue_ratio | 净利润比上营业总收入               | brief    |

资产负债表

1
2
3
4
5
6
7
| balance_liquid_assets                                | 流动资产总计                                       | balance           |
| balance_non_liquid_assets                            | 非流动资产总计                                     | balance           |
| balance_current_liability                            | 流动负债总计                                       | balance           |
| balance_non_current_liability                        | 非流动负债总计                                     | balance           |
| balance_assets                                       | 资产总计                                          | balance           |
| balance_liability                                    | 负债总计                                          | balance           |
| balance_owners_equity                                | 所有者权益总计                                     | balance           |

现金流量表

1
2
3
4
5
6
7
8
9
| cashflow_operating_activities_in                     | 经营活动流入                                     | cashflow          |
| cashflow_operating_activities_out                    | 经营活动流出                                     | cashflow          |
| cashflow_investing_activities_in                     | 投资活动流入                                     | cashflow          |
| cashflow_investing_activities_out                    | 投资活动流出                                     | cashflow          |
| cashflow_financing_activities_in                     | 筹资活动流入                                     | cashflow          |
| cashflow_financing_activities_out                    | 筹资活动流出                                     | cashflow          |
| cashflow_operating_activities_total                  | 经营活动总计                                     | cashflow          |
| cashflow_investing_activities_total                  | 投资活动总计                                     | cashflow          |
| cashflow_financing_activities_total                  | 筹资活动总计                                     | cashflow          |

利润表

1
2
3
4
5
6
7
8
9
10
11
| profit_operating_income                              | 营业收入                                         | profit            |
| profit_overhead_costs                                | 营业成本                                         | profit            |
| profit_selling_expenses                              | 销售费用                                         | profit            |
| profit_adminisstrative_expenses                      | 管理费用                                         | profit            |
| profit_financial_expenses                            | 财务费用                                         | profit            |
| profit_changes_in_the_fair_value                     | 公允价值变动收益                                  | profit            |
| profit_net_investment_income                         | 投资净收益                                       | profit            |
| profit_operating_profit                              | 营业利润                                         | profit            |
| profit_total_profit                                  | 利润总额（含非营业收入支出影响）                     | profit            |
| profit_net_profit                                    | 净利润                                           | profit            |
| profit_net_profit_attributable_to_the_parent_company | 归属于母公司所有者的净利润                          | profit            |

股本结构表

1
2
3
4
5
6
7
| cs_total_stock_issue                                 | 总股本                                           | capital_structure |
| cs_total_stock_issue_a                               | 流通A股                                          | capital_structure |
| cs_limited_total                                     | 有限售条件股份总额                                 | capital_structure |
| cs_limited_country                                   | 有限售条件股份-国家持股                            | capital_structure |
| cs_limited_state_own_Legal_person                    | 有限售条件股份-国有法人持股                         | capital_structure |
| cs_limited_foreign_capital                           | 有限售条件股份-外资持股                            | capital_structure |
| cs_limited_executives                                | 有限售条件股份-高管持股                            | capital_structure |

history

history相当于上面的data.days data.hours data.minutes 三个函数的另一个包装。

1
history(stock_list,freq="d1",field="close",num=10,df=False)

stock_list:股票集

freq:数据的频度，可以为d1,h1,m1

field:close open high low volume volume_money

num:获取数据的数量

df:是否返回DataFrame格式的数据，默认为False

参考策略案例

双均线策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def init(context):
    context.s1="sha-600000"
    sma12_factor=SMAFactor(12,"close")
    sma30_factor=SMAFactor(30,"close")
    reg_factor("sma12",sma12_factor)
    reg_factor("sma30",sma30_factor)
    schedule_function(my_func,DateRule.every_day(),TimeRule.once_per_day())
def my_func(context,data):
    stock=context.s1
    ma12=factor_output("sma12",context.s1)["sma12"]
    ma30=factor_output("sma30",context.s1)["sma30"]
    if ma12>ma30:
        order(stock,1000)
    elif ma12 < ma30 and context.portfolio.positions[stock].amount > 0:
        order_target_value(stock,0)

均线回归策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def init(context):
    context.s1="sza-000001"
    sma_factor=SMAFactor(20,"close")
    reg_factor("sma20",sma_factor)
    schedule_function(my_func,DateRule.every_day(),TimeRule.once_per_day())
def my_func(context, data):
    s1 = context.s1
    price200 = factor_output("sma20",context.s1)["sma20"]
    close=data.days_current([s1],"close")[s1]
    cash = context.portfolio.cash
    # 如果当前有余额，并且上一时间点价格低于200日均线平均价格*0.95，买入
    if close < price200 * 0.95 :
        order_percent(s1, 12)
        # 记录这次买入
        log.info("Buying %s" % (s1))
    # 如果当前价格高于200日平均价格*1.05，并且目前有头寸，卖出
    elif close > price200 * 1.05 and context.portfolio.positions.has_key(s1):
        # 全部卖出
        order_target(s1, 0)
        # 记录这次卖出
        log.info("Selling %s" % (s1))
    # 绘制股票价格
    record("close",close)

DMI策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def init(context):
    context.stocks=[]
    context.stocks.extend(['sha-600000', 'sza-300207', 'sza-002030', 'sza-300033', 'sha-600677', 'sha-600340', 'sza-300024', 'sha-600650', 'sza-300133', 'sza-000002', 'sha-600703', 'sza-300275', 'sza-002280', 'sha-600887' ])
    context.bench_mark="sha-601318"
    context.slippage=0.003
    dmi=DMIFactor(10)
    reg_factor("dmi",dmi)
def every_day(context,data):
    for s in context.stocks:
        pdi=factor_output("dmi",[s])["dmi_pdi"][s]
        mdi=factor_output("dmi",[s])["dmi_mdi"][s]
        adx=factor_output("dmi",[s])["dmi_adx"][s]
        adxr=factor_output("dmi",[s])["dmi_adxr"][s]
        pdi_prev=factor_output("dmi",[s],"d1",-2)["dmi_pdi"][s]
        if pdi>pdi_prev and pdi>32 and adx>adxr and (pdi-mdi)>20 and adx<40:
            order_percent(s,10)

KDJ策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def init(context):
    context.stocks=[]
    context.stocks.extend(['sha-600000', 'sza-300207', 'sza-002030', 'sza-300033', 'sha-600677', 'sha-600340', 'sza-300024', 'sha-600650', 'sza-300133', 'sza-000002', 'sha-600703', 'sza-300275', 'sza-002280', 'sha-600887' ])                           #股票池加入股票
    context.bench_mark="sha-601318"     #设置基准股票为"sha-601318"
    context.slippage=0.003              #设置测试时交易产生的浮点
    kdj=STOCHASTICFactor()
    reg_factor("kdj",kdj)
def every_day(context,data):
    for stock in context.stocks:
        out=factor_output("kdj",stock)
        out_prev=factor_output("kdj",stock,"d1",-2)
        k=out["kdj_stochk"]
        d=out["kdj_stochd"]
        k_prev=out_prev["kdj_stochk"]
        d_prev=out_prev["kdj_stochd"]
        if k>d and k_prev<d_prev:
            order_percent(stock,12)
        if k<d and k_prev>d_prev:
            order_target(stock,0)

max/min比值排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def init(context):
    context.bench_mark="shz-000001"
    context.stocks=find_by_group("all-stocks")
    sma_factor=SMAFactor(22,"close")
    max_factor=MAXFactor(22,"close")
    reg_factor("sma",sma_factor)
    reg_factor("max",max_factor)
    reg_expr("rate","sma/max")
    schedule_function(my_func,DateRule.every_day(),TimeRule.once_per_day())
def my_func(context, data):
    output = factor_output_df("rate",context.stocks)
    abc=output.sort(columns="rate").tail(5)
    log.info(abc)
    abc=output.sort(columns="rate").head(5)
    log.info(abc)
    
    rs=output[(output.rate<1)&(output.rate>0.95) ]
    record("size",rs.size )

财务数据示例策略

1
2
3
4
5
6
7
8
9
10
11
12
def init(context):
    context.bench_mark="sha-600498"
    context.slippage=0.003
    schedule_function(select_stocks,DateRule.month(5),TimeRule.market_open(10) )
 
def select_stocks(context,data):
    df = get_fundamentals("brief_roic").sort(['brief_roic'],ascending=False).head(5)
    for pos in context.portfolio.positions.keys():
        order_target(pos,0)
    for stock in df.get("brief_roic").keys():
        log.info("buying stock %s"% stock)
        order_percent(stock,20)

股票组、股票概念

镭矿提供一系列股票组、股票概念供查询

入口地址： http://www.raquant.com/dev/category

使用方法：

1
stocks=find_by_group("all-stocks")

其中传入股票组名称或id均可。