交易接口函数

账号集accounts

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

用法有：

• context.accounts.has_key(accountname)：检查账号集中是否有accountname这个账号名称对应的账号，如context.accounts.has_key(“回测期货”)为检查是否有回测期货这个账号。
• context.accounts[accountname]常见方法：登录账号 、登出账号 、 自动重新登录 、 获取资金状况 、 下单 、 下单2 、 下智能单 、 撤单 、 获取可开数量 、 获取所有委托单 、 获取某一委托单信息 、 获取全部当日成交 、 获取某一成交单信息 、 获取持仓 、保证金率 、手续费率 、 常用风控

委托对象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 *

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)