欢迎光临
专业期货策略平台

博易云量化交易开发API参数教程3

交易接口函数

账号集accounts

账号集,context.accounts是所有设置好的交易账号,context.accounts[accountname]是accountname对应的特定交易账号,如context.accounts[“回测期货”]。

用法有:

委托对象order

order 一条订单,具有以下属性:

  • accountname:str类型,所属账号名称,同OnOrderChange/OnTradeDeal事件的AccountName参数;
  • id:str类型,委托编号(OrderID);
  • contract:str类型,合约代码,例如“SR709.CZCE”之类;
  • volume:int型,委托数量;
  • price:float型,委托价格;
  • tradedvol:int型,已成交数量
  • status:int型,0代表初始状态,4代表正在申报,5代表委托单已申报,32代表已完成(终止状态,部成部撤或全部成交),33:下单出错终止
  • InsertTime : 委托时间,返回值为datetime格式的时间
  • CancelTime : 撤单时间,返回值为datetime格式的时间
  • bstype:买卖/开平类别,是一个对象,拥有两个成员BuySellFlag和OffsetFlag;
  • 如:bstype.BuySellFlag :str类型,买卖方向0代表买,1代表卖;
  • bstype.OffsetFlag :str类型,开平方向0代表开仓,1代表平仓,2代表平今

order具有三个方法:

  • order.IsOrderCancelled() :是否已经撤单判断,bool型,已撤单的返回True,没撤单的返回False
  • order.IsOrderRejected() : 是否是废单判断,bool型,废单返回True,非废单返回False
  • order.IsCanCancel(): 是否可撤,bool型,可撤的返回True,不可撤的返回False

持仓对象position

一条持仓,具备以下属性

  • accountname:str类型,所属账号名称,同OnOrderChange/OnTradeDeal事件的AccountName参数;
  • contract:str类型,合约代码,例如“SR709.CZCE”之类;
  • volume:int型,持仓手数
  • availvolume:int型,可用手数
  • openavgprice:float型,开仓均价;
  • holdavgprice:float型,持仓均价
  • bstype:买卖/今昨类别,是一个对象,拥有两个成员BuySellFlag和TodayFlag;
  • 如: bstype.BuySellFlag :str类型,买卖方向0代表买,1代表卖;
  • bstype.TodayFlag :bool类型,True代表今仓,False代表非今仓

成交对象trade

一条当日成交,具有以下属性

  • accountname:str类型,所属账号名称,同OnOrderChange/OnTradeDeal事件的AccountName参数;
  • id:str类型,成交编号(TradeID);
  • orderid:str类型,对应的委托编号(OrderID);
  • contract:str类型,合约代码,例如“SR709.CZCE”之类;
  • volume:int型,成交数量;
  • price:float型,成交价格;
  • TradeTime :成交时间,返回值为datetime格式的时间
  • bstype:买卖/开平类别,是一个对象,拥有两个成员BuySellFlag和OffsetFlag;
  • 如:bstype.BuySellFlag :str类型,买卖方向0代表买,1代表卖;
  • bstype.OffsetFlag :str类型,开平方向0代表开仓,1代表平仓,2代表平今

登录—Login()

登录某个交易账号,交易账号需要先在主页——用户设置——交易账号管理里添加。

参数

返回

bool型,登录成功True,登录失败返回False

示例

if context.accounts.has_key("回测期货") :
    print "登录交易账号 回测期货"
    context.accounts["回测期货"].Login()

登出—Logout()

登出交易账号,回测不需要使用,实跑使用;

参数

返回

None

示例

context.accounts[“回测期货”].Logout()

自动重新登录—SetAutoRelogin

自动重新登录—SetAutoRelogin(datetime),设置交易账号在每天某个时间自动重新登录,不区分交易日/非交易日。
SetAutoRelogin可以在Login()前或Login()后调用,效果相同。
回测时交易账号会在系统内设定的特定时间(期货晚上20:53,期权早上09:13)自动重新登录,无需调用SetAutoRelogin(),调用也不会有预期的效果,但也不会报错。
交易账号的重新登录行为只会在下列两个条件同时满足时才进行:

  • 设定的时间已到;
  • 交易账号处于已登录状态。

参数

datetime 自动重登的时间

False 取消自动重新登录时使用

示例

#每日9点16重登回测期货账号
context.accounts["回测期货"].SetAutoRelogin(datetime.time(09, 16))
#取消自动重新登录
context.accounts["回测期货"].SetAutoRelogin(False)

获取资金状况—AccountBalance

获取账户的资金状况。

参数

示例

bal = context.accounts["回测期货"].AccountBalance
print '资金余额: ' + str(bal.CashBalance)

返回

一个AccountBalance对象,具备以下属性:

  • currency:str类型,货币类型,CNY代表人民币,USD代表美元;
  • CashBalanceYesterday:float型,上日资金余额
  • DynamicNetAssets:float型,动态权益,包含浮动盈亏在内
  • AvailableCashBalance:float型,可用资金
  • AvailableMargin:float型,可用保证金
  • FrozenMargin:float型,持仓冻结保证金
  • FrozenCashForOrder:float型,委托冻结
  • FrozenCashForFee:float型,手续费冻结
  • OtherAvailableCash:float型,其他可用资金 =初始查得的现金资产- (可用 + 冻结)
  • MarketValue:float型,持仓市值
  • AssetsBalance:float型,总资产
  • NetAssets:float型,净资产
  • FloatingProfit:float型,浮动盈亏
  • CashBalance:float型,静态资金余额= 静态可用+ 冻结,不包括未结算的盈亏在内
  • DailyFee:float型,当日手续费
  • RiskDegree:float型,风险度

下单—InsertOrder

下单InsertOrder(code, BSType, price, Volume),下单成功后,可以调用CancelOrder取消交易。

参数

Code:合约代码 + 市场代码

BSType 买卖类型:

  • BuyOpen 买开仓
  • BuyClose 买平仓
  • BuyCloseToday 买平今
  • SellOpen 卖开仓
  • SellClose 卖平仓
  • SellCloseToday 卖平今

Price下单价格,用法可直接用数字,如1000,也可以用.PbPriceType,有多种下单类型,下单价格类型及各交易所的支持情况如下表:

其中,价格类型为限价时,LmitPriceType代表限价类型,仅PriceType为“限价”时本字段有效,int型,1代表指定限价,2代表最新价,3代表买一价,4代表卖一价,5代表涨停价,6代表跌停价,7代表昨收价,8代表昨结价,16代表对手价,17代表挂单价;

LimitPriceOffset限价超价,仅PriceType为“限价”,且仅LimitPriceType为“对手价”、“挂单价”、“最新价”时有意义,输入int型,如OrderParam.LimitPriceOffset = 2,代表超价两个价位。

注意:用到aPriceType = deepcopy(PbPriceType.Limit)写法时,需要在整个策略代码一开始from copy import *

类型名称说明上交所深交所上交所期权深交所期权上期所大商所郑商所中金所上期所期权大商所期权郑商所期权能源交易所
Limit限价(无FOK,无FAK)支持支持支持支持支持支持支持支持支持支持支持支持
LimitFOK限价FOK支持支持支持支持支持支持
LimitFAK限价FAK支持支持支持支持支持支持
Any市价(无FOK,无FAK)支持
AnyFOK市价FOK支持支持支持
AnyFAK市价FAK支持支持支持支持支持
AnyFAL市价FAL支持
Best1FAK最优一档FAK支持
Best1FAL最优一档FAL支持
Best5FAK最优五档FAK支持支持支持支持
Best5FAL最优五档FAL支持支持
DBest对手方最优支持支持
WBest本方最优支持支持

Volume 下单量

返回

bool型,下单成功True,下单失败返回False

示例

#买开沪铜1805,限价不带任何属性
context.accounts["CTP测试"].InsertOrder("cu1805.SHFE", BSType.BuyOpen, 51000, 1)
#市价买开一手豆粕期货
context.accounts["CTP测试"].InsertOrder("m1905.DCE", BSType.BuyOpen, PbPriceType.Any, 1)
#最新价FOK
aPriceType = deepcopy(PbPriceType.Limit)    #限价,别忘记import
aPriceType.LimitPriceType= 2     #最新价
aPriceType.LimitPriceOffset = 10    #限价超价;不需要超价时,可不写
context.accounts["CTP测试"].InsertOrder(”rb1901.SHFE”,BSType.BuyOpen, aPriceType ,2)

下单—InsertOrder2

InsertOrder2(code, BSType, price, Volume),与InsertOrder的主要区别是返回值的不同,InsertOrder2下单后可返回一个用户id,可以用于定位委托单,用GetOrder可以获得对应订单。

参数

Code:合约代码 + 市场代码

BSType 买卖类型:

  • BuyOpen 买开仓
  • BuyClose 买平仓
  • BuyCloseToday 买平今
  • SellOpen 卖开仓
  • SellClose 卖平仓
  • SellCloseToday 卖平今

Price下单价格,同InsertOrder中的价格用法

Volume 下单量

返回

字符串,下单成功返回用户id,下单失败返回None

示例

#买开沪铜1805
aPriceType = deepcopy(PbPriceType.Limit)    #限价,别忘记from copy import *
aPriceType.LimitPriceType= 2     #最新价
context.uid = context.accounts["CTP测试"].InsertOrder2("cu1805.SHFE", BSType.BuyOpen, aPriceType, 1)
def OnOrderChange(context, AccountName, order) :
    print context.uid
    Test = context.accounts["CTP测试"].GetOrder(context.uid)
    print str(Test.status)   

下智能单—InsertSmartOrder

InsertSmartOrder(OrderParam,SplitOrderParam,ReorderParam,CancelOrderParam),可以用来自动追单,自动拆单等下单操作

参数

OrderParam 委托单基本参数:

  • OrderParam.Code:合约代码 + 市场代码
  • OrderParam.BSType 买卖类型:
    BSType.BuyOpen 买开仓
    BSType.BuyClose 买平仓
    BSType.BuyCloseToday 买平今
    BSType.SellOpen 卖开仓
    BSType.SellClose 卖平仓
    BSType.SellCloseToday 卖平今
  • OrderParam.Volume 下单数量
  • OrderParam.PyPriceType下单价格,同InsertOrder中的价格用法

SplitOrderParam 拆单参数:

  • SplitOrderParam.Mode 拆单方式: 0-不拆单 1-固定拆单.2-随机拆单
  • SplitOrderParam.TimeSpan 并发下单的间隔时间(毫秒)
  • SplitOrderParam.MiniVolUnit 最小交易单位,如股票拆单的时候应该设置为100,表示拆出来的数量是100的整数倍,期货的话设置为1就可以了;
  • SplitOrderParam.FixSplit 固定拆单参数对象
    SplitOrderParam.FixSplit.Threshold 阈值: 大于30
    SplitOrderParam.FixSplit.Volume 每次委托数量
  • SplitOrderParam.RandomSplit 随机拆单参数对象
    SplitOrderParam.RandomSplit.Threshold 阈值: 大于30
    SplitOrderParam.RandomSplit.LowerLimit 每次委托下限数量
    SplitOrderParam.RandomSplit.UpperLimit 每次委托上限数量

ReorderParam 追单参数:

  • ReorderParam.LmitPriceType 限价类型,仅PriceType为“限价”时有本字段,int型,1代表指定限价,2代表最新价,3代表买一价,4代表卖一价,5代表涨停价,6代表跌停价,7代表昨收价,8代表昨结价,16代表对手价,17代表挂单价
  • ReorderParam..LimitPriceOffset限价超价,仅PriceType为“限价”时有本字段,仅LimitPriceType为“对手价”、“挂单价”、“最新价”时有意义,输入int型,如OrderParam.LimitPriceOffset = 2,代表超价两个价位。
  • ReorderParam.RepeatTotal 追价总次数
  • ReorderParam.MaxaPriceOffset 追价与首次下单价之差的最大价位,超过就不追了。
  • ReorderParam.TimeOut 超时撤单时间(单位:ms), =0时,不追单

CancelOrderParam 最后一笔追单的撤单参数:

  • CancelOrderParam.TimeOut 超时撤单时间(单位:ms),=0时,不进行最后撤单。

返回

出错时,返回None 成功时,返回ResultInfo:

  • .UID 唯一标识(拆单ID)
  • .ErrorCode 出错码
  • .ErrorInfo 出错信息

示例1

指定价格下一个简单智能单;

def TestSmartOrder(context, code) :

    OrderParam1 = OrderParam()      #生成一个OrderParam对象
    OrderParam1.Code = 'sr905.CZCE'
    OrderParam1.BSType = BSType.BuyOpen
    aPriceType = deepcopy(PbPriceType.Limit)    #限价,别忘记from copy import *
    aPriceType.LimitPriceType= 1  #指定限价
    aPriceType.price = 4997          #具体价格
    OrderParam1.PyPriceType = aPriceType
    OrderParam1.Volume    = 2
    print '下单'
    ret = context.myacc.InsertSmartOrder(OrderParam1) 
    if ret and ret.UID:
        g.UID1 = ret.UID    #成功,记录智能单ID

示例2

对手价下一个简单的智能单。

def TestSmartOrder(context, code) :
    #过滤掉不需要的行情通知
    #if code != g.code :
        #return
    a = GetQuote(g.code)
    print a.now
    OrderParam1 = OrderParam()    #生成一个OrderParam对象
    OrderParam1.Code = g.code
    OrderParam1.BSType = BSType.BuyOpen
    aPriceType = deepcopy(PbPriceType.Limit)    #限价,别忘记from copy import *
    aPriceType.LimitPriceType= 16     #对手价
    aPriceType.LimitPriceOffset = 10    #限价超价;不需要超价时,可不写
    OrderParam1.PyPriceType = aPriceType
    OrderParam1.Volume    = 2
    print '下单'
    ret = context.myacc.InsertSmartOrder(OrderParam1) 
    if ret and ret.UID:
        g.UID1 = ret.UID    #成功,记录智能单ID

示例3

下一个固定数量拆单的智能单,每次下单数量拆成5手5手下单。

def TestSmartOrder(context, code) :
    #过滤掉不需要的行情通知
    #if code != g.code :
        #return
    a = GetQuote(g.code)
    print a.now
    OrderParam1 = OrderParam()    #生成一个OrderParam对象
    OrderParam1.Code = g.code
    OrderParam1.BSType = BSType.BuyOpen
    aPriceType = deepcopy(PbPriceType.Limit)    #限价,别忘记from copy import *
    aPriceType.LimitPriceType= 2     #最新价
    aPriceType.LimitPriceOffset = 10    #限价超价;不需要超价时,可不写
    OrderParam1.PyPriceType = aPriceType
    OrderParam1.Volume    = 12
    SplitOrderParam1 = SplitOrderParam()    #生成一个SplitOrderParam对象
    SplitOrderParam1. Mode = 1  #拆单方式: 0-不拆单 1-固定拆单.2-随机拆单 
    SplitOrderParam1. TimeSpan = 100    #下单的间隔时间(毫秒)
    #固定拆单
    SplitOrderParam1. FixSplit.Threshold = 5  #阈值: 大于5手
    SplitOrderParam1. FixSplit.Volume=5    #每次委托数量=5
    ret = context.myacc.InsertSmartOrder(OrderParam1,SplitOrderParam1) 
    if ret and ret.UID:
        g.UID2 = ret.UID    #成功,记录智能单ID

示例4

下一个随机数量拆单并且能追单的智能单,下单数量超过10手时,以3~6之间随机数量下单,如果不成交,以对手价追价,最多追三次。

def TestSmartOrder(context, code) :
    #过滤掉不需要的行情通知
    #if code != g.code :
        #return
    a = GetQuote(g.code)
    print a.now
    OrderParam1 = OrderParam()    #生成一个OrderParam对象
    OrderParam1.Code = g.code
    OrderParam1.BSType = BSType.BuyOpen
    aPriceType = deepcopy(PbPriceType.Limit)    #限价,别忘记from copy import *
    aPriceType.LimitPriceType= 2     #最新价
    aPriceType.LimitPriceOffset = 10    #限价超价;不需要超价时,可不写
    OrderParam1.PyPriceType = aPriceType
    OrderParam1.Volume    = 12
    SplitOrderParam1 = SplitOrderParam()    #生成一个SplitOrderParam对象
    SplitOrderParam1. Mode = 2  #拆单方式: 0-不拆单 1-固定拆单.2-随机拆单 
    SplitOrderParam1. TimeSpan = 100    #下单的间隔时间(毫秒)
    #随机拆单
    SplitOrderParam1. RandomSplit.Threshold = 10     #阈值: 大于5手
    SplitOrderParam1. RandomSplit.LowerLimit = 3    #每次委托下限数量
    SplitOrderParam1. RandomSplit.UpperLimit = 6    #每次委托上限数量
    #追单参数
    ReorderParam1 = ReorderParam()
    ReorderParam1 .PriceType = '2'  #价格类型: 限价(默认)
    ReorderParam1 .LimitPriceType= 16  #限价类型:对手价
    ReorderParam1 .LimitPriceOffset = 2    #限价超价
    ReorderParam1 .RepeatTotal = 3        #追价总次数
    ReorderParam1 .MaxaPriceOffset = 100 #追价与首次下单价之差的最大价位
    ReorderParam1 .TimeOut = 800        #超时撤单时间(单位:ms), =0时,不追单
    #最后撤单参数
    CancelOrderParam1 = CancelOrderParam()
    CancelOrderParam1 .TimeOut = 1500   #最后超时撤单时间(单位:ms)
    ret = context.myacc.InsertSmartOrder(OrderParam1,SplitOrderParam1,ReorderParam1,CancelOrderParam1) 
    if ret and ret.UID:
        g.UID3 = ret.UID    #成功,记录智能单ID

获取智能单参数—GetSmartOrderItem

获取智能单参数—GetSmartOrderItem(UID),可以在智能单下单以后,获取智能单的参数信息;

参数

UID: 智能单ID (必填),下智能单的返回值对象中的UID

返回

返回SmartOrderItem智能单参数对象,属性有:

  • .OrderParam 委托单参数
  • .SplitOrderParam 拆单参数
  • .ReorderParam 追单参数
  • .CancelOrderParam 最后撤单参数

注:以上参数对象属性参照下智能单InsertSmartOrder

示例

myacc = context.accounts["期货测试"]
ret = myacc.GetSmartOrderItem(g.UID3)  #g.UID3接下智能单InsertSmartOrder最后一个示例

获取智能单执行状态信息—GetSmartOrderStatus

获取智能单执行状态信息—GetSmartOrderStatus(UID),可以在智能单下单以后,获取智能单的状态信息;

参数

UID: 智能单ID (必填),下智能单的返回值对象中的UID

返回

返回SmartOrderStatus智能单执行状态对象,对象成员有:

  • .UID 智能单ID
  • .OrderNo 委托编号(普通委托时为效),当智能单只有最简单参数,没有追单和拆单参数时,会当做普通委托处理,可以看委托编号;
  • .State 智能执行状态字,返回是int型,2代表执行中,3是首单已请求,6是已有成交还没完全完成,32是智能单已完成;
  • .ErrorCode 出错码
  • .ErrorInfo 出错信息
  • .VolumeTotal 委托总数量
  • .VolumeRemain 未拆单剩余数量(拆单时为效)
  • .VolumeTraded 已成交数量
  • .ReorderTotal 追单总次数(=0只有首次下单,没有追单)
  • .OrderNbr 已下单次数, 包括下首单(追单时为效)
  • .SubOrderIDs子单ID列表[uid1,uid2,…]

示例

myacc = context.accounts["期货测试"]
ret = myacc.GetSmartOrderStatus(g.UID3)  #g.UID3接下智能单InsertSmartOrder最后一个示例

中止智能单—KillOrder

中止智能单—KillOrder(UID, CancelOrder),可以在智能单进行中,不需要继续的时候,中止智能单;

参数

UID: 智能单ID (必填),下智能单的返回值对象中的UID

CancelOrder:是否需要撤单标志(可选参数,默认为不撤单),决定是否撤销已发未成交的委托单;bool型,True -需要撤单, False-不撤单;

注:目前对于拆单和组合单,不支持撤单(CancelOrder=True)参数

返回

返回一个对象,属性有:

  • .UID 唯一标识(组合单ID)
  • .ErrorCode 出错码,小于0的时候,代表有出错,可以拿出错信息。
  • .ErrorInfo 出错信息

示例

myacc = context.accounts["期货测试"]
ret = myacc.KillOrder(g.UID1) # 不需要撤销已发未成的单子
myacc = context.accounts["期货测试"]
ret = myacc.KillOrder(g.UID1,True) # 需要撤销已发未成的单子,目前对于拆单和组合单,不支持撤单(CancelOrder=True)参数

组合单

与组合单有关的API主要有三个,分别是下组合单InsertComboOrder、获取组合单参数信息GetComboOrderItem、获取组合单执行状态信息GetComboOrderStatus

我们首先先看到下组合单—InsertComboOrder(ComboOrderParam, SmartOrders)

参数

ComboOrderParam :组合单参数,一个对象成员,属性有:

  • .UID 组合单ID(下单时不用填写)
  • .TimeSpan 并发下单时的间隙时间,单位:毫秒 如 ComboOrderParam.TimeSpan = 1000,即每秒下一单,想要单子一起发出时,=0即可。

SmartOrders :有一个个智能单组成的列表,[SmartOrderItem1, SmartOrderItem2,… ]

返回

返回一个对象,属性有:

  • .UID 唯一标识(组合单ID)
  • .ErrorCode 出错码,小于0的时候,代表有出错,可以拿出错信息。
  • .ErrorInfo 出错信息

接下来我们看获取组合单参数信息—GetComboOrderItem(UID)

参数

UID :下组合单后返回的ID

返回

返回组合单对象,属性有:

  • .UID 组合单ID
  • .ComboOrderParam 组合单参数对象,属性同下组合单InsertComboOrder里的ComboOrderParam;
  • .SmartOrders 智能单列表,组合单中所有订单对象组成的列表

最后我们有时需要看组合单有没有完成,就需要对状态进行追踪,用到获取组合单执行状态信息GetComboOrderStatus(UID)

参数

UID :下组合单后返回的ID

返回

状态对象,属性有

  • .UID 组合单ID
  • .State 智能执行状态字,返回结果对照:1代表开始下智能单,2代表执行中,32表示已完成,详细结果由出错码和出错信息给出;
  • .ErrorCode 出错码
  • .ErrorInfo 出错信息
  • .SubOrderIDs 子单ID列表[uid1,uid2,…]

示例

#!/usr/bin/env python
# coding:utf-8
from PoboAPI import *
import datetime
from copy import *
#开始时间,用于初始化一些参数
def OnStart(context) :
    print "I\'m starting..."
    #设定一个全局变量品种
    g.code = "rb1905.SHFE"
    #订阅实时数据,用于驱动OnQuote事件
    SubscribeQuote(g.code)
    #SubscribeQuote(g.code)
    #订阅K线数据,用于驱动OnBar事件
    #SubscribeBar(g.code, BarType.Min5)
    #登录交易账号,需在主页用户管理中设置账号,并把证券测试替换成您的账户名称
    context.myacc = None
    #设一个12月5号以后,每天下午2重复触发的日程
    context.MySchedule1 = SetSchedule(datetime.datetime(2018, 12,5, 14, 0), RepeatType.Daily)
    if context.accounts.has_key("期货测试") :
        print "登录交易账号[期货测试]"
        if context.accounts["期货测试"].Login() :
            context.myacc = context.accounts["期货测试"]

#调用日程事件,从12月5号后,每天下午2点下组合单,用户可自行调整时间
def OnSchedule(context, scheduleid):
    d = GetCurrentTime().strftime('%Y%m%d')
    if d != str(GetCurrentTradingDate('SHFE')):
        print '非交易日'
        return

    zhuli1 = GetMainContract('DCE', 'm',20)
    zhuli2 = GetMainContract('SHFE', 'ag',20)
    zhuli3 = GetMainContract('CZCE', 'sr',20)
    zhuli4 = GetMainContract('CFFEX', 'if',20)
    ind = [zhuli1,zhuli2,zhuli3,zhuli4]
    i = 0
    SmartOrders = []
    while i < len(ind):
        order = Test(context,ind[i]) #生成一张订单
        SmartOrders.append(order)   #把订单放在一个list里
        i+=1
    #生成一个ComboOrderParam组合单参数对象
    ComboOrderParam1 = ComboOrderParam()
    ComboOrderParam1.TimeSpan = 0  #并发下单时的间隙时间,单位:毫秒
    ret = context.myacc.InsertComboOrder(ComboOrderParam1 ,SmartOrders)  #按之前的订单list下组合单
    if ret and ret.UID:
        g.UID6 = ret.UID    #成功,记录组合单ID,可用于后期追踪订单使用
        item1 = context.myacc.GetComboOrderItem(g.UID6) #获取组合单参数信息
        status1 = context.myacc.GetComboOrderStatus(g.UID6)  #获取组合单状态对象
        if status1.State == 2:
            print '执行中'
        elif status1.State == 32:
            print '组合单已完成'

def Test(context, code):
    OrderParam1 = OrderParam()    #生成一个OrderParam对象
    OrderParam1.Code = code
    OrderParam1.BSType = BSType.Buy
    aPriceType = deepcopy(PbPriceType.Limit)    #限价,别忘记from copy import *
    aPriceType.LimitPriceType= 16     #对手价
    #aPriceType.LimitPriceOffset = 10    #限价超价;不需要超价时,可不写
    OrderParam1.PyPriceType = aPriceType
    OrderParam1.Volume    = 10

    #追单参数
    ReorderParam1 = ReorderParam()    #生成一个ReorderParam对象
    ReorderParam1 .PriceType =TPriceType.LimitPrice  #价格类型: 限价(默认)
    ReorderParam1 .LimitPriceType=TLimitPriceType.OrderRival  #限价类型:对手价
    ReorderParam1 .LimitPriceOffset = 1    #限价超价
    ReorderParam1 .RepeatTotal = 2        #追价总次数
    ReorderParam1 .MaxaPriceOffset = 900 #追价与首次下单价之差的最大价位
    ReorderParam1 .TimeOut = 900         #超时撤单时间(单位:ms)

    #最后撤单参数
    CancelOrderParam1 = CancelOrderParam()    #生成一个CancelOrderParam对象
    CancelOrderParam1 .TimeOut = 1500   #最后超时撤单时间(单位:ms)
    SmartOrderItem1 = context.myacc.NewSmartOrderItem(OrderParam1,ReorderParam1,CancelOrderParam1) 
    return SmartOrderItem1

撤单—CancelOrder

撤单—CancelOrder(orderid)或CancelOrder(order)

参数

orderid委托编号 也支持直接用order对象

返回

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

示例

def OnOrderChange(context, AccountName, order) :
    context.accounts["回测期货"].CancelOrder(order)

获取可开数量—GetValidVolume

获取可开数量—GetValidVolume(code, BSType,price),基于某个价格买卖方向计算某一品种的可开数量

参数

Code:合约代码 + 市场代码

BSType 买卖类型,用法同下单—InsertOrder中的BSType

Price 价格

返回

计算出来的可开数量

示例

if klinedata[len(klinedata)-1].close < klinedata[len(klinedata)-2].close :
    #下单前获取可开数量
    n = context.accounts["回测期货"].GetValidVolume("rb1905.SHFE",BSType.BuyOpen,3382)
    print '可开数量:' + str(n)
    # 当日收盘价小于昨收则买入     
    context.accounts["回测期货"].InsertOrder("rb1901.SHFE", BSType.BuyOpen, dyndata.now, 1)

获取所有委托信息—GetOrders

获取所有委托信息—GetOrders(option),获取整个委托列表

参数

option,筛选委托单的参数,为空是获取所有委托单。

可支持:

  • option.contract 按合约代码筛选,str类型,合约代码,例如“SR709.CZCE”之类;
  • option.buysellflag 按买卖方向筛选 ,str类型,买卖方向0代表买,1代表卖;
  • option.offsetflag 按开平方向筛选,str类型,开平方向0代表开仓,1代表平仓,2代表平今
  • option.status 按委托单状态筛选,status:int型,0代表初始状态,4代表正在申报,5代表委托单已申报,32代表已完成(终止状态,部成部撤或全部成交),33:下单出错终止

示例

option = PBObj()
option.buysellflag = '0'
ods = context.accounts["回测期货"].GetOrders(option)
print ods
for i in ods:
    print i.bstype.BuySellFlag
    print i.bstype.OffsetFlag
print '----------------'

返回

一个list,包含所有的委托单信息,里面包括多个order对象。

获取订单信息—GetOrder

获取订单信息—GetOrder(orderid)或GetOrder(uid),获取某一订单的信息

参数

orderid委托单的ID

或uid 用InsertOrder2下单返回的结果

返回

一个order对象

示例

def OnOrderChange(context, AccountName, order) :
    Test = context.accounts["回测期货"].GetOrder(order.id)
    print str(Test.volume)

获取所有成交信息—GetTradeDetails

获取所有成交信息—GetTradeDetails (option),获取当天的所有成交记录, 一个订单可能分多次成交

参数

option,筛选成交记录的参数,为空是获取所有成交记录。

可支持:

  • option.contract 按合约代码筛选,str类型,合约代码,例如“SR709.CZCE”之类;
  • option.buysellflag 按买卖方向筛选 ,str类型,买卖方向0代表买,1代表卖;
  • option.offsetflag 按开平方向筛选,str类型,开平方向0代表开仓,1代表平仓,2代表平今

示例

option = PBObj()
option.buysellflag = '0'
TradeDetails = context.accounts["回测期货"].GetTradeDetails(option)
print TradeDetails
for i in TradeDetails:
    print i.bstype.BuySellFlag
    print i.bstype.OffsetFlag
print '----------------'

返回

一个list,包含所有的成交单信息,包括多个trade对象

获取成交信息—GetTradeDetail

获取成交信息—GetTradeDetail(id,BuySellFlag),获取某一成交单的信息

参数

Id 成交单的ID

BuySellFlag 买卖方向,str类型,’0’代表买,’1’代表卖;

返回

一个trade对象,ID对应的成交的信息。

示例

def OnTradeDeal(context, AccountName, trade) :
    TR = context.accounts["回测期货"].GetTradeDetail(trade.id, trade.bstype.BuySellFlag)
    print '成交价格:' + str(TR.price)

获取持仓信息—GetPositions

获取所有的持仓信息—GetPositions(option)

参数

option,筛选持仓记录的参数,为空是获取所有持仓记录。

可支持:

  • option.contract 按合约代码筛选,str类型,合约代码,例如“SR709.CZCE”之类;
  • option.buysellflag 按买卖方向筛选 ,str类型,买卖方向0代表买,1代表卖;
  • option.todayflag 按开平方向筛选,bool类型,True代表今仓,False代表非今仓
  • option.coveredtype 期权有效,备兑标志,str类型 ‘0’ : 非备兑, ‘1’ : 备兑

示例

option = PBObj()
option.buysellflag = '0'
pos = context.accounts["回测期货"].GetPositions(option)
print pos
for i in pos:
    print i.bstype.contract
print '----------------'

返回

一个list,里面有多个Position对象

保证金费率

查询或设置所交易品种的保证金费率,期货和期权有效。

  • 同步柜台保证金费率 —— RefreshMargin(code, BSType)
  • 设置指定保证金费率 —— SetMargin(code, value, BSType)
  • 获取指定保证金费率 —— GetMargin(code, BSType) 返回value对象(保证金比例)

目前平台中期货和期权品种交易的时候,保证金和手续费都是一个默认值,可能与您的实际情况不一致;

在回测当中,我们可以用SetMargin(code, value, BSType)来指定费率,做到回测的费率尽量和实际一致;

在策略实跑中,当我们希望我们的交易费率与交易柜台一致时,可以用RefreshMargin(code, BSType)来向柜台同步费率,这个时候我们是不能用SetMargin的,因为实际交易我们无法修改柜台的费率。

参数

code: str类型,合约代码,例如“SR709.CZCE”之类;

BSType:买入卖出方向,查询或者设置时可不填,如果不填则同时更新或设置买和卖两个方向,GetMargin时必须要指定是获取买入的还是卖出的。

  • BSType.Buy 买入
  • BSType.Sell 卖出

value: 设置保证金费率数值的对象,用法如下:

  • value.Unit 每手保证金
  • value.Rate 保证金金额比例

示例

设置了三个闹钟,第一个闹钟触发时,调用策略里面封装的TestSetmargin函数设置保证金,闹钟2直接获取并打印,闹钟3刷新后获取并打印,实际使用中我们可以根据情况选择使用设置或同步柜台费率。

#!/usr/bin/env python
# coding:utf-8
from PoboAPI import *
import datetime

#开始时间,用于初始化一些参数
def OnStart(context) :
    print "I\'m starting..."
    #设定一个全局变量品种
    g.code = "rb1905.SHFE"
    #登录交易账号,需在主页用户管理中设置账号,并把证券测试替换成您的账户名称
    context.myacc = None
    if context.accounts.has_key("期货测试") :
        print "登录交易账号[期货测试]"
        if context.accounts["期货测试"].Login() :
            context.myacc = context.accounts["期货测试"]

    context.MyAlarm1 = SetAlarm(datetime.time(11, 10), RepeatType.Daily)
    context.MyAlarm2 = SetAlarm(datetime.time(11, 11), RepeatType.Daily)
    context.MyAlarm3 = SetAlarm(datetime.time(11, 12), RepeatType.Daily)
def OnAlarm(context, alarmid) :
    if alarmid==context.MyAlarm1:
      print '设置保证金率'
      TestSetmargin(context,g.code)
    if alarmid==context.MyAlarm2:
      print '获取保证金率'
      a = context.myacc.GetMargin(g.code,BSType.Buy)
      print a.Unit
      print a.Rate
    elif alarmid==context.MyAlarm3:
      print '刷新后获取保证金率'
      context.myacc.RefreshMargin(g.code,BSType.Buy)
      a2 = context.myacc.GetMargin(g.code,BSType.Buy)
      print a2
      print a2.Unit
      print a2.Rate
def TestSetmargin(context,code):
    value = PBObj()
    value.Rate = 0.5
    context.myacc.SetMargin(code, value, BSType.Buy)

手续费率

  • 同步柜台的手续费率 —— RefreshFee(code)
  • 设置指定手续费率 —— SetFee(code, value)
  • 获取指定手续费率 —— GetFee(code) 返回value对象(手续费比例)

目前平台中期货和期权品种交易的时候,保证金和手续费都是一个默认值,可能与您的实际情况不一致;

在回测当中,我们可以用SetFee(code, value)来指定费率,做到回测的费率尽量和实际一致;

在策略实跑中,当我们希望我们的交易费率与交易柜台一致时,可以用RefreshFee(code)来向柜台同步费率,这个时候我们是不能用SetFee的,因为实际交易我们无法修改柜台的费率。

参数

code: str类型,合约代码,例如“SR709.CZCE”之类;

value: 设置手续费费率数值的对象,用法如下:

  • value.MiniFee 最小手续费
  • value.OpenUnit 开仓每(张)手续费
  • value.OpenRate 开仓手续费金额比例
  • value.CloseUnit 平仓每(张)手续费
  • value.CloseRate 平仓手续费金额比例
  • value.CloseTodayUnit 平今每(张)手续费
  • value.CloseTodayRate 平今手续费金额比例

示例

设置了三个闹钟,第一个闹钟触发时,调用策略里面封装的TestSetFeeRate函数设置手续费,闹钟2直接获取并打印,闹钟3刷新后获取并打印,实际使用中我们可以根据情况选择使用设置或同步柜台费率。

#!/usr/bin/env python
# coding:utf-8
from PoboAPI import *
import datetime

#开始时间,用于初始化一些参数
def OnStart(context) :
    print "I\'m starting..."
    #设定一个全局变量品种
    g.code = "rb1905.SHFE"
    #登录交易账号,需在主页用户管理中设置账号,并把证券测试替换成您的账户名称
    context.myacc = None
    if context.accounts.has_key("期货测试") :
        print "登录交易账号[期货测试]"
        if context.accounts["期货测试"].Login() :
            context.myacc = context.accounts["期货测试"]

    context.MyAlarm1 = SetAlarm(datetime.time(11, 10), RepeatType.Daily)
    context.MyAlarm2 = SetAlarm(datetime.time(11, 11), RepeatType.Daily)
    context.MyAlarm3 = SetAlarm(datetime.time(11, 12), RepeatType.Daily)


def OnAlarm(context, alarmid) :
    if alarmid==context.MyAlarm1:
      print '设置手续费率'
      TestSetFeeRate(context)
    if alarmid==context.MyAlarm2:
      print '获取手续费'
      b = context.myacc.GetFee(g.code)
      print b.OpenUnit
      print b.OpenRate
      print b.CloseUnit
      print b.CloseRate
      print b.CloseTodayUnit
      print b.CloseTodayRate
      print b.MiniFee
    elif alarmid==context.MyAlarm3:
      print '刷新后获取手续费'
      context.myacc.RefreshFee(g.code)
      b = context.myacc.GetFee(g.code)
      print b.OpenUnit
      print b.OpenRate
      print b.CloseUnit
      print b.CloseRate
      print b.CloseTodayUnit
      print b.CloseTodayRate
      print b.MiniFee

def TestSetFeeRate(context):
    if not context.myacc:
      return

    fee = PBObj();
    fee.OpenUnit = 3
    fee.OpenRate = 0.003

    fee.CloseUnit = 4
    fee.CloseRate = 0.004    

    fee.CloseTodayUnit = 5
    fee.CloseTodayRate = 0.005    

    fee.MiniFee = 0
    context.myacc.SetFee(g.code, fee) 
0 0 vote
Article Rating
Click to rate this post!
[Total: 0 Average: 0]
赞(0) 打赏
未经允许不得转载:A期客 » 博易云量化交易开发API参数教程3
订阅
提醒
guest
0 评论
Inline Feedbacks
View all comments

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

0
Would love your thoughts, please comment.x
()
x