注册登录

QMT Python API

行情示例

获取行情示例

qmt://docs/python
Python
1# 用前须知
2 
3## xtdata提供和MiniQmt的交互接口，本质是和MiniQmt建立连接，由MiniQmt处理行情数据请求，再把结果回传返回到python层。使用的行情服务器以及能获取到的行情数据和MiniQmt是一致的，要检查数据或者切换连接时直接操作MiniQmt即可。
4 
5## 对于数据获取接口，使用时需要先确保MiniQmt已有所需要的数据，如果不足可以通过补充数据接口补充，再调用数据获取接口获取。
6 
7## 对于订阅接口，直接设置数据回调，数据到来时会由回调返回。订阅接收到的数据一般会保存下来，同种数据不需要再单独补充。
8 
9# 代码讲解
10 
11# 从本地python导入xtquant库，如果出现报错则说明安装失败
12from xtquant import xtdata
13import time
14 
15# 设定一个标的列表
16code_list = ["000001.SZ"]
17# 设定获取数据的周期
18period = "1d"
19 
20# 下载标的行情数据
21if 1:
22 ## 为了方便用户进行数据管理，xtquant的大部分历史数据都是以压缩形式存储在本地的
23 ## 比如行情数据，需要通过download_history_data下载，财务数据需要通过
24 ## 所以在取历史数据之前，我们需要调用数据下载接口，将数据下载到本地
25 for i in code_list:
26 xtdata.download_history_data(i,period=period,incrementally=True) # 增量下载行情数据（开高低收,等等）到本地
27
28 xtdata.download_financial_data(code_list) # 下载财务数据到本地
29 xtdata.download_sector_data() # 下载板块数据到本地
30 # 更多数据的下载方式可以通过数据字典查询
31 
32# 读取本地历史行情数据
33history_data = xtdata.get_market_data_ex([],code_list,period=period,count=-1)
34print(history_data)
35print("=" * 20)
36 
37# 如果需要盘中的实时行情，需要向服务器进行订阅后才能获取
38# 订阅后，get_market_data函数于get_market_data_ex函数将会自动拼接本地历史行情与服务器实时行情
39 
40# 向服务器订阅数据
41for i in code_list:
42 xtdata.subscribe_quote(i,period=period,count=-1) # 设置count = -1来取到当天所有实时行情
43 
44# 等待订阅完成
45time.sleep(1)
46 
47# 获取订阅后的行情
48kline_data = xtdata.get_market_data_ex([],code_list,period=period)
49print(kline_data)
50 
51# 获取订阅后的行情，并以固定间隔进行刷新,预期会循环打印10次
52for i in range(10):
53 # 这边做演示，就用for来循环了，实际使用中可以用while True
54 kline_data = xtdata.get_market_data_ex([],code_list,period=period)
55 print(kline_data)
56 time.sleep(3) # 三秒后再次获取行情
57 
58# 如果不想用固定间隔触发，可以以用订阅后的回调来执行
59# 这种模式下当订阅的callback回调函数将会异步的执行，每当订阅的标的tick发生变化更新，callback回调函数就会被调用一次
60# 本地已有的数据不会触发callback
61
62# 定义的回测函数
63 ## 回调函数中，data是本次触发回调的数据，只有一条
64def f(data):
65 # print(data)
66
67 code_list = list(data.keys()) # 获取到本次触发的标的代码
68 
69 kline_in_callabck = xtdata.get_market_data_ex([],code_list,period = period) # 在回调中获取klines数据
70 print(kline_in_callabck)
71 
72for i in code_list:
73 xtdata.subscribe_quote(i,period=period,count=-1,callback=f) # 订阅时设定回调函数
74 
75# 使用回调时，必须要同时使用xtdata.run()来阻塞程序，否则程序运行到最后一行就直接结束退出了。
76xtdata.run()
77 
78 
79 

连接VIP服务器

qmt://docs/python
Python
1# 导入 xtdatacenter 模块
2import sys
3 
4print("Python 版本：", sys.version)
5 
6 
7import time
8import pandas as pd
9from xtquant import xtdatacenter as xtdc
10from xtquant import xtdata
11'''
12设置用于登录行情服务的token，此接口应该先于 init_quote 调用
13 
14token可以从投研用户中心获取
15https://xuntou.net/#/userInfo
16'''
17xtdc.set_token('这里输入token')
18 
19'''
20设置连接池,使服务器只在连接池内优选
21 
22建议将VIP服务器设为连接池
23'''
24addr_list = [
25 '115.231.218.73:55310',
26 '115.231.218.79:55310',
27 '42.228.16.211:55300',
28 '42.228.16.210:55300',
29 '36.99.48.20:55300',
30 '36.99.48.21:55300'
31 ]
32xtdc.set_allow_optmize_address(addr_list)
33 
34xtdc.set_kline_mirror_enabled(True) # 开启K线全推功能(vip),以获取全市场实时K线数据
35 
36 
37"""
38初始化
39"""
40xtdc.init()
41## 监听端口
42port = xtdc.listen(port = 58621) # 指定固定端口进行连接
43# port = xtdc.listen(port = (58620, 58630))[1] 通过指定port范围，可以让xtdc在范围内自动寻找可用端口
44 
45xtdata.connect(port=port)
46 
47print('-----连接上了------')
48print(xtdata.data_dir)
49 
50 
51 
52servers = xtdata.get_quote_server_status()
53# print(servers)
54for k, v in servers.items():
55 print(k, v)
56 
57xtdata.run()
58 

连接指定服务器

qmt://docs/python
Python
1 
2import time
3from xtquant import xtdata
4 
5#用token方式连接，不需要账号密码
6#其他连接方式，需要账号密码
7info = {"ip": '115.231.218.73', "port": 55300, "username": '', "pwd": ''}
8 
9connect_success = 0
10def func(d):
11 ip = d.get('ip', '')
12 port = d.get('port')
13 status = d.get('status', 'disconnected')
14 
15 global connect_success
16 if ip == info['ip'] and port == info['port']:
17 if status == 'connected':
18 connect_success = 1
19 else:
20 connect_success = 2
21 
22# 注册连接回调信息
23xtdata.watch_quote_server_status(func)
24 
25# 行情连接
26qs = xtdata.QuoteServer(info)
27qs.connect()
28 
29# 获取当前数据连接站点
30data_server_info = xtdata.get_quote_server_status()
31# 显示当前数据连接站点
32if 1:
33 for k,v in data_server_info.items():
34 print(f"data:{k}, connect info:{v.info}")
35 
36 
37# 等待连接状态
38while connect_success == 0:
39 time.sleep(0.3)
40 
41if connect_success == 2:
42 print("连接失败")
43 

指定初始化行情连接范围

qmt://docs/python
Python
1if 1:
2 from xtquant import xtdatacenter as xtdc
3 
4 ## 设置数据目录
5 xtdc.set_data_home_dir('data')
6 
7 ## 设置token
8 token = "你的token"
9 xtdc.set_token(token)
10 
11 ## 限定行情站点的优选范围
12 opt_list = [
13 '115.231.218.73:55310',
14 '115.231.218.79:55310',
15 '42.228.16.210:55300',
16 '42.228.16.211:55300',
17 '36.99.48.20:55300',
18 '36.99.48.21:55300',
19 ]
20 xtdc.set_allow_optmize_address(opt_list)
21 
22 ## 开启指定市场的K线全推
23 xtdc.set_kline_mirror_markets(['SH', 'SZ', 'BJ'])
24 
25 ## 设置要初始化的市场列表
26 init_markets = [
27 'SH', 'SZ', 'BJ',
28 #'DF', 'GF', 'IF', 'SF', 'ZF', 'INE',
29 #'SHO', 'SZO',
30 ]
31 xtdc.set_init_markets(init_markets)
32 
33 ## 初始化xtdc模块
34 xtdc.init(start_local_service = False)
35 
36 ## 监听端口
37 #xtdc.listen(port = 58620)
38 listen_port = xtdc.listen(port = (58620, 58650))
39 
40 #import code; code.interact(local = locals())
41 
42 
43import xtquant.xtdata as xtdata
44 
45xtdata.connect(port = listen_port)
46 
47 
48 
49import code; code.interact(local = locals())
50 
51 
52 
53 

订阅全推数据/下载历史数据

qmt://docs/python
Python
1 
2# coding:utf-8
3import time
4 
5from xtquant import xtdata
6 
7code = '600000.SH'
8 
9#取全推数据
10full_tick = xtdata.get_full_tick([code])
11print('全推数据 日线最新值', full_tick)
12 
13#下载历史数据 下载接口本身不返回数据
14xtdata.download_history_data(code, period='1m', start_time='20230701')
15 
16#订阅最新行情
17def callback_func(data):
18 print('回调触发', data)
19 
20xtdata.subscribe_quote(code, period='1m', count=-1, callback= callback_func)
21data = xtdata.get_market_data(['close'], [code], period='1m', start_time='20230701')
22print('一次性取数据', data)
23 
24#死循环 阻塞主线程退出
25xtdata.run()
26 

获取对手价

qmt://docs/python
Python
1# 以卖出为例
2 
3import pandas as pd
4import numpy as np
5from xtquant import xtdata
6 
7to_do_trade_list = ["000001.SZ"]
8tick = xtdata.get_full_tick(to_do_trade_list)
9 
10 
11# 取买一价为对手价，若买一价为0，说明已经跌停，则取最新价
12for i in tick:
13 fix_price = tick[i]["bidPrice"][0] if tick[i]["bidPrice"][0] != 0 else tick[i]["lastPrice"]
14 print(fix_price)

复权计算方式

qmt://docs/python
Python
1#coding:utf-8
2 
3import numpy as np
4import pandas as pd
5 
6from xtquant import xtdata
7 
8#def gen_divid_ratio(quote_datas, divid_datas):
9# drl = []
10# for qi in range(len(quote_datas)):
11# q = quote_datas.iloc[qi]
12# dr = 1.0
13# for di in range(len(divid_datas)):
14# d = divid_datas.iloc[di]
15# if d.name <= q.name:
16# dr *= d['dr']
17# drl.append(dr)
18# return pd.DataFrame(drl, index = quote_datas.index, columns = quote_datas.columns)
19 
20def gen_divid_ratio(quote_datas, divid_datas):
21 drl = []
22 dr = 1.0
23 qi = 0
24 qdl = len(quote_datas)
25 di = 0
26 ddl = len(divid_datas)
27 while qi < qdl and di < ddl:
28 qd = quote_datas.iloc[qi]
29 dd = divid_datas.iloc[di]
30 if qd.name >= dd.name:
31 dr *= dd['dr']
32 di += 1
33 if qd.name <= dd.name:
34 drl.append(dr)
35 qi += 1
36 while qi < qdl:
37 drl.append(dr)
38 qi += 1
39 return pd.DataFrame(drl, index = quote_datas.index, columns = quote_datas.columns)
40 
41def process_forward_ratio(quote_datas, divid_datas):
42 drl = gen_divid_ratio(quote_datas, divid_datas)
43 drlf = drl / drl.iloc[-1]
44 result = (quote_datas * drlf).apply(lambda x: round(x, 2))
45 return result
46 
47def process_backward_ratio(quote_datas, divid_datas):
48 drl = gen_divid_ratio(quote_datas, divid_datas)
49 result = (quote_datas * drl).apply(lambda x: round(x, 2))
50 return result
51 
52def process_forward(quote_datas1, divid_datas):
53 quote_datas = quote_datas1.copy()
54 def calc_front(v, d):
55 return ((v - d['interest'] + d['allotPrice'] * d['allotNum'])
56 / (1 + d['allotNum'] + d['stockBonus'] + d['stockGift']))
57 for qi in range(len(quote_datas)):
58 q = quote_datas.iloc[qi]
59 for di in range(len(divid_datas)):
60 d = divid_datas.iloc[di]
61 if d.name <= q.name:
62 continue
63 q.iloc[0] = calc_front(q.iloc[0], d)
64 return quote_datas
65 
66def process_backward(quote_datas1, divid_datas):
67 quote_datas = quote_datas1.copy()
68 def calc_back(v, d):
69 return ((v * (1.0 + d['stockGift'] + d['stockBonus'] + d['allotNum'])
70 + d['interest'] - d['allotNum'] * d['allotPrice']))
71 for qi in range(len(quote_datas)):
72 q = quote_datas.iloc[qi]
73 for di in range(len(divid_datas) - 1, -1, -1):
74 d = divid_datas.iloc[di]
75 if d.name > q.name:
76 continue
77 q.iloc[0] = calc_back(q.iloc[0], d)
78 return quote_datas
79 
80 
81#--------------------------------
82 
83s = '002594.SZ'
84 
85#xtdata.download_history_data(s, '1d', '20100101', '')
86 
87dd = xtdata.get_divid_factors(s)
88print(dd)
89 
90#复权计算用于处理价格字段
91field_list = ['open', 'high', 'low', 'close']
92datas_ori = xtdata.get_market_data(field_list, [s], '1d', dividend_type = 'none')['close'].T
93#print(datas_ori)
94 
95#等比前复权
96datas_forward_ratio = process_forward_ratio(datas_ori, dd)
97print('datas_forward_ratio', datas_forward_ratio)
98 
99#等比后复权
100datas_backward_ratio = process_backward_ratio(datas_ori, dd)
101print('datas_backward_ratio', datas_backward_ratio)
102 
103#前复权
104datas_forward = process_forward(datas_ori, dd)
105print('datas_forward', datas_forward)
106 
107#后复权
108datas_backward = process_backward(datas_ori, dd)
109print('datas_backward', datas_backward)
110 

根据商品期货期权代码获取对应的商品期货合约代码

qmt://docs/python
Python
1from xtquant import xtdata
2 
3def get_option_underline_code(code:str) -> str:
4 """
5 注意：该函数不适用于股指期货期权与ETF期权
6 Todo: 根据商品期权代码获取对应的具体商品期货合约
7 Args:
8 code:str 期权代码
9 Return:
10 对应的期货合约代码
11 """
12 Exchange_dict = {
13 "SHFE":"SF",
14 "CZCE":"ZF",
15 "DCE":"DF",
16 "INE":"INE",
17 "GFEX":"GF"
18 }
19
20 if code.split(".")[-1] not in [v for k,v in Exchange_dict.items()]:
21 raise KeyError("此函数不支持该交易所合约")
22 info = xtdata.get_option_detail_data(code)
23 underline_code = info["OptUndlCode"] + "." + Exchange_dict[info["OptUndlMarket"]]
24 
25 return underline_code
26 
27if __name__ == "__main__":
28 
29 symbol_code = get_option_underline_code('sc2403C465.INE') # 获取期权合约'sc2403C465.INE'对应的期货合约代码
30 print(symbol_code)
31 

根据指数代码，返回对应的期货合约

qmt://docs/python
Python
1 
2from xtquant import xtdata
3import re
4 
5def get_financial_futures_code_from_index(index_code:str) -> list:
6 """
7 ToDo:传入指数代码，返回对应的期货合约（当前）
8 Args:
9 index_code:指数代码，如"000300.SH","000905.SH"
10 Retuen:
11 list: 对应期货合约列表
12 """
13 financial_futures = xtdata.get_stock_list_in_sector("中金所")
14 future_list = []
15 pattern = r'^[a-zA-Z]{1,2}\d{3,4}\.[A-Z]{2}$'
16 for i in financial_futures:
17
18 if re.match(pattern,i):
19 future_list.append(i)
20 ls = []
21 for i in future_list:
22 _info = xtdata._get_instrument_detail(i)
23 _index_code = _info["ExtendInfo"]['OptUndlCode'] + "." + _info["ExtendInfo"]['OptUndlMarket']
24 if _index_code == index_code:
25 ls.append(i)
26 return ls
27 
28if __name__ == "__main__":
29 ls = get_financial_futures_code_from_index("000905.SH")
30 print(ls)
31 

高频因子数据创建

qmt://docs/python
Python
1#coding:utf-8
2 
3 
4import xtquant.invadv as xtia
5 
6 
7remote_host = '115.231.218.7'
8remote_port = 55300
9user_name = '授权账号'
10password = '授权账号对应密码'
11 
12# 连接云服务
13api = xtia.InvAdv()
14api.set_remote_addr(remote_host, remote_port)
15api.set_user(user_name, password)
16api.connect()
17 
18# 查询高频因子数据列表
19ret_sector_dict = api.get_block_list()
20new_dict = {v: k for k, v in ret_sector_dict.items()}
21 
22# 创建新的因子
23fp_name = '盘口价差'
24if fp_name not in new_dict:
25 api.create_block(fp_name)
26 print(f'创建{fp_name}表')
27 
28# 格式 {股票1: 因子值, 股票2: 因子值 ...}
29codes = {'002594.SZ': 0.009, '300750.SZ': 0.007, '688001.SH': 0.1, '000001.SZ':0.2, '300751.SZ':0.3}
30 
31# 查询高频因子数据列表
32ret_sector_dict = api.get_block_list()
33print(f'查询高频因子数据列表:{ret_sector_dict}')
34 
35 
36# 创建高频因子内容
37for k_msg_id, v in ret_sector_dict.items():
38 write_codes = []
39 if v == fp_name:
40 for code, value in codes.items():
41 write_codes.append(f'{code}|{value}')
42 # 创建代码
43 api.push_block(k_msg_id, write_codes)
44 print(f'表:{fp_name} id:{k_msg_id} {write_codes}')
45 print(f'创建结束!')
46 
47 
48print('====end====')
49 
50 

交易示例

简单买卖各一笔示例

需要调整的参数：

  • 98行的path变量需要改为本地客户端路径,券商端指定到 f"{安装目录}\userdata_mini",投研端指定到f"{安装目录}\userdata"
  • 107行的资金账号需要调整为自身资金账号
qmt://docs/python
Python
1# coding:utf-8
2import time, datetime, traceback, sys
3from xtquant import xtdata
4from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
5from xtquant.xttype import StockAccount
6from xtquant import xtconstant
7 
8 
9# 定义一个类 创建类的实例 作为状态的容器
10class _a():
11 pass
12 
13 
14A = _a()
15A.bought_list = []
16A.hsa = xtdata.get_stock_list_in_sector('沪深A股')
17 
18 
19def interact():
20 """执行后进入repl模式"""
21 import code
22 code.InteractiveConsole(locals=globals()).interact()
23 
24 
25xtdata.download_sector_data()
26 
27 
28 
29class MyXtQuantTraderCallback(XtQuantTraderCallback):
30 def on_disconnected(self):
31 """
32 连接断开
33 :return:
34 """
35 print(datetime.datetime.now(), '连接断开回调')
36 
37 def on_stock_order(self, order):
38 """
39 委托回报推送
40 :param order: XtOrder对象
41 :return:
42 """
43 print(datetime.datetime.now(), '委托回调 投资备注', order.order_remark)
44 
45 def on_stock_trade(self, trade):
46 """
47 成交变动推送
48 :param trade: XtTrade对象
49 :return:
50 """
51 print(datetime.datetime.now(), '成交回调', trade.order_remark, f"委托方向(48买 49卖) {trade.offset_flag} 成交价格 {trade.traded_price} 成交数量 {trade.traded_volume}")
52 
53 def on_order_error(self, order_error):
54 """
55 委托失败推送
56 :param order_error:XtOrderError 对象
57 :return:
58 """
59 # print("on order_error callback")
60 # print(order_error.order_id, order_error.error_id, order_error.error_msg)
61 print(f"委托报错回调 {order_error.order_remark} {order_error.error_msg}")
62 
63 def on_cancel_error(self, cancel_error):
64 """
65 撤单失败推送
66 :param cancel_error: XtCancelError 对象
67 :return:
68 """
69 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
70 
71 def on_order_stock_async_response(self, response):
72 """
73 异步下单回报推送
74 :param response: XtOrderResponse 对象
75 :return:
76 """
77 print(f"异步委托回调 投资备注: {response.order_remark}")
78 
79 def on_cancel_order_stock_async_response(self, response):
80 """
81 :param response: XtCancelOrderResponse 对象
82 :return:
83 """
84 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
85 
86 def on_account_status(self, status):
87 """
88 :param response: XtAccountStatus 对象
89 :return:
90 """
91 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
92 
93 
94if __name__ == '__main__':
95 print("start")
96 # 指定客户端所在路径, 券商端指定到 userdata_mini文件夹
97 # 注意：如果是连接投研端进行交易，文件目录需要指定到f"{安装目录}\userdata"
98 path = r'D:\qmt\投研\迅投极速交易终端睿智融科版\userdata'
99 # 生成session id 整数类型 同时运行的策略不能重复
100 session_id = int(time.time())
101 xt_trader = XtQuantTrader(path, session_id)
102 # 开启主动请求接口的专用线程 开启后在on_stock_xxx回调函数里调用XtQuantTrader.query_xxx函数不会卡住回调线程，但是查询和推送的数据在时序上会变得不确定
103 # 详见: /docs/xtquant/xttrader.html#开启主动请求接口的专用线程
104 # xt_trader.set_relaxed_response_order_enabled(True)
105 
106 # 创建资金账号为 800068 的证券账号对象 股票账号为STOCK 信用CREDIT 期货FUTURE
107 acc = StockAccount('2000128', 'STOCK')
108 # 创建交易回调类对象，并声明接收回调
109 callback = MyXtQuantTraderCallback()
110 xt_trader.register_callback(callback)
111 # 启动交易线程
112 xt_trader.start()
113 # 建立交易连接，返回0表示连接成功
114 connect_result = xt_trader.connect()
115 print('建立交易连接，返回0表示连接成功', connect_result)
116 # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功
117 subscribe_result = xt_trader.subscribe(acc)
118 print('对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功', subscribe_result)
119 #取账号信息
120 account_info = xt_trader.query_stock_asset(acc)
121 #取可用资金
122 available_cash = account_info.m_dCash
123 
124 print(acc.account_id, '可用资金', available_cash)
125 #查账号持仓
126 positions = xt_trader.query_stock_positions(acc)
127 #取各品种 总持仓 可用持仓
128 position_total_dict = {i.stock_code : i.m_nVolume for i in positions}
129 position_available_dict = {i.stock_code : i.m_nCanUseVolume for i in positions}
130 print(acc.account_id, '持仓字典', position_total_dict)
131 print(acc.account_id, '可用持仓字典', position_available_dict)
132 
133 #买入 浦发银行 最新价 两万元
134 stock = '600000.SH'
135 target_amount = 20000
136 full_tick = xtdata.get_full_tick([stock])
137 print(f"{stock} 全推行情： {full_tick}")
138 current_price = full_tick[stock]['lastPrice']
139 #买入金额 取目标金额 与 可用金额中较小的
140 buy_amount = min(target_amount, available_cash)
141 #买入数量 取整为100的整数倍
142 buy_vol = int(buy_amount / current_price / 100) * 100
143 print(f"当前可用资金 {available_cash} 目标买入金额 {target_amount} 买入股数 {buy_vol}股")
144 async_seq = xt_trader.order_stock_async(acc, stock, xtconstant.STOCK_BUY, buy_vol, xtconstant.FIX_PRICE, current_price,
145 'strategy_name', stock)
146 
147 #卖出 500股
148 stock = '513130.SH'
149 #目标数量
150 target_vol = 500
151 #可用数量
152 available_vol = position_available_dict[stock] if stock in position_available_dict else 0
153 #卖出量取目标量与可用量中较小的
154 sell_vol = min(target_vol, available_vol)
155 print(f"{stock} 目标卖出量 {target_vol} 可用数量 {available_vol} 卖出 {sell_vol}股")
156 if sell_vol > 0:
157 async_seq = xt_trader.order_stock_async(acc, stock, xtconstant.STOCK_SELL, sell_vol, xtconstant.LATEST_PRICE,
158 -1,
159 'strategy_name', stock)
160 print(f"下单完成 等待回调")
161 # 阻塞主线程退出
162 xt_trader.run_forever()
163 # 如果使用vscode pycharm等本地编辑器 可以进入交互模式 方便调试 （把上一行的run_forever注释掉 否则不会执行到这里）
164 interact()
165 
166 

单股订阅实盘示例

需要调整的参数：

  • 113行的path变量需要改为本地客户端路径,券商端指定到 f"{安装目录}\userdata_mini",投研端指定到f"{安装目录}\userdata"
  • 122行的资金账号需要调整为自身资金账号
qmt://docs/python
Python
1# coding:utf-8
2import time, datetime, traceback, sys
3from xtquant import xtdata
4from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
5from xtquant.xttype import StockAccount
6from xtquant import xtconstant
7 
8 
9# 定义一个类 创建类的实例 作为状态的容器
10class _a():
11 pass
12 
13 
14A = _a()
15A.bought_list = []
16A.hsa = xtdata.get_stock_list_in_sector('沪深A股')
17 
18 
19def interact():
20 """执行后进入repl模式"""
21 import code
22 code.InteractiveConsole(locals=globals()).interact()
23 
24 
25xtdata.download_sector_data()
26 
27 
28def f(data):
29 print(data)
30 now = datetime.datetime.now()
31 for stock in data:
32 if stock not in A.hsa:
33 continue
34 cuurent_price = data[stock][0]['close']
35 pre_price = data[stock][0]['preClose']
36 ratio = cuurent_price / pre_price - 1 if pre_price > 0 else 0
37 if ratio > 0.09 and stock not in A.bought_list:
38 print(f"{now} 最新价 买入 {stock} 100股")
39 async_seq = xt_trader.order_stock_async(acc, stock, xtconstant.STOCK_BUY, 100, xtconstant.LATEST_PRICE, -1,
40 'strategy_name', stock)
41 A.bought_list.append(stock)
42 
43 
44class MyXtQuantTraderCallback(XtQuantTraderCallback):
45 def on_disconnected(self):
46 """
47 连接断开
48 :return:
49 """
50 print(datetime.datetime.now(), '连接断开回调')
51 
52 def on_stock_order(self, order):
53 """
54 委托回报推送
55 :param order: XtOrder对象
56 :return:
57 """
58 print(datetime.datetime.now(), '委托回调', order.order_remark)
59 
60 def on_stock_trade(self, trade):
61 """
62 成交变动推送
63 :param trade: XtTrade对象
64 :return:
65 """
66 print(datetime.datetime.now(), '成交回调', trade.order_remark)
67 
68 def on_order_error(self, order_error):
69 """
70 委托失败推送
71 :param order_error:XtOrderError 对象
72 :return:
73 """
74 # print("on order_error callback")
75 # print(order_error.order_id, order_error.error_id, order_error.error_msg)
76 print(f"委托报错回调 {order_error.order_remark} {order_error.error_msg}")
77 
78 def on_cancel_error(self, cancel_error):
79 """
80 撤单失败推送
81 :param cancel_error: XtCancelError 对象
82 :return:
83 """
84 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
85 
86 def on_order_stock_async_response(self, response):
87 """
88 异步下单回报推送
89 :param response: XtOrderResponse 对象
90 :return:
91 """
92 print(f"异步委托回调 {response.order_remark}")
93 
94 def on_cancel_order_stock_async_response(self, response):
95 """
96 :param response: XtCancelOrderResponse 对象
97 :return:
98 """
99 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
100 
101 def on_account_status(self, status):
102 """
103 :param response: XtAccountStatus 对象
104 :return:
105 """
106 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
107 
108 
109if __name__ == '__main__':
110 print("start")
111 # 指定客户端所在路径, 券商端指定到 userdata_mini文件夹
112 # 注意：如果是连接投研端进行交易，文件目录需要指定到f"{安装目录}\userdata"
113 path = r'D:\qmt\投研\迅投极速交易终端睿智融科版\userdata'
114 # 生成session id 整数类型 同时运行的策略不能重复
115 session_id = int(time.time())
116 xt_trader = XtQuantTrader(path, session_id)
117 # 开启主动请求接口的专用线程 开启后在on_stock_xxx回调函数里调用XtQuantTrader.query_xxx函数不会卡住回调线程，但是查询和推送的数据在时序上会变得不确定
118 # 详见: /docs/xtquant/xttrader.html#开启主动请求接口的专用线程
119 # xt_trader.set_relaxed_response_order_enabled(True)
120 
121 # 创建资金账号为 800068 的证券账号对象 股票账号为STOCK 信用CREDIT 期货FUTURE
122 acc = StockAccount('2000128', 'STOCK')
123 # 创建交易回调类对象，并声明接收回调
124 callback = MyXtQuantTraderCallback()
125 xt_trader.register_callback(callback)
126 # 启动交易线程
127 xt_trader.start()
128 # 建立交易连接，返回0表示连接成功
129 connect_result = xt_trader.connect()
130 print('建立交易连接，返回0表示连接成功', connect_result)
131 # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功
132 subscribe_result = xt_trader.subscribe(acc)
133 print('对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功', subscribe_result)
134 
135 #订阅的品种列表
136 code_list = ['600000.SH', '000001.SZ']
137 
138 for code in code_list:
139 xtdata.subscribe_quote(code, '1d', callback = f)
140 
141 # 阻塞主线程退出
142 xt_trader.run_forever()
143 # 如果使用vscode pycharm等本地编辑器 可以进入交互模式 方便调试 （把上一行的run_forever注释掉 否则不会执行到这里）
144 interact()
145 
146 

全推订阅实盘示例

本示例用于展示如何订阅上海及深圳市场全推，对于沪深A股品种策略进行判断当前涨幅超过 9 个点的买入 200 股

需要调整的参数：

  • 111行的path变量需要改为本地客户端路径
  • 116行的资金账号需要调整为自身资金账号

注意

本策略只用于提供策略写法及参考，若您直接进行实盘下单，造成损失本网站不负担责任。

qmt://docs/python
Python
1#coding:utf-8
2import time, datetime, traceback, sys
3from xtquant import xtdata
4from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
5from xtquant.xttype import StockAccount
6from xtquant import xtconstant
7 
8#定义一个类 创建类的实例 作为状态的容器
9class _a():
10 pass
11A = _a()
12A.bought_list = []
13A.hsa = xtdata.get_stock_list_in_sector('沪深A股')
14 
15def interact():
16 """执行后进入repl模式"""
17 import code
18 code.InteractiveConsole(locals=globals()).interact()
19xtdata.download_sector_data()
20 
21def f(data):
22 now = datetime.datetime.now()
23 for stock in data:
24 if stock not in A.hsa:
25 continue
26 cuurent_price = data[stock][0]['lastPrice']
27 pre_price = data[stock][0]['lastClose']
28 ratio = cuurent_price / pre_price - 1 if pre_price > 0 else 0
29 if ratio > 0.09 and stock not in A.bought_list:
30 print(f"{now} 最新价 买入 {stock} 200股")
31 async_seq = xt_trader.order_stock_async(acc, stock, xtconstant.STOCK_BUY, 200, xtconstant.LATEST_PRICE, -1, 'strategy_name', stock)
32 A.bought_list.append(stock)
33
34class MyXtQuantTraderCallback(XtQuantTraderCallback):
35 def on_disconnected(self):
36 """
37 连接断开
38 :return:
39 """
40 print(datetime.datetime.now(),'连接断开回调')
41 
42 def on_stock_order(self, order):
43 """
44 委托回报推送
45 :param order: XtOrder对象
46 :return:
47 """
48 print(datetime.datetime.now(), '委托回调', order.order_remark)
49 
50 
51 def on_stock_trade(self, trade):
52 """
53 成交变动推送
54 :param trade: XtTrade对象
55 :return:
56 """
57 print(datetime.datetime.now(), '成交回调', trade.order_remark)
58 
59 
60 def on_order_error(self, order_error):
61 """
62 委托失败推送
63 :param order_error:XtOrderError 对象
64 :return:
65 """
66 # print("on order_error callback")
67 # print(order_error.order_id, order_error.error_id, order_error.error_msg)
68 print(f"委托报错回调 {order_error.order_remark} {order_error.error_msg}")
69 
70 def on_cancel_error(self, cancel_error):
71 """
72 撤单失败推送
73 :param cancel_error: XtCancelError 对象
74 :return:
75 """
76 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
77 
78 def on_order_stock_async_response(self, response):
79 """
80 异步下单回报推送
81 :param response: XtOrderResponse 对象
82 :return:
83 """
84 print(f"异步委托回调 {response.order_remark}")
85 
86 def on_cancel_order_stock_async_response(self, response):
87 """
88 :param response: XtCancelOrderResponse 对象
89 :return:
90 """
91 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
92 
93 def on_account_status(self, status):
94 """
95 :param response: XtAccountStatus 对象
96 :return:
97 """
98 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
99 
100 
101if __name__ == '__main__':
102 print("start")
103 #指定客户端所在路径,
104 # 注意：如果是连接投研端进行交易，文件目录需要指定到f"{安装目录}\userdata"
105 path = r'D:\qmt\sp3\迅投极速交易终端 睿智融科版\userdata_mini'
106 # 生成session id 整数类型 同时运行的策略不能重复
107 session_id = int(time.time())
108 xt_trader = XtQuantTrader(path, session_id)
109 # 开启主动请求接口的专用线程 开启后在on_stock_xxx回调函数里调用XtQuantTrader.query_xxx函数不会卡住回调线程，但是查询和推送的数据在时序上会变得不确定
110 # 详见: /docs/xtquant/xttrader.html#开启主动请求接口的专用线程
111 # xt_trader.set_relaxed_response_order_enabled(True)
112 
113 # 创建资金账号为 800068 的证券账号对象
114 acc = StockAccount('800068', 'STOCK')
115 # 创建交易回调类对象，并声明接收回调
116 callback = MyXtQuantTraderCallback()
117 xt_trader.register_callback(callback)
118 # 启动交易线程
119 xt_trader.start()
120 # 建立交易连接，返回0表示连接成功
121 connect_result = xt_trader.connect()
122 print('建立交易连接，返回0表示连接成功', connect_result)
123 # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功
124 subscribe_result = xt_trader.subscribe(acc)
125 print('对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功', subscribe_result)
126 
127 #这一行是注册全推回调函数 包括下单判断 安全起见处于注释状态 确认理解效果后再放开
128 # xtdata.subscribe_whole_quote(["SH", "SZ"], callback=f)
129 # 阻塞主线程退出
130 xt_trader.run_forever()
131 # 如果使用vscode pycharm等本地编辑器 可以进入交互模式 方便调试 （把上一行的run_forever注释掉 否则不会执行到这里）
132 interact()

定时判断实盘示例

qmt://docs/python
Python
1# coding:utf-8
2import time, datetime, traceback, sys
3from xtquant import xtdata
4from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
5from xtquant.xttype import StockAccount
6from xtquant import xtconstant
7 
8 
9# 定义一个类 创建类的实例 作为状态的容器
10class _a():
11 pass
12 
13 
14A = _a()
15A.bought_list = []
16A.hsa = xtdata.get_stock_list_in_sector('沪深A股')
17 
18 
19def interact():
20 """执行后进入repl模式"""
21 import code
22 code.InteractiveConsole(locals=globals()).interact()
23 
24 
25xtdata.download_sector_data()
26 
27 
28def f(data):
29 now = datetime.datetime.now()
30 # print(data)
31 for stock in data:
32 if stock not in A.hsa:
33 continue
34 cuurent_price = data[stock].iloc[-1, 0]
35 pre_price = data[stock].iloc[-2, 0]
36 ratio = cuurent_price / pre_price - 1 if pre_price > 0 else 0
37 if ratio > 0.09 and stock not in A.bought_list:
38 print(f"{now} 最新价 买入 {stock} 100股")
39 async_seq = xt_trader.order_stock_async(acc, stock, xtconstant.STOCK_BUY, 100, xtconstant.LATEST_PRICE, -1,
40 'strategy_name', stock)
41 A.bought_list.append(stock)
42 
43 
44class MyXtQuantTraderCallback(XtQuantTraderCallback):
45 def on_disconnected(self):
46 """
47 连接断开
48 :return:
49 """
50 print(datetime.datetime.now(), '连接断开回调')
51 
52 def on_stock_order(self, order):
53 """
54 委托回报推送
55 :param order: XtOrder对象
56 :return:
57 """
58 print(datetime.datetime.now(), '委托回调', order.order_remark)
59 
60 def on_stock_trade(self, trade):
61 """
62 成交变动推送
63 :param trade: XtTrade对象
64 :return:
65 """
66 print(datetime.datetime.now(), '成交回调', trade.order_remark)
67 
68 def on_order_error(self, order_error):
69 """
70 委托失败推送
71 :param order_error:XtOrderError 对象
72 :return:
73 """
74 # print("on order_error callback")
75 # print(order_error.order_id, order_error.error_id, order_error.error_msg)
76 print(f"委托报错回调 {order_error.order_remark} {order_error.error_msg}")
77 
78 def on_cancel_error(self, cancel_error):
79 """
80 撤单失败推送
81 :param cancel_error: XtCancelError 对象
82 :return:
83 """
84 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
85 
86 def on_order_stock_async_response(self, response):
87 """
88 异步下单回报推送
89 :param response: XtOrderResponse 对象
90 :return:
91 """
92 print(f"异步委托回调 {response.order_remark}")
93 
94 def on_cancel_order_stock_async_response(self, response):
95 """
96 :param response: XtCancelOrderResponse 对象
97 :return:
98 """
99 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
100 
101 def on_account_status(self, status):
102 """
103 :param response: XtAccountStatus 对象
104 :return:
105 """
106 print(datetime.datetime.now(), sys._getframe().f_code.co_name)
107 
108 
109if __name__ == '__main__':
110 print("start")
111 # 指定客户端所在路径, 券商端指定到 userdata_mini文件夹
112 # 注意：如果是连接投研端进行交易，文件目录需要指定到f"{安装目录}\userdata"
113 path = r'D:\qmt\投研\迅投极速交易终端睿智融科版\userdata'
114 # 生成session id 整数类型 同时运行的策略不能重复
115 session_id = int(time.time())
116 xt_trader = XtQuantTrader(path, session_id)
117 # 开启主动请求接口的专用线程 开启后在on_stock_xxx回调函数里调用XtQuantTrader.query_xxx函数不会卡住回调线程，但是查询和推送的数据在时序上会变得不确定
118 # 详见: /docs/xtquant/xttrader.html#开启主动请求接口的专用线程
119 # xt_trader.set_relaxed_response_order_enabled(True)
120 
121 # 创建资金账号为 800068 的证券账号对象 股票账号为STOCK 信用CREDIT 期货FUTURE
122 acc = StockAccount('2000128', 'STOCK')
123 # 创建交易回调类对象，并声明接收回调
124 callback = MyXtQuantTraderCallback()
125 xt_trader.register_callback(callback)
126 # 启动交易线程
127 xt_trader.start()
128 # 建立交易连接，返回0表示连接成功
129 connect_result = xt_trader.connect()
130 print('建立交易连接，返回0表示连接成功', connect_result)
131 # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功
132 subscribe_result = xt_trader.subscribe(acc)
133 print('对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功', subscribe_result)
134 
135 #订阅的品种列表
136 code_list = ['600000.SH', '000001.SZ']
137 #遍历品种 下载历史k线 订阅当日行情
138 for code in code_list:
139 xtdata.download_history_data(code, period='1d', start_time='20200101')
140 xtdata.subscribe_quote(code, '1d', callback = None)
141 
142 while True:
143 now = datetime.datetime.now()
144 now_time = now.strftime('%H%M%S')
145 if not '093000' <= now_time < '150000':
146 print(f"{now} 非交易时间 循环退出")
147 break
148 #取k线数据
149 data = xtdata.get_market_data_ex(['close'], code_list, period= '1d', start_time= '20240101')
150 #判断交易
151 f(data)
152 #每次循环 睡眠三秒后继续
153 time.sleep(3)
154 
155 
156 # 阻塞主线程退出
157 xt_trader.run_forever()
158 # 如果使用vscode pycharm等本地编辑器 可以进入交互模式 方便调试 （把上一行的run_forever注释掉 否则不会执行到这里）
159 interact()
160 

交易接口重连

该示例演示交易连接断开时重连的代码处理。

提示

  1. 该示例不是线程安全的，仅演示断开连接时应该怎么处理重连代码，实际使用时请注意避免潜在的问题
  2. 本策略只用于提供策略写法及参考，若您直接进行实盘下单，造成损失本网站不负担责任。
qmt://docs/python
Python
1 
2#本文用一个均线策略演示交易连接断开时怎么处理交易接口重连
3# 策略本身不严谨，不能作为实盘策略或者参考策略，本策略仅是演示重连用法
4import time
5from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
6from xtquant.xttype import StockAccount
7from xtquant import xtconstant
8from xtquant import xtdata
9 
10 
11class MyXtQuantTraderCallback(XtQuantTraderCallback):
12 # 更多说明见 /docs/xtquant/xttrader.html#委托xtorder
13 def on_disconnected(self):
14 """
15 连接断开
16 :return:
17 """
18 print("connection lost, 交易接口断开，即将重连")
19 global xt_trader
20 xt_trader = None
21
22 def on_stock_order(self, order):
23 print(f'委托回报: 股票代码:{order.stock_code} 账号:{order.account_id}, 订单编号:{order.order_id} 柜台合同编号:{order.order_sysid} \
24 委托状态:{order.order_status} 成交数量:{order.order_status} 委托数量:{order.order_volume} 已成数量：{order.traded_volume}')
25
26 def on_stock_trade(self, trade):
27 print(f'成交回报: 股票代码:{trade.stock_code} 账号:{trade.account_id}, 订单编号:{trade.order_id} 柜台合同编号:{trade.order_sysid} \
28 成交编号:{trade.traded_id} 成交数量:{trade.traded_volume} 委托数量:{trade.direction} ')
29 
30 def on_order_error(self, order_error):
31 print(f"报单失败： 订单编号：{order_error.order_id} 下单失败具体信息:{order_error.error_msg} 委托备注:{order_error.order_remark}")
32 
33 def on_cancel_error(self, cancel_error):
34 print(f"撤单失败: 订单编号：{cancel_error.order_id} 失败具体信息:{cancel_error.error_msg} 市场：{cancel_error.market}")
35 
36 def on_order_stock_async_response(self, response):
37 print(f"异步下单的请求序号:{response.seq}, 订单编号：{response.order_id} ")
38 
39 def on_account_status(self, status):
40 print(f"账号状态发生变化， 账号:{status.account_id} 最新状态：{status.status}")
41 
42def create_trader(xt_acc,path, session_id):
43 trader = XtQuantTrader(path, session_id,callback=MyXtQuantTraderCallback())
44 trader.start()
45 connect_result = trader.connect()
46 trader.subscribe(xt_acc)
47 return trader if connect_result == 0 else None
48 
49 
50def try_connect(xt_acc,path):
51 session_id_range = [i for i in range(100, 120)]
52 
53 import random
54 random.shuffle(session_id_range)
55 
56 # 遍历尝试session_id列表尝试连接
57 for session_id in session_id_range:
58 trader = create_trader(xt_acc,path, session_id)
59 if trader:
60 print('连接成功，session_id:{}', session_id)
61 return trader
62 else:
63 print('连接失败，session_id:{}，继续尝试下一个id', session_id)
64 continue
65 
66 print('所有id都尝试后仍失败，放弃连接')
67 return None
68 
69 
70def get_xttrader(xt_acc,path):
71 global xt_trader
72 if xt_trader is None:
73 xt_trader = try_connect(xt_acc,path)
74 return xt_trader
75 
76 
77if __name__ == "__main__":
78 
79 # 注意实际连接XtQuantTrader时不要写类似while True 这种无限循环的尝试，因为每次连接都会用session_id创建一个对接文件，这样就会占满硬盘导致电脑运行异常
80 # 要控制session_id在有限的范围内尝试，这里提供10个session_id供重连尝试
81 # 当所有session_id都尝试后，程序会抛出异常。实际使用过程中当session_id用完时，可以增加邮件等通知方式提醒人工处理
82 
83 #指定客户端所在路径
84 path = 'E:\qmt\\userdata_mini'
85 xt_trader = None
86 xt_acc = StockAccount('2000204')
87 xt_trader = get_xttrader(xt_acc,path)
88 if not xt_trader:
89 raise Exception('交易接口连接失败')
90 print('交易接口连接成功， 策略开始')
91 
92 stock = '513050.SH'
93 xtdata.subscribe_quote(stock, '5m','','',count=-1)
94 time.sleep(1)
95 order_record = []
96 while '093000'<=time.strftime('%H%M%S')<'150000':
97 time.sleep(3)
98 xt_trader = get_xttrader(xt_acc,path)
99
100 price = xtdata.get_market_data_ex(['close'],[stock],period='5m',)[stock]
101 #计算均线
102 ma5 = price['close'].rolling(5).mean()
103 ma10 = price['close'].rolling(10).mean()
104 
105 if ma5.iloc[-1]>ma5.iloc[-10]:
106 t = price.index[-1]
107 order_flag = (t, '买')
108 if order_flag not in order_record: #防止重复下单
109 print(f'发起买入 {stock} k线时间:{t}')
110
111 # 用最新价买100股
112 xt_trader.order_stock_async(xt_acc, stock, xtconstant.STOCK_BUY,100,xtconstant.LATEST_PRICE,0)
113 order_record.append(order_flag)
114 elif ma5.iloc[-1]<ma5[-10]:
115 t = price.index[-1]
116 order_flag = (t, '卖')
117 if order_flag not in order_record: #防止重复下单
118 print(f'发起卖出 {stock} k线时间:{t}')
119 # 用最新价买100股
120 xt_trader.order_stock_async(xt_acc, stock, xtconstant.STOCK_SELL,100,xtconstant.LATEST_PRICE,0)
121
122 order_record.append(order_flag)
123 
124 

指定session id范围连接交易

该示例演示指定session重试连接次数的代码处理。

qmt://docs/python
Python
1 
2#coding:utf-8
3 
4def connect(path, session):
5 from xtquant import xttrader
6 
7 trader = xttrader.XtQuantTrader(path, session)
8 trader.start()
9 
10 connect_result = trader.connect()
11 return trader if connect_result == 0 else None
12 
13 
14def try_connect_range():
15 # 随机 session_id 的待尝试列表
16 # 100以内的id保留
17 ids = [i for i in range(100, 200)]
18 
19 import random
20 random.shuffle(ids)
21 
22 # 要连接到的对接路径
23 path = r'userdata_mini'
24 
25 # 遍历id列表尝试连接
26 for session_id in ids:
27 print(f'尝试id:{session_id}')
28 trader = connect(path, session_id)
29 
30 if trader:
31 print('连接成功')
32 return trader
33 else:
34 print('连接失败，继续尝试下一个id')
35 continue
36 
37 # 所有id都尝试后仍失败，放弃连接
38 raise Exception('XtQuantTrader 连接失败,请重试')
39 
40 
41try:
42 trader = try_connect_range()
43except Exception as e:
44 import traceback
45 print(e, traceback.format_exc())
46 
47 
48import time
49while True:
50 print('.', end = '')
51 time.sleep(2)
52 
53 
54 
55 

信用账号执行还款

本示例用于展示如何使用xtquant库对信用账号执行还款的操作

提示

本策略只用于提供策略写法及参考，若您直接进行实盘下单，造成损失本网站不负担责任。

qmt://docs/python
Python
1#coding=utf-8
2from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
3from xtquant.xttype import StockAccount
4from xtquant import xtconstant
5 
6# 修改参数
7# path为mini qmt客户端安装目录下userdata_mini路径
8path = 'E:\\qmt\\userdata_mini'
9# session_id为会话编号，策略使用方对于不同的Python策略需要使用不同的会话编号
10session_id = 1234567
11repay_money = 1000.51 # 元，需要执行还款的金额
12 
13class MyXtQuantTraderCallback(XtQuantTraderCallback):
14 def on_disconnected(self):
15 """
16 连接断开
17 :return:
18 """
19 print("connection lost")
20 def on_stock_order(self, order):
21 """
22 委托回报推送
23 :param order: XtOrder对象
24 :return:
25 """
26 print("on order callback:")
27 print(order.stock_code, order.order_status, order.order_sysid)
28 def on_stock_asset(self, asset):
29 """
30 资金变动推送
31 :param asset: XtAsset对象
32 :return:
33 """
34 print("on asset callback")
35 print(asset.account_id, asset.cash, asset.total_asset)
36 def on_stock_trade(self, trade):
37 """
38 成交变动推送
39 :param trade: XtTrade对象
40 :return:
41 """
42 print("on trade callback")
43 print(trade.account_id, trade.stock_code, trade.order_id)
44 def on_order_error(self, order_error):
45 """
46 委托失败推送
47 :param order_error:XtOrderError 对象
48 :return:
49 """
50 print("on order_error callback")
51 print(order_error.order_id, order_error.error_id, order_error.error_msg)
52 def on_cancel_error(self, cancel_error):
53 """
54 撤单失败推送
55 :param cancel_error: XtCancelError 对象
56 :return:
57 """
58 print("on cancel_error callback")
59 print(cancel_error.order_id, cancel_error.error_id, cancel_error.error_msg)
60 def on_order_stock_async_response(self, response):
61 """
62 异步下单回报推送
63 :param response: XtOrderResponse 对象
64 :return:
65 """
66 print("on_order_stock_async_response")
67 print(response.account_id, response.order_id, response.seq)
68 def on_account_status(self, status):
69 """
70 :param response: XtAccountStatus 对象
71 :return:
72 """
73 print("on_account_status")
74 print(status.account_id, status.account_type, status.status)
75 
76 
77if __name__ == "__main__":
78 print("demo test")
79 
80 
81 xt_trader = XtQuantTrader(path, session_id)
82 # 创建资金账号为1000000365的证券账号对象
83 acc = StockAccount('200035', 'CREDIT')
84 # StockAccount可以用第二个参数指定账号类型，如沪港通传'HUGANGTONG'，深港通传'SHENGANGTONG'
85 # acc = StockAccount('1000000365','STOCK')
86 # 创建交易回调类对象，并声明接收回调
87 callback = MyXtQuantTraderCallback()
88 xt_trader.register_callback(callback)
89 # 启动交易线程
90 xt_trader.start()
91 # 建立交易连接，返回0表示连接成功
92 connect_result = xt_trader.connect()
93 if connect_result != 0:
94 import sys
95 sys.exit('连接失败，程序即将退出 %d'%connect_result)
96 # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功
97 subscribe_result = xt_trader.subscribe(acc)
98 if subscribe_result != 0:
99 print('账号订阅失败 %d'%subscribe_result)
100 print(subscribe_result)
101 stock_code = '600000.SH' # 参数占位用，任意股票代码都可以
102 volume = 200 # 参数占位用，任意数量
103 # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态
104 fix_result_order_id = xt_trader.order_stock(acc, stock_code, xtconstant.CREDIT_DIRECT_CASH_REPAY, repay_money, xtconstant.FIX_PRICE, -1, 'strategy_name', 'remark')
105 
106 # 阻塞线程，接收交易推送
107 xt_trader.run_forever()

下单后通过回调撤单

qmt://docs/python
Python
1import pandas as pd
2import numpy as np
3import datetime
4from xtquant import xtdata,xttrader
5from xtquant.xttype import StockAccount
6from xtquant import xtconstant
7from xtquant.xttrader import XtQuantTraderCallback
8import sys
9import time
10 
11 
12"""
13异步下单委托流程为
141.order_stock_async发出委托
152.回调on_order_stock_async_response收到回调信息
163.回调on_stock_order收到委托信息
174.回调cancel_order_stock_sysid_async发出异步撤单指令
185.回调on_cancel_order_stock_async_response收到撤单回调信息
196.回调on_stock_order收到委托信息
20"""
21strategy_name = "委托撤单测试"
22 
23class MyXtQuantTraderCallback(XtQuantTraderCallback):
24 # 用于接收回调信息的类
25 def on_stock_order(self, order):
26 """
27 委托回报推送
28 :param order: XtOrder对象
29 :return:
30 """
31 # 属性赋值
32 account_type = order.account_type # 账号类型
33 account_id = order.account_id # 资金账号
34 stock_code = order.stock_code # 证券代码，例如"600000.SH"
35 order_id = order.order_id # 订单编号
36 order_sysid = order.order_sysid # 柜台合同编号
37 order_time = order.order_time # 报单时间
38 order_type = order.order_type # 委托类型，参见数据字典
39 order_volume = order.order_volume # 委托数量
40 price_type = order.price_type # 报价类型，该字段在返回时为柜台返回类型，不等价于下单传入的price_type，枚举值不一样功能一样，参见数据字典
41 price = order.price # 委托价格
42 traded_volume = order.traded_volume # 成交数量
43 traded_price = order.traded_price # 成交均价
44 order_status = order.order_status # 委托状态，参见数据字典
45 status_msg = order.status_msg # 委托状态描述，如废单原因
46 strategy_name = order.strategy_name # 策略名称
47 order_remark = order.order_remark # 委托备注
48 direction = order.direction # 多空方向，股票不适用；参见数据字典
49 offset_flag = order.offset_flag # 交易操作，用此字段区分股票买卖，期货开、平仓，期权买卖等；参见数据字典
50 
51 # 打印输出
52 print(f"""
53 =============================
54 委托信息
55 =============================
56 账号类型: {order.account_type},
57 资金账号: {order.account_id},
58 证券代码: {order.stock_code},
59 订单编号: {order.order_id},
60 柜台合同编号: {order.order_sysid},
61 报单时间: {order.order_time},
62 委托类型: {order.order_type},
63 委托数量: {order.order_volume},
64 报价类型: {order.price_type},
65 委托价格: {order.price},
66 成交数量: {order.traded_volume},
67 成交均价: {order.traded_price},
68 委托状态: {order.order_status},
69 委托状态描述: {order.status_msg},
70 策略名称: {order.strategy_name},
71 委托备注: {order.order_remark},
72 多空方向: {order.direction},
73 交易操作: {order.offset_flag}
74 """)
75 if order.strategy_name == strategy_name:
76 # 该委托是由本策略发出
77 ssid = order.order_sysid
78 status = order.order_status
79 market = order.stock_code.split(".")[1]
80 # print(ssid)
81 if ssid and status in [50,55]:
82 ## 使用cancel_order_stock_sysid_async时，投研端market参数可以填写为0，券商端按实际情况填写
83 print(xt_trade.cancel_order_stock_sysid_async(account,0,ssid))
84 
85 def on_stock_trade(self, trade):
86 """
87 成交变动推送
88 :param trade: XtTrade对象
89 :return:
90 """
91 print(datetime.datetime.now(), '成交回调', trade.order_remark,trade.stock_code,trade.traded_volume,trade.offset_flag)
92 
93 def on_order_stock_async_response(self, response):
94 """
95 异步下单回报推送
96 :param response: XtOrderResponse 对象
97 :return:
98 """
99
100 print(datetime.datetime.now(),'异步下单编号为：',response.seq)
101 
102 def on_cancel_order_stock_async_response(self, response):
103 """
104 异步撤单回报
105 :param response: XtCancelOrderResponse 对象
106 :return:
107 """
108 account_type = response.account_type # 账号类型
109 account_id = response.account_id # 资金账号
110 order_id = response.order_id # 订单编号
111 order_sysid = response.order_sysid # 柜台委托编号
112 cancel_result = response.cancel_result # 撤单结果
113 seq = response.seq # 异步撤单的请求序号
114 
115 print(f"""
116 ===========================
117 异步撤单回调信息
118 ===========================
119 账号类型: {response.account_type},
120 资金账号: {response.account_id},
121 订单编号: {response.order_id},
122 柜台委托编号: {response.order_sysid},
123 撤单结果: {response.cancel_result},
124 异步撤单的请求序号: {response.seq}""")
125 pass
126 
127 
128callback = MyXtQuantTraderCallback()
129# 填投研端的期货账号
130account = StockAccount("1000024",account_type = "FUTURE")
131# 填写投研端的股票账号
132# account = StockAccount("2000567")
133# 填投研端的userdata路径,miniqmt指定到userdata_mini
134xt_trade = xttrader.XtQuantTrader(r"C:\Program Files\测试1\迅投极速交易终端睿智融科版\userdata",int(time.time()))
135# 注册接受回调
136xt_trade.register_callback(callback)
137# 启动交易线程
138xt_trade.start()
139# 链接交易
140connect_result = xt_trade.connect()
141# 订阅账号信息，接受这个账号的回调，回调是账号维度的
142subscribe_result = xt_trade.subscribe(account)
143print(subscribe_result)
144 
145 
146code = "rb2410.SF"
147# code = "000001.SZ"
148 
149tick = xtdata.get_full_tick([code])[code]
150 
151last_price = tick["lastPrice"] # 最新价
152 
153ask_price = round(tick["askPrice"][0],3) # 卖方1档价
154bid_price = round(tick["bidPrice"][4],3) # 买方5档价
155 
156symbol_info = xtdata.get_instrument_detail(code)
157 
158up_limit = symbol_info["UpStopPrice"]
159down_limit = symbol_info["DownStopPrice"]
160 
161lots = 1
162res_id = xt_trade.order_stock_async(account, code, xtconstant.FUTURE_OPEN_LONG, lots, xtconstant.FIX_PRICE, down_limit, strategy_name, "跌停价/固定手数")
163 
164 
165# lots = 100
166# res_id = xt_trade.order_stock_async(account, code, xtconstant.STOCK_BUY, lots, xtconstant.FIX_PRICE, bid_price, strategy_name, "跌停价/固定手数")
167 
168 
169xtdata.run()
170 
171 
172 
173 

智能助手

咨询式 AI · 带入当前文档

智能助手加载中...