Trade
GetOrder - 查询指定订单
查询指定订单的详细信息，包括订单状态、成交量、价格等。
语法
python
order = exchange.GetOrder(order_id)参数
| 参数 | 类型 | 说明 |
|---|---|---|
| order_id | int/str | 订单ID（由 Buy/Sell 返回） |
返回值
返回订单对象（dict），失败返回 None。
| 字段 | 类型 | 说明 |
|---|---|---|
| Id | str | 订单唯一标识 |
| Price | float | 订单价格 |
| Amount | float | 订单数量 |
| DealAmount | float | 已成交数量 |
| AvgPrice | float | 成交均价 |
| Status | int | 订单状态（0=未完成, 1=已完成, 2=已取消） |
| Type | int | 订单类型（0=买单, 1=卖单） |
| Offset | int | 期货开平方向（0=开仓, 1=平仓） |
| ContractType | str | 合约类型（期货） |
示例
1. 基础订单查询
python
# 下单并获取订单ID
order_id = exchange.Buy(100, 0.1)
# 查询订单详情
order = exchange.GetOrder(order_id)
if order:
Log("订单状态:", order["Status"])
Log("已成交:", order["DealAmount"])
Log("成交均价:", order["AvgPrice"])
else:
Log("订单不存在或查询失败")2. 等待订单完全成交
python
def wait_order_filled(order_id, timeout=30):
"""
等待订单完全成交
timeout: 超时时间（秒）
返回: True=成交, False=超时
"""
start_time = time.time()
while time.time() - start_time < timeout:
order = exchange.GetOrder(order_id)
if not order:
Log("订单查询失败")
return False
if order["Status"] == 1: # 完全成交
Log(f"订单已成交, 均价: {order['AvgPrice']}")
return True
elif order["Status"] == 2: # 已取消
Log("订单已被取消")
return False
Sleep(1000) # 每秒查询一次
Log("等待订单超时")
return False
# 使用
order_id = exchange.Buy(100, 0.1)
if wait_order_filled(order_id):
Log("可以继续下一步操作")3. 监控订单并补单
python
# 下限价单
order_id = exchange.Buy(100, 0.1)
Sleep(5000) # 等待5秒
# 检查成交情况
order = exchange.GetOrder(order_id)
if order:
fill_ratio = order["DealAmount"] / order["Amount"]
if fill_ratio < 0.5: # 成交不到50%
Log("订单成交缓慢，撤单重新下单")
exchange.CancelOrder(order_id)
# 以市价补单
remaining = order["Amount"] - order["DealAmount"]
exchange.Buy(-1, remaining) # 市价买入4. 计算订单盈亏
python
# 做市策略：计算买卖订单差价盈利
buy_order_id = exchange.Buy(100, 0.1)
Sleep(60000) # 等待买单成交
buy_order = exchange.GetOrder(buy_order_id)
if buy_order and buy_order["Status"] == 1:
# 以更高价卖出
sell_price = buy_order["AvgPrice"] * 1.01
sell_order_id = exchange.Sell(sell_price, buy_order["DealAmount"])
Sleep(60000)
sell_order = exchange.GetOrder(sell_order_id)
if sell_order and sell_order["Status"] == 1:
profit = (sell_order["AvgPrice"] - buy_order["AvgPrice"]) * sell_order["DealAmount"]
Log(f"本轮盈利: {profit}")5. 订单状态跟踪
python
def track_order_status(order_id):
"""详细跟踪订单状态变化"""
last_deal_amount = 0
while True:
order = exchange.GetOrder(order_id)
if not order:
break
# 检测到新成交
if order["DealAmount"] > last_deal_amount:
new_deal = order["DealAmount"] - last_deal_amount
Log(f"新成交 {new_deal}, 累计成交 {order['DealAmount']}/{order['Amount']}")
last_deal_amount = order["DealAmount"]
# 订单结束
if order["Status"] in [1, 2]:
if order["Status"] == 1:
Log(f"订单完全成交, 均价: {order['AvgPrice']}")
else:
Log(f"订单已取消, 成交: {order['DealAmount']}/{order['Amount']}")
break
Sleep(1000)
# 使用
order_id = exchange.Buy(100, 0.5)
track_order_status(order_id)6. 批量订单查询
python
# 同时下多个订单
order_ids = []
prices = [100, 101, 102, 103, 104]
for price in prices:
order_id = exchange.Buy(price, 0.1)
if order_id:
order_ids.append(order_id)
# 等待一段时间后检查
Sleep(30000)
# 查询所有订单状态
for order_id in order_ids:
order = exchange.GetOrder(order_id)
if order:
status_text = ["未完成", "已完成", "已取消"][order["Status"]]
fill_ratio = (order["DealAmount"] / order["Amount"]) * 100
Log(f"订单 {order_id}: {status_text}, 成交率 {fill_ratio:.1f}%")7. 部分成交处理
python
# 下单
order_id = exchange.Buy(100, 1.0)
Sleep(10000)
# 检查部分成交情况
order = exchange.GetOrder(order_id)
if order and order["Status"] == 0: # 未完成
if order["DealAmount"] > 0: # 有部分成交
Log(f"部分成交: {order['DealAmount']}/{order['Amount']}")
# 取消未成交部分
exchange.CancelOrder(order_id)
# 记录已成交的数量
filled_amount = order["DealAmount"]
Log(f"已购买 {filled_amount} 个币")8. 合约订单查询
python
# 合约开仓
exchange.SetContractType("swap")
exchange.SetDirection("buy") # 开多
order_id = exchange.Buy(50000, 100)
# 查询合约订单
Sleep(2000)
order = exchange.GetOrder(order_id)
if order:
Log("合约类型:", order["ContractType"])
Log("开平方向:", "开仓" if order["Offset"] == 0 else "平仓")
Log("买卖方向:", "买入" if order["Type"] == 0 else "卖出")
Log("成交数量:", order["DealAmount"], "张")
Log("成交均价:", order["AvgPrice"])9. 冰山订单实现
python
def iceberg_order(total_amount, display_amount, price):
"""
冰山订单：分批下单，避免暴露总量
total_amount: 总下单量
display_amount: 每次显示的数量
price: 下单价格
"""
filled_total = 0
while filled_total < total_amount:
# 下单
remaining = total_amount - filled_total
current_amount = min(display_amount, remaining)
order_id = exchange.Buy(price, current_amount)
if not order_id:
Log("下单失败")
break
# 等待成交
while True:
order = exchange.GetOrder(order_id)
if not order:
break
if order["Status"] == 1: # 完全成交
filled_total += order["DealAmount"]
Log(f"累计成交: {filled_total}/{total_amount}")
break
elif order["Status"] == 2: # 已取消
filled_total += order["DealAmount"]
break
Sleep(1000)
Sleep(500) # 等待一下再下下一单
Log(f"冰山订单完成，总成交: {filled_total}")
return filled_total
# 使用：总共买入10个，每次只显示1个
iceberg_order(10.0, 1.0, 100)10. 订单超时自动撤单
python
def order_with_timeout(price, amount, timeout=30):
"""
带超时的订单，超时未成交自动撤单
返回: 实际成交量
"""
order_id = exchange.Buy(price, amount)
if not order_id:
return 0
start_time = time.time()
while time.time() - start_time < timeout:
order = exchange.GetOrder(order_id)
if not order:
return 0
if order["Status"] == 1: # 完全成交
return order["DealAmount"]
Sleep(1000)
# 超时，撤单
Log("订单超时，执行撤单")
exchange.CancelOrder(order_id)
Sleep(1000)
# 返回部分成交量
order = exchange.GetOrder(order_id)
if order:
return order["DealAmount"]
return 0
# 使用
filled = order_with_timeout(100, 0.5, timeout=60)
Log(f"实际成交: {filled}")注意事项
- 订单ID类型：不同交易所返回的订单ID可能是字符串或整数，注意类型转换
- 查询频率：避免频繁查询同一订单，建议间隔至少1秒
- 订单过期：部分交易所的历史订单可能无法查询，建议及时保存订单信息
- 状态判断：订单状态值可能因交易所而异，建议封装统一的状态判断函数
- 网络异常：查询失败时返回
None，需要做好异常处理 - 合约订单：合约订单包含额外的
Offset和ContractType字段