# qmt_trader交易框架 **Repository Path**: taote/qmt_trader_1 ## Basic Information - **Project Name**: qmt_trader交易框架 - **Description**: miniqmt交易框架 - **Primary Language**: Unknown - **License**: Not specified - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 1 - **Created**: 2025-10-31 - **Last Updated**: 2025-10-31 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README # qmt_trader交易框架 #### 介绍 首先，需要理解它们的关系和目标用户： QMT：迅投公司推出的专业量化交易系统。它功能全面，自带强大的策略编辑、回测、交易和风控界面，主要面向专业投资者、机构和高净值个人。 MiniQMT：是QMT的极简、轻量级版本。它剥离了QMT的GUI界面，只保留了最核心的交易API，以Python库的形式提供，主要面向希望使用自己本地IDE（如VSCode, PyCharm）进行策略开发的专业程序员。 你可以把它们类比为： QMT 像是一个功能齐全的“量化交易工作站”（类似Photoshop），集成了所有工具。 MiniQMT 像是一个纯粹的“交易引擎SDK”（类似一个图像处理库），让你可以在自己熟悉的环境里调用它的交易能力。 #### 软件架构 索普量化框架 大QMT，索普量化框架 导入大qmt就可以，这个是源代码版本，直接里面修改参数 全部内容在知识星球https://t.zsxq.com/0RYT4 ![输入图片说明](zsxqzsxq.jpg) 作者微信 ![输入图片说明](wx%E7%B4%A2%E6%99%AE.jpg) 量化官网http://14.103.193.242:9999/xms_quants.html ![输入图片说明](gwimage.png) #### 安装教程 pip 安装代码，安装服务器http://124.220.32.224:8888/ 安装教程，安键盘的win+r，输入cmd，输入下面的pip安装代码就可以 先安装xtquant 安装代码 ``` py -m pip install http://124.220.32.224:8888/xtquant-1.0.0-py3-none-any.whl ``` 老版本python安装 ``` pip install http://124.220.32.224:8888/xtquant-1.0.0-py3-none-any.whl ``` ``` py -m pip install http://124.220.32.224:8888/qmt_trader-1.0.0-py3-none-any.whl ``` ``` py -m pip install http://124.220.32.224:8888/qmt_trader-1.0.0-py3-none-any.whl ``` 低版本的安装代码 ``` pip install http://124.220.32.224:8888/qmt_trader-1.0.0-py3-none-any.whl ``` 更新版本的代码 ``` py -m pip install --force-reinstall http://124.220.32.224:8888/qmt_trader-1.0.0-py3-none-any.whl ``` 老版本pthon更新代码 ``` pip install --force-reinstall http://124.220.32.224:8888/qmt_trader-1.0.0-py3-none-any.whl ``` #### 使用说明 ### 1导入框架 框架导入代码 ``` from qmt_trader.qmt_trader import qmt_trader trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() print(trader.position()) ``` ### 2路径设置 点击安装路径点击属性，复制前面部分就可以 ![输入图片说明](1image.png) 后面的写法mini_userdata固定写法 ![输入图片说明](2image.png) ### 3设置账户 实盘，模拟盘设置都一样的 ![输入图片说明](3image.png) ### 4代码测试 点击运行 ![输入图片说明](4image.png) 读取的持股数据 ``` 操作方式,登录qmt,选择行情加交易选,择极简模式 作者:索普量化 作者微信:xms_quants1,开实盘qmt可以联系我,开户也可以 作者知识星球:金融量化交易研究院 https://t.zsxq.com/19VzjjXNi 开源网页教程https://gitee.com/quants/qmt_trader 链接qmt 0 持仓数量: 48 账号类型 资金账号 证券代码 证券代码1 股票余额 可用余额 成本价 参考成本价 市值 冻结数量 0 2 55001947 113045 113045.SH 10 10 133.480000 133.480000 1295.98 0 1 2 55001947 113577 113577.SH 10 10 152.445000 152.445000 1183.07 0 2 2 55001947 118005 118005.SH 10 10 121.770000 121.770000 1190.20 0 3 2 55001947 512480 512480.SH 3500 3500 1.559429 1.559429 5015.50 0 4 2 55001947 512530 512530.SH 100 100 1.601000 1.601000 160.40 0 5 2 55001947 516160 516160.SH 800 800 2.836250 2.836250 2133.60 0 6 2 55001947 562310 562310.SH 11600 11600 1.026431 1.026431 11286.80 0 7 2 55001947 600276 600276.SH 5000 5000 63.064168 63.064168 325650.00 0 8 2 55001947 600592 600592.SH 4600 4600 23.851933 23.851933 111228.00 0 9 2 55001947 600617 600617.SH 100 100 4.030000 4.030000 440.00 0 10 2 55001947 600705 600705.SH 2800 2800 3.481821 3.481821 9716.00 0 11 2 55001947 601360 601360.SH 5000 5000 10.769594 10.769594 51600.00 0 12 2 55001947 601398 601398.SH 890100 0 7.642639 7.642639 6773661.00 0 13 2 55001947 603020 603020.SH 21400 21400 9.349583 9.349583 220634.00 0 14 2 55001947 603196 603196.SH 200 200 19.235200 19.235200 4638.00 0 15 2 55001947 603259 603259.SH 1600 1600 97.616456 97.616456 158224.00 0 16 2 55001947 603266 603266.SH 200 200 22.315200 22.315200 4408.00 0 17 2 55001947 603270 603270.SH 100 100 26.640300 26.640300 2435.00 0 18 2 55001947 603285 603285.SH 200 200 24.885250 24.885250 5040.00 0 19 2 55001947 603429 603429.SH 400 400 11.902625 11.902625 4016.00 0 20 2 55001947 603569 603569.SH 400 400 10.432600 10.432600 3352.00 0 21 2 55001947 603656 603656.SH 0 0 0.000000 0.000000 0.00 0 22 2 55001947 603893 603893.SH 4800 4800 178.632665 178.632665 890880.00 0 23 2 55001947 605266 605266.SH 0 0 0.000000 0.000000 0.00 0 24 2 55001947 000066 000066.SZ 4600 4600 17.870565 17.870565 73646.00 0 25 2 55001947 001218 001218.SZ 200 200 18.445000 18.445000 4244.00 0 26 2 55001947 002031 002031.SZ 5000 5000 8.134164 8.134164 38600.00 0 27 2 55001947 002138 002138.SZ 600 600 36.538917 36.538917 21114.00 0 28 2 55001947 002241 002241.SZ 1100 1100 27.760000 27.760000 33451.00 0 29 2 55001947 002261 002261.SZ 2400 2400 33.740113 33.740113 83904.00 0 30 2 55001947 002326 002326.SZ 200 200 17.575000 17.575000 3296.00 0 31 2 55001947 002353 002353.SZ 200 200 46.965000 46.965000 10216.00 0 32 2 55001947 002456 002456.SZ 5000 5000 11.969168 11.969168 58850.00 0 33 2 55001947 123168 123168.SZ 10 10 131.985000 131.985000 1242.15 0 34 2 55001947 123221 123221.SZ 10 10 184.024000 184.024000 1412.06 0 35 2 55001947 127030 127030.SZ 10 10 120.624000 120.624000 1191.33 0 36 2 55001947 127052 127052.SZ 10 10 151.530000 151.530000 1379.83 0 37 2 55001947 127078 127078.SZ 10 10 140.450000 140.450000 1314.03 0 38 2 55001947 127079 127079.SZ 10 10 146.447000 146.447000 1741.18 0 39 2 55001947 128101 128101.SZ 10 10 135.972000 135.972000 1237.46 0 40 2 55001947 128117 128117.SZ 80 80 125.693625 125.693625 10868.40 0 41 2 55001947 159351 159351.SZ 200 200 1.112000 1.112000 232.20 0 42 2 55001947 159680 159680.SZ 200 200 1.498000 1.498000 293.60 0 43 2 55001947 159915 159915.SZ 100 100 2.638000 2.638000 297.10 0 44 2 55001947 300120 300120.SZ 2400 2400 10.403487 10.403487 29568.00 0 45 2 55001947 300339 300339.SZ 400 400 59.730025 59.730025 23632.00 0 46 2 55001947 300458 300458.SZ 400 400 51.997425 51.997425 18804.00 0 47 2 55001947 301152 301152.SZ 3000 0 31.238640 31.238640 94350.00 0 PS C:\Users\lxg123456\Desktop\开源库> ``` ### 5设置滑点函数select_slippage 调用的源代码 ``` from qmt_trader.qmt_trader import qmt_trader trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() print(trader.select_slippage(stock='600031',price=15.01,trader_type='buy')) ``` 调用结果 ``` 操作方式,登录qmt,选择行情加交易选,择极简模式 作者:索普量化 作者微信:xms_quants1,开实盘qmt可以联系我,开户也可以 作者知识星球:金融量化交易研究院 https://t.zsxq.com/19VzjjXNi 开源网页教程https://gitee.com/quants/qmt_trader 链接qmt 0 15.02 ``` 底层的源代码 ``` def select_slippage(self,stock='600031',price=15.01,trader_type='buy'): ''' 选择滑点 安价格来滑点，比如0.01就是一块 etf3位数,股票可转债2位数 ''' stock=self.adjust_stock(stock=stock) data_type=self.select_data_type(stock=stock) if data_type=='fund' or data_type=='bond': slippage=self.slippage/10 if trader_type=='buy' or trader_type==23: price=price+slippage else: price=price-slippage else: slippage=self.slippage if trader_type=='buy' or trader_type==23: price=price+slippage else: price=price-slippage return price ``` ### 6检查是不是交易时间check_is_trader_date_1 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() print(trader.check_is_trader_date_1()) ``` 调用的结果 ``` 链接qmt 0 False ``` 底层源代码 ``` def check_is_trader_date_1(self,trader_time=4,start_date=9,end_date=14,start_mi=0,jhjj='否'): ''' 检测是不是交易时间 ''' if jhjj=='是': jhjj_time=15 else: jhjj_time=30 loc=time.localtime() tm_hour=loc.tm_hour tm_min=loc.tm_min wo=loc.tm_wday if wo<=trader_time: if tm_hour>=start_date and tm_hour<=end_date: if tm_hour==9 and tm_min=start_mi: return True else: return False else: return False else: print('周末') return False ``` ### 7识别标的类型select_data_type 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() print(trader.select_data_type(stock='600031')) ``` 结果 ``` 链接qmt 0 stock ``` 底层的源代码 ``` def select_data_type(self,stock='600031'): ''' 选择数据类型 ''' stock=str(stock) if stock[:2] in ['11','12'] or stock[:3] in ['123','110','113','123','127','128','118','132','120']: return 'bond' elif stock[:2] in ['51','15','50','16','18','52']: return 'fund' else: return 'stock' ``` ### 8调整股票代码adjust_stock 源代码 ``` from qmt_trader.qmt_trader import qmt_trader trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() print(trader.adjust_stock(stock='600031')) ``` 输出结果 ``` 链接qmt 0 600031.SH ``` 底层源代码 ``` def adjust_stock(self,stock='600031.SH'): ''' 调整代码 ''' if stock[-2:]=='SH' or stock[-2:]=='SZ' or stock[-2:]=='sh' or stock[-2:]=='sz': stock=stock.upper() else: if stock[:3] in ['600','601','603','605','688','689', ] or stock[:2] in ['11','51','58']: stock=stock+'.SH' else: stock=stock+'.SZ' return stock ``` ### 9检查是否可以买入check_stock_is_av_buy 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() print(trader.check_stock_is_av_buy(stock='513100',price=1.855,amount=10)) ``` 数据结果 ``` 链接qmt 0 持仓数量: 48 允许买入513100 可用现金13605824.53大于买入金额18.55 价格1.855 数量10 True ``` 底层代码 ``` def check_stock_is_av_buy(self,stock='128036',price='156.700',amount=10,hold_limit=100000): ''' 检查是否可以买入 ''' hold_stock=self.position() try: del hold_stock['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass #买入是价值 value=price*amount cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] if cash>=value: print('允许买入{} 可用现金{}大于买入金额{} 价格{} 数量{}'.format(stock,cash,value,price,amount)) return True else: print('不允许买入{} 可用现金{}小于买入金额{} 价格{} 数量{}'.format(stock,cash,value,price,amount)) return False ``` ### 10检查是否可以卖出 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() print(trader.check_stock_is_av_sell(stock='513100',amount=100)) ``` 输出结果 ``` 链接qmt 0 持仓数量: 48 不允许卖出没有持股：513100 持股0 卖出100 False ``` 底层源代码 ``` def check_stock_is_av_sell(self,stock='128036',amount=10): ''' 检查是否可以卖出 ''' #stock=self.adjust_stock(stock=stock) hold_data=self.position() try: del hold_data['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass #买入是价值 cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] stock_list=hold_data['证券代码'].tolist() if stock in stock_list: hold_num=hold_data[hold_data['证券代码']==stock]['可用余额'].tolist()[-1] if hold_num>=amount: print('允许卖出：{} 持股{} 卖出{}'.format(stock,hold_num,amount)) return True else: print('不允许卖出持股不足：{} 持股{} 卖出{}'.format(stock,hold_num,amount)) return False else: print('不允许卖出没有持股：{} 持股{} 卖出{}'.format(stock,0,amount)) return False ``` ### 11链接qmt函数 源代码 ``` from qmt_trader.qmt_trader import qmt_trader trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() ``` 结果 ``` 链接qmt 0 ``` 底层源代码 ``` def connect(self): ''' 连接 path qmt userdata_min是路径 session_id 账户的标志,随便 account账户, account_type账户内类型 ''' print('链接qmt') # path为mini qmt客户端安装目录下userdata_mini路径 path = self.path # session_id为会话编号，策略使用方对于不同的Python策略需要使用不同的会话编号 session_id = self.session_id xt_trader = XtQuantTrader(path, session_id) # 创建资金账号为1000000365的证券账号对象 account=self.account account_type=self.account_type acc = StockAccount(account_id=account,account_type=account_type) # 创建交易回调类对象，并声明接收回调 callback = MyXtQuantTraderCallback() xt_trader.register_callback(callback) # 启动交易线程 xt_trader.start() # 建立交易连接，返回0表示连接成功 connect_result = xt_trader.connect() if connect_result==0: # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = xt_trader.subscribe(acc) print(subscribe_result) self.xt_trader=xt_trader self.acc=acc return xt_trader,acc else: print('qmt连接失败') ``` ### 12下单函数 源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() fix_result_order_id=trader.order_stock(stock_code='513100', order_type=xtconstant.STOCK_BUY, order_volume=100, price_type=xtconstant.FIX_PRICE, price=1.844, strategy_name='', order_remark='') print(fix_result_order_id) ``` 结果 ``` 链接qmt 0 None 交易类型23 代码513100.SH 价格1.845 数量100 订单编号1098912896 1098912896 ``` 下单的结果 ![输入图片说明](5image.png) 底层源代码 ``` def order_stock(self,stock_code='600031.SH', order_type=xtconstant.STOCK_BUY, order_volume=100,price_type=xtconstant.FIX_PRICE,price=20,strategy_name='',order_remark=''): ''' 下单，统一接口 :param account: 证券账号 :param stock_code: 证券代码, 例如"600000.SH" :param order_type: 委托类型, 23:买, 24:卖 :param order_volume: 委托数量, 股票以'股'为单位, 债券以'张'为单位 :param price_type: 报价类型, 详见帮助手册 :param price: 报价价格, 如果price_type为指定价, 那price为指定的价格, 否则填0 :param strategy_name: 策略名称 :param order_remark: 委托备注 :return: 返回下单请求序号, 成功委托后的下单请求序号为大于0的正整数, 如果为-1表示委托失败 ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = self.xt_trader.subscribe(self.acc) print(self.xt_trader.query_stock_asset_async(account=self.acc,callback=subscribe_result)) #print(subscribe_result) stock_code = self.adjust_stock(stock=stock_code) price=self.select_slippage(stock=stock_code,price=price,trader_type=order_type) # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态 fix_result_order_id = self.xt_trader.order_stock(account=self.acc,stock_code=stock_code, order_type=order_type, order_volume=order_volume, price_type=price_type, price=price, strategy_name=strategy_name, order_remark=order_remark) print('交易类型{} 代码{} 价格{} 数量{} 订单编号{}'.format(order_type,stock_code,price,order_volume,fix_result_order_id)) return fix_result_order_id ``` ### 13order_type类型参数说明 ``` STOCK_BUY = 23 STOCK_SELL = 24 CREDIT_BUY = 23 #担保品买入 CREDIT_SELL = 24 #担保品卖出 CREDIT_FIN_BUY = 27 #融资买入 CREDIT_SLO_SELL = 28 #融券卖出 CREDIT_BUY_SECU_REPAY = 29 #买券还券 CREDIT_DIRECT_SECU_REPAY = 30 #直接还券 CREDIT_SELL_SECU_REPAY = 31 #卖券还款 CREDIT_DIRECT_CASH_REPAY = 32 #直接还款 CREDIT_FIN_BUY_SPECIAL = 40 #专项融资买入 CREDIT_SLO_SELL_SPECIAL = 41 #专项融券卖出 CREDIT_BUY_SECU_REPAY_SPECIAL = 42 #专项买券还券 CREDIT_DIRECT_SECU_REPAY_SPECIAL = 43 #专项直接还券 CREDIT_SELL_SECU_REPAY_SPECIAL = 44 #专项卖券还款 CREDIT_DIRECT_CASH_REPAY_SPECIAL = 45 #专项直接还款 ``` ### 14price_type类型说明 ``` """ 报价类型 """ # 最新价 LATEST_PRICE = 5 # 指定价/限价 FIX_PRICE = 11 # 市价最优价[郑商所][期货] MARKET_BEST = 18 # 市价即成剩撤[大商所][期货] MARKET_CANCEL = 19 # 市价全额成交或撤[大商所][期货] MARKET_CANCEL_ALL = 20 # 市价最优一档即成剩撤[中金所][期货] MARKET_CANCEL_1 = 21 # 市价最优五档即成剩撤[中金所][期货] MARKET_CANCEL_5 = 22 # 市价最优一档即成剩转[中金所][期货] MARKET_CONVERT_1 = 23 # 市价最优五档即成剩转[中金所][期货] MARKET_CONVERT_5 = 24 # 最优五档即时成交剩余撤销[上交所][北交所][股票] MARKET_SH_CONVERT_5_CANCEL = 42 # 最优五档即时成交剩转限价[上交所][北交所][股票] MARKET_SH_CONVERT_5_LIMIT = 43 # 对手方最优价格委托[上交所[股票]][深交所[股票][期权]][北交所[股票]] MARKET_PEER_PRICE_FIRST = 44 # 本方最优价格委托[上交所[股票]][深交所[股票][期权]][北交所[股票]] MARKET_MINE_PRICE_FIRST = 45 # 即时成交剩余撤销委托[深交所][股票][期权] MARKET_SZ_INSTBUSI_RESTCANCEL = 46 # 最优五档即时成交剩余撤销[深交所][股票][期权] MARKET_SZ_CONVERT_5_CANCEL = 47 # 全额成交或撤销委托[深交所][股票][期权] MARKET_SZ_FULL_OR_CANCEL = 48 ``` ### 15买入函数 函数用统一下单函数独立出来 源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() fix_result_order_id=trader.buy(security='600031.SH', order_type=xtconstant.STOCK_BUY, amount=100, price_type=xtconstant.FIX_PRICE, price=20, strategy_name='', order_remark='') print(fix_result_order_id) ``` 结果 ``` 链接qmt 0 None 交易类型23 代码600031.SH 价格20.01 数量100 订单编号5 5 ``` 下单结果 ![输入图片说明](6image.png) 底层源代码 ``` def buy(self,security='600031.SH', order_type=xtconstant.STOCK_BUY, amount=100,price_type=xtconstant.FIX_PRICE,price=20,strategy_name='',order_remark=''): ''' 单独独立股票买入函数 ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = self.xt_trader.subscribe(self.acc) print(self.xt_trader.query_stock_asset_async(account=self.acc,callback=subscribe_result)) #print(subscribe_result) stock_code =self.adjust_stock(stock=security) price=self.select_slippage(stock=security,price=price,trader_type='buy') order_volume=amount # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态 if order_volume>0: fix_result_order_id = self.xt_trader.order_stock_async(account=self.acc,stock_code=stock_code, order_type=order_type, order_volume=order_volume, price_type=price_type, price=price, strategy_name=strategy_name, order_remark=order_remark) print('交易类型{} 代码{} 价格{} 数量{} 订单编号{}'.format(order_type,stock_code,price,order_volume,fix_result_order_id)) return fix_result_order_id else: print('买入 标的{} 价格{} 委托数量{}小于0有问题'.format(stock_code,price,order_volume)) ``` ### 16卖出函数 统一下单的函数里面独立出来的 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() fix_result_order_id=trader.sell(security='600031.SH', order_type=xtconstant.STOCK_SELL, amount=100, price_type=xtconstant.FIX_PRICE, price=20, strategy_name='', order_remark='') print(fix_result_order_id) ``` 结果 ``` 交易类型24 代码600031.SH 价格19.99 数量100 订单编号1098914848 1098914848 ``` 下单结果 ![输入图片说明](7image.png) 底层源代码 ``` def sell(self,security='600031.SH', order_type=xtconstant.STOCK_SELL, amount=100,price_type=xtconstant.FIX_PRICE,price=20,strategy_name='',order_remark=''): ''' 单独独立股票卖出函数 ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = self.xt_trader.subscribe(self.acc) print(self.xt_trader.query_stock_asset_async(account=self.acc,callback=subscribe_result)) #print(subscribe_result) stock_code =self.adjust_stock(stock=security) price=self.select_slippage(stock=security,price=price,trader_type='sell') order_volume=amount # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态 if order_volume>0: fix_result_order_id = self.xt_trader.order_stock(account=self.acc,stock_code=stock_code, order_type=order_type, order_volume=order_volume, price_type=price_type, price=price, strategy_name=strategy_name, order_remark=order_remark) print('交易类型{} 代码{} 价格{} 数量{} 订单编号{}'.format(order_type,stock_code,price,order_volume,fix_result_order_id)) return fix_result_order_id else: print('卖出 标的{} 价格{} 委托数量{}小于0有问题'.format(stock_code,price,order_volume)) ``` ### 17异步下单 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() fix_result_order_id=trader.order_stock_async( stock_code='600111.SH', order_type=xtconstant.STOCK_BUY, order_volume=200, price_type=xtconstant.FIX_PRICE, price=18, strategy_name='', order_remark='') print(fix_result_order_id) ``` 调用结果 ``` 链接qmt 0 None 交易类型23 代码600111.SH 价格18.01 数量200 订单编号5 5 ``` 下单结果 ![输入图片说明](8image.png) 底层源代码 ``` def order_stock_async(self,stock_code='600031.SH', order_type=xtconstant.STOCK_BUY, order_volume=100,price_type=xtconstant.FIX_PRICE,price=20,strategy_name='',order_remark=''): ''' 释义 - 对股票进行异步下单操作，异步下单接口如果正常返回了下单请求序号seq，会收到on_order_stock_async_response的委托反馈 * 参数 - account - StockAccount 资金账号 - stock_code - str 证券代码， 如'600000.SH' - order_type - int 委托类型 - order_volume - int 委托数量，股票以'股'为单位，债券以'张'为单位 - price_type - int 报价类型 - price - float 委托价格 - strategy_name - str 策略名称 - order_remark - str 委托备注 ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = self.xt_trader.subscribe(self.acc) print(self.xt_trader.query_stock_asset_async(account=self.acc,callback=subscribe_result)) #print(subscribe_result) stock_code = self.adjust_stock(stock=stock_code) price=self.select_slippage(stock=stock_code,price=price,trader_type=order_type) # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态 fix_result_order_id = self.xt_trader.order_stock_async(account=self.acc,stock_code=stock_code, order_type=order_type, order_volume=order_volume, price_type=price_type, price=price, strategy_name=strategy_name, order_remark=order_remark) print('交易类型{} 代码{} 价格{} 数量{} 订单编号{}'.format(order_type,stock_code,price,order_volume,fix_result_order_id)) return fix_result_order_id ``` ### 18撤单 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() del_list=[56,57] df=trader.today_entrusts() print(df) if df.shape[0]>0: df['不能撤单']=df['委托状态'].apply(lambda x: '是' if x in del_list else '不是') df=df[df['不能撤单']=='不是'] for stock,trader_id in zip(df['证券代码'],df['订单编号']): print(stock,trader.cancel_order_stock(order_id=trader_id)) ``` 结果 ``` 链接qmt 0 委托数量 6 账号类型 资金账号 证券代码 订单编号 柜台合同编号 ... 策略名称 委托备注 委托状态翻译 未成交数量 未成交价值 0 2 55001947 513100 1098912896 4820 ... 已报 100 184.5 1 2 55001947 600031 1098913792 5396 ... 已报 100 2001.0 2 2 55001947 600031 1098914755 5987 ... 已报 100 1999.0 3 2 55001947 600031 1098914848 xt1098914848 ... 废单 100 1999.0 4 2 55001947 600031 1098914890 xt1098914890 ... 废单 100 1999.0 5 2 55001947 600111 1098915098 6240 ... 已报 200 3602.0 [6 rows x 19 columns] 成功 0 成功 0 成功 0 成功 0 ``` 结果 ![输入图片说明](9image.png) 底层源代码 ``` def cancel_order_stock(self,order_id=12): ''' :param account: 证券账号 :param order_id: 委托编号, 报单时返回的编号 :return: 返回撤单成功或者失败, 0:成功, -1:委托已完成撤单失败, -2:未找到对应委托编号撤单失败, -3:账号未登陆撤单失败 ''' # 使用订单编号撤单 cancel_order_result = self.xt_trader.cancel_order_stock(account=self.acc,order_id=order_id) if cancel_order_result==0: print('成功') elif cancel_order_result==-1: print('委托已完成撤单失败') elif cancel_order_result==-2: print('找到对应委托编号撤单失败') elif cancel_order_result==-3: print('账号未登陆撤单失败') else: pass return cancel_order_result ``` ### 19异步撤单 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() trader.buy(security='513100',price=10,amount=100) del_list=[56,57] df=trader.today_entrusts() print(df) if df.shape[0]>0: df['不能撤单']=df['委托状态'].apply(lambda x: '是' if x in del_list else '不是') df=df[df['不能撤单']=='不是'] for stock,trader_id in zip(df['证券代码'],df['订单编号']): print(stock,trader.cancel_order_stock_async(order_id=trader_id)) else: print('没有委托数据') ``` 结果 ``` [6 rows x 19 columns] 513100 7 600031 8 600031 9 600111 10 ``` ![输入图片说明](10image.png) 底层源代码 ``` def cancel_order_stock_async(self,order_id=12): ''' * 释义 - 根据订单编号对委托进行异步撤单操作 * 参数 - account - StockAccount 资金账号 - order_id - int 下单接口返回的订单编号 * 返回 - 返回撤单请求序号, 成功委托后的撤单请求序号为大于0的正整数, 如果为-1表示委托失败 * 备注 - 如果失败，则通过撤单失败主推接口返回撤单失败信息 ''' # 使用订单编号撤单 cancel_order_result = self.xt_trader.cancel_order_stock_async(account=self.acc,order_id=order_id) if cancel_order_result==0: print('成功') elif cancel_order_result==-1: print('委托已完成撤单失败') elif cancel_order_result==-2: print('找到对应委托编号撤单失败') elif cancel_order_result==-3: print('账号未登陆撤单失败') else: pass return cancel_order_result ``` ### 20获取账户数据 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.query_stock_asset() print(df) ``` 调用结果 ``` 链接qmt 0 {'账号类型': 2, '资金账户': '55001947', '可用金额': 15859372.44, '冻结金额': 0.0, '持仓市值': 6854481.289999998, '总资产': 22714214.98} ``` 底层代码 ``` def query_stock_asset(self): ''' :param account: 证券账号 :return: 返回当前证券账号的资产数据 ''' # 查询证券资产 asset = self.xt_trader.query_stock_asset(account=self.acc) data_dict={} if asset: data_dict['账号类型']=asset.account_type data_dict['资金账户']=asset.account_id data_dict['可用金额']=asset.cash data_dict['冻结金额']=asset.frozen_cash data_dict['持仓市值']=asset.market_value data_dict['总资产']=asset.total_asset return data_dict else: print('获取失败资金') data_dict['账号类型']=[None] data_dict['资金账户']=[None] data_dict['可用金额']=[None] data_dict['冻结金额']=[None] data_dict['持仓市值']=[None] data_dict['总资产']=[None] return data_dict ``` ### 21获取资金数据 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.balance() print(df) ``` 结果 ``` 链接qmt 0 账号类型 资金账户 可用金额 冻结金额 持仓市值 总资产 0 2 55001947 15857465.63 0.0 6856125.08 22719721.05 ``` 底层源代码 ``` def balance(self): ''' pandas数据 ''' try: asset = self.xt_trader.query_stock_asset(account=self.acc) df=pd.DataFrame() if asset: df['账号类型']=[asset.account_type] df['资金账户']=[asset.account_id] df['可用金额']=[asset.cash] df['冻结金额']=[asset.frozen_cash] df['持仓市值']=[asset.market_value] df['总资产']=[asset.total_asset] return df except: print('获取账户失败，读取上次数据，谨慎使用') df=pd.DataFrame() return df ``` ### 22当日委托 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.query_stock_orders() print(df) ``` 结果 ``` 链接qmt 0 委托数量 8 账号类型 资金账号 证券代码 订单编号 柜台合同编号 ... 成交均价 委托状态 委托状态 描述 策略名称 委托备注 0 2 55001947 513100 1098912896 4820 ... 0.000 54 1 2 55001947 600031 1098913792 5396 ... 0.000 54 2 2 55001947 600031 1098914755 5987 ... 0.000 54 3 2 55001947 600031 1098914848 xt1098914848 ... 0.000 57 [COUNTER][251005][证 4 2 55001947 600031 1098914890 xt1098914890 ... 0.000 57 [COUNTER][251005][证 5 2 55001947 600111 1098915098 6240 ... 0.000 54 6 2 55001947 513100 1098918324 7373 ... 1.889 56 7 2 55001947 601398 1098918544 7564 ... 7.600 56 hotkey SELL_0.33 [8 rows x 16 columns] ``` 底层源代码 ``` def query_stock_orders(self): ''' 当日委托 :param account: 证券账号 :param cancelable_only: 仅查询可撤委托 :return: 返回当日所有委托的委托对象组成的list ''' orders = self.xt_trader.query_stock_orders(self.acc) print("委托数量", len(orders)) data=pd.DataFrame() if len(orders) != 0: for i in range(len(orders)): df=pd.DataFrame() df['账号类型']=[orders[i].account_type] df['资金账号']=[orders[i].account_id] df['证券代码']=[orders[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['订单编号']=[orders[i].order_id] df['柜台合同编号']=[orders[i].order_sysid] df['报单时间']=[orders[i].order_time] df['委托类型']=[orders[i].order_type] df['委托数量']=[orders[i].order_volume] df['报价类型']=[orders[i].price_type] df['委托价格']=[orders[i].price] df['成交数量']=[orders[i].traded_volume] df['成交均价']=[orders[i].traded_price] df['委托状态']=[orders[i].order_status] df['委托状态描述']=[orders[i].status_msg] df['策略名称']=[orders[i].strategy_name] df['委托备注']=[orders[i].order_remark] data=pd.concat([data,df],ignore_index=True) data['报单时间']=pd.to_datetime(data['报单时间'],unit='s') return data else: print('目前没有委托') return data ``` ### 23当日委托2 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.today_entrusts() print(df) ``` 结果 ``` 0 委托数量 8 账号类型 资金账号 证券代码 订单编号 柜台合同编号 ... 策略名称 委托备注 委托状态翻译 未成交数量 未成交价值 0 2 55001947 513100 1098912896 4820 ... 已撤 100 184.5 1 2 55001947 600031 1098913792 5396 ... 已撤 100 2001.0 2 2 55001947 600031 1098914755 5987 ... 已撤 100 1999.0 3 2 55001947 600031 1098914848 xt1098914848 ... 废单 100 1999.0 4 2 55001947 600031 1098914890 xt1098914890 ... 废单 100 1999.0 5 2 55001947 600111 1098915098 6240 ... 已撤 200 3602.0 6 2 55001947 513100 1098918324 7373 ... 已成 0 0.0 7 2 55001947 601398 1098918544 7564 ... hotkey SELL_0.33 已成 0 0.0 [8 rows x 19 columns] ``` 底层源代码 ``` def today_entrusts(self): ''' 今天委托 ''' def select_data(x): if x==48: return '未报' elif x==49: return '待报' elif x==50: return '已报' elif x==51: return '已报待撤' elif x==52: return '部分待撤' elif x==53: return '部撤' elif x==54: return '已撤' elif x==55: return '部成' elif x==56: return '已成' elif x==57: return '废单' else: return '废单' orders = self.xt_trader.query_stock_orders(self.acc) print("委托数量", len(orders)) data=pd.DataFrame() if len(orders) != 0: for i in range(len(orders)): df=pd.DataFrame() df['账号类型']=[orders[i].account_type] df['资金账号']=[orders[i].account_id] df['证券代码']=[orders[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['订单编号']=[orders[i].order_id] df['柜台合同编号']=[orders[i].order_sysid] df['报单时间']=[orders[i].order_time] df['委托类型']=[orders[i].order_type] df['委托数量']=[orders[i].order_volume] df['报价类型']=[orders[i].price_type] df['委托价格']=[orders[i].price] df['成交数量']=[orders[i].traded_volume] df['成交均价']=[orders[i].traded_price] df['委托状态']=[orders[i].order_status] df['委托状态描述']=[orders[i].status_msg] df['策略名称']=[orders[i].strategy_name] df['委托备注']=[orders[i].order_remark] data=pd.concat([data,df],ignore_index=True) data['报单时间']=df['报单时间'].apply(conv_time) data['委托状态翻译']=data['委托状态'].apply(select_data) data['未成交数量']=data['委托数量']-data['成交数量'] data['未成交价值']=data['未成交数量']*data['委托价格'] return data else: print('目前没有委托') return data ``` ### 24获取合约基础信息 源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.get_instrument_detail(stock_code='513100.SH') print(df) ``` 结果 ``` {'ExchangeID': 'SH', 'InstrumentID': '513100', 'InstrumentName': '纳指ETF', 'ProductID': '', 'ProductName': '', 'ProductType': None, 'ExchangeCode': '513100', 'UniCode': '513100', 'CreateDate': '0', 'OpenDate': '20130515', 'ExpireDate': '99999999', 'TradingDay': '20251021', 'PreClose': 1.859, 'SettlementPrice': 1.859, 'UpStopPrice': 2.045, 'DownStopPrice': 1.673, 'FloatVolume': 330622120.0, 'TotalVolume': 330622120.0, 'LongMarginRatio': 0.0, 'ShortMarginRatio': 0.0, 'PriceTick': 0.001, 'VolumeMultiple': 1, 'MainContract': 0, 'LastVolume': 0, 'InstrumentStatus': 0, 'IsTrading': False, 'IsRecent': False, 'ProductTradeQuota': 0, 'ContractTradeQuota': 0, 'ProductOpenInterestQuota': 0, 'ContractOpenInterestQuota': 0} PS C:\Users\lxg123456\Desktop\开源库> ``` 底层代码 ``` def get_instrument_detail(self,stock_code='600031.SH'): ''' models=qmt_data() df=models.get_instrument_detail() print(df) 释义 获取合约基础信息 参数 stock_code - string 合约代码 iscomplete - bool 是否获取全部字段，默认为False 返回 dict 数据字典，{ field1 : value1, field2 : value2, ... }，找不到指定合约时返回None iscomplete为False时，返回以下字段 ExchangeID - string 合约市场代码 InstrumentID - string 合约代码 InstrumentName - string 合约名称 ProductID - string 合约的品种ID(期货) ProductName - string 合约的品种名称(期货) ExchangeCode - string 交易所代码 UniCode - string 统一规则代码 CreateDate - str 上市日期(期货) OpenDate - str IPO日期(股票) ExpireDate - int 退市日或者到期日 PreClose - float 前收盘价格 SettlementPrice - float 前结算价格 UpStopPrice - float 当日涨停价 DownStopPrice - float 当日跌停价 FloatVolume - float 流通股本 TotalVolume - float 总股本 LongMarginRatio - float 多头保证金率 ShortMarginRatio - float 空头保证金率 PriceTick - float 最小价格变动单位 VolumeMultiple - int 合约乘数(对期货以外的品种，默认是1) MainContract - int 主力合约标记，1、2、3分别表示第一主力合约，第二主力合约，第三主力合约 LastVolume - int 昨日持仓量 InstrumentStatus - int 合约停牌状态 IsTrading - bool 合约是否可交易 IsRecent - bool 是否是近月合约 ''' df=xtdata.get_instrument_detail(stock_code) return df ``` ### 25检查股票是否涨停跌停 第哦啊有代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.get_check_stock_is_limit_down(stock='513100.SH') print(df) ``` 结果 ``` ***** xtdata连接成功 2025-10-21 10:13:28***** 服务信息: {'tag': 'sp3', 'version': '1.0'} 服务地址: 127.0.0.1:58610 数据路径: D:\国金QMT交易端模拟\bin.x64/../userdata_mini/datadir 设置xtdata.enable_hello = False可隐藏此消息 正常 ``` 底层代码 ``` def get_check_stock_is_limit_down(self,stock='600031'): ''' 检查股票是否涨停跌停 ''' stock=self.adjust_stock(stock=stock) instrument=self.get_instrument_detail(stock_code=stock) spot_data=self.get_full_tick(code_list=[stock]) last_price=spot_data[stock]['lastPrice'] UpStopPrice=instrument['UpStopPrice'] DownStopPrice=instrument['DownStopPrice'] if last_price>=UpStopPrice: return '涨停' elif last_price<=DownStopPrice: return '跌停' else: return '正常' ``` ### 26检查没有成交的当日委托 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.get_check_not_trader_today_entrusts(stock='600031',trader_type='buy',data_type='数量') print(df) ``` 结果 ``` 链接qmt 0 委托数量 8 没有委托2/委托已经成交 (0, '没有委托2/委托已经成交') ``` 底层源代码 ``` def get_check_not_trader_today_entrusts(self,stock='600031',trader_type='buy',data_type='数量'): ''' 检查没有成交的当日委托 ''' stock=self.adjust_stock(stock=stock) df=self.today_entrusts() stock=str(stock)[:6] if df.shape[0]>0: df1=df[df['委托状态']<=53] if df1.shape[0]>0: df2=df1[df1['证券代码']==stock] if df2.shape[0]>0: if trader_type=='buy': df2=df2[df['委托类型']==23] if data_type=='数量': amount=df2['未成交数量'].sum() print('{}委托买入数量{}'.format(stock,amount)) return amount,df2 else: value=df2['未成交价值'].sum() print('{}委托买入价值{}'.format(stock,value)) return value,df2 else: df2=df2[df['委托类型']==24] if data_type=='数量': amount=df2['未成交数量'].sum() print('{}委托卖出数量{}'.format(stock,amount)) return amount,df2 else: value=df2['未成交价值'].sum() print('{}价值{}'.format(stock,value)) return value,df2 else: print('{}没有委托1/委托已经成交'.format(stock)) return 0,'没有委托1/委托已经成交' else: print('没有委托2/委托已经成交') return 0,'没有委托2/委托已经成交' else: print('今天没有委托3/委托已经成交') return 0,'没有委托/委托已经成交' ``` ### 27通过证券代码来撤单 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.cancel_order_stock_async_by_code(cancel_type='all',stock='600031',num='all') print(df) ``` 底层源代码 ``` def cancel_order_stock_async_by_code(self,cancel_type='all',stock='600031',num='all'): ''' 通过证券代码来撤单 类型cancel_type=all/buy/sell/one 在有多个单时候选择怎么样撤单num=0/all ''' # 使用订单编号撤单 entrusts=self.today_entrusts() entrusts=entrusts[entrusts['委托状态']<=48] entrusts=entrusts[entrusts['委托状态']<=53] if entrusts.shape[0]>0: #stock=self.adjust_stock(stock=stock) entrusts['证券代码']=entrusts['证券代码'].astype(str) stock_list=entrusts['证券代码'].tolist() if stock in stock_list: if cancel_type=='all': order_id_list=entrusts['订单编号'].tolist() for order_id in order_id_list: self.cancel_order_stock_async(order_id=order_id) elif cancel_type=='buy': entrusts_buy=entrusts[entrusts['委托类型']==xtconstant.STOCK_BUY] order_id_list=entrusts_buy['订单编号'].tolist() for order_id in order_id_list: self.cancel_order_stock_async(order_id=order_id) elif cancel_type=='sell': entrusts_sell=entrusts[entrusts['委托类型']==xtconstant.STOCK_SELL] order_id_list=entrusts_sell['订单编号'].tolist() for order_id in order_id_list: self.cancel_order_stock_async(order_id=order_id) else: entrusts_on=entrusts[entrusts['证券代码']==stock] if num=='all': order_id_list=entrusts_on['订单编号'].tolist() for order_id in order_id_list: self.cancel_order_stock_async(order_id=order_id) else: order_id_list=entrusts_on['订单编号'].tolist() self.cancel_order_stock_async(order_id=order_id_list[num]) ``` ### 28当日成交 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.query_stock_trades() print(df) ``` 结果 ``` 账号类型 资金账号 证券代码 委托类型 成交编号 成交时间 ... 订单编号 柜台合同编号 策略名称 委托备注 多空方向 交易操作 0 2 55001947 513100 23 50019902 2025-10-21 02:17:10 ... 1098918324 7373 48 48 1 2 55001947 601398 24 50020100 2025-10-21 02:18:22 ... 1098918544 7564 hotkey SELL_0.33 48 49 2 2 55001947 601398 24 50020103 2025-10-21 02:18:23 ... 1098918544 7564 hotkey SELL_0.33 48 49 3 2 55001947 601398 24 50020104 2025-10-21 02:18:24 ... 1098918544 7564 hotkey SELL_0.33 48 49 4 2 55001947 601398 24 50020107 2025-10-21 02:18:25 ... 1098918544 7564 hotkey SELL_0.33 48 49 5 2 55001947 601398 24 50020112 2025-10-21 02:18:26 ... 1098918544 7564 hotkey SELL_0.33 48 49 6 2 55001947 601398 24 50020115 2025-10-21 02:18:27 ... 1098918544 7564 hotkey SELL_0.33 48 49 7 2 55001947 601398 24 50020116 2025-10-21 02:18:28 ... 1098918544 7564 hotkey SELL_0.33 48 49 [8 rows x 15 columns] ``` 底层源代码 ``` def query_stock_trades(self): ''' 当日成交 ''' trades = self.xt_trader.query_stock_trades(self.acc) print("成交数量:", len(trades)) data=pd.DataFrame() if len(trades) != 0: for i in range(len(trades)): df=pd.DataFrame() df['账号类型']=[trades[i].account_type] df['资金账号']=[trades[i].account_id] df['证券代码']=[trades[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['委托类型']=[trades[i].order_type] df['成交编号']=[trades[i].traded_id] df['成交时间']=[trades[i].traded_time] df['成交均价']=[trades[i].traded_price] df['成交数量']=[trades[i].traded_volume] df['成交金额']=[trades[i].traded_amount] df['订单编号']=[trades[i].order_id] df['柜台合同编号']=[trades[i].order_sysid] df['策略名称']=[trades[i].strategy_name] df['委托备注']=[trades[i].order_remark] df['多空方向']=[trades[i].direction] df['交易操作']=[trades[i].offset_flag] data=pd.concat([data,df],ignore_index=True) data['成交时间']=pd.to_datetime(data['成交时间'],unit='s') return data else: print('今日没有成交') return data ``` ### 30当日成交2 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.today_trades() print(df) ``` 结果 ``` 账号类型 资金账号 证券代码 委托类型 成交编号 成交时间 ... 成交数量 成交金额 订单编号 柜台合同编号 策略名称 委托备注 0 2 55001947 513100 23 50019902 2025-10-21 02:17:10 ... 100 188.9 1098918324 7373 1 2 55001947 601398 24 50020100 2025-10-21 02:18:22 ... 11800 89680.0 1098918544 7564 hotkey SELL_0.33 2 2 55001947 601398 24 50020103 2025-10-21 02:18:23 ... 11800 89680.0 1098918544 7564 hotkey SELL_0.33 3 2 55001947 601398 24 50020104 2025-10-21 02:18:24 ... 11800 89680.0 1098918544 7564 hotkey SELL_0.33 4 2 55001947 601398 24 50020107 2025-10-21 02:18:25 ... 11800 89680.0 1098918544 7564 hotkey SELL_0.33 5 2 55001947 601398 24 50020112 2025-10-21 02:18:26 ... 107900 820040.0 1098918544 7564 hotkey SELL_0.33 6 2 55001947 601398 24 50020115 2025-10-21 02:18:27 ... 107900 820040.0 1098918544 7564 hotkey SELL_0.33 7 2 55001947 601398 24 50020116 2025-10-21 02:18:28 ... 33700 256120.0 1098918544 7564 hotkey SELL_0.33 [8 rows x 13 columns] ``` 底层源代码 ``` def today_trades(self): ''' 今日成交 ''' trades = self.xt_trader.query_stock_trades(self.acc) print("成交数量:", len(trades)) data=pd.DataFrame() if len(trades) != 0: for i in range(len(trades)): df=pd.DataFrame() df['账号类型']=[trades[i].account_type] df['资金账号']=[trades[i].account_id] df['证券代码']=[trades[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['委托类型']=[trades[i].order_type] df['成交编号']=[trades[i].traded_id] df['成交时间']=[trades[i].traded_time] df['成交均价']=[trades[i].traded_price] df['成交数量']=[trades[i].traded_volume] df['成交金额']=[trades[i].traded_amount] df['订单编号']=[trades[i].order_id] df['柜台合同编号']=[trades[i].order_sysid] df['策略名称']=[trades[i].strategy_name] df['委托备注']=[trades[i].order_remark] data=pd.concat([data,df],ignore_index=True) def select_data(x): if x==xtconstant.STOCK_BUY: return '证券买入' elif x==xtconstant.STOCK_SELL: return '证券卖出' else: return '无' df['操作']=df['委托类型'].apply(select_data) data['成交时间']=pd.to_datetime(data['成交时间'],unit='s') return data else: print('今日没有成交') return data ``` ### 31查询账户所有的持仓 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.query_stock_positions() print(df) ``` 结果 ``` 0 持仓数量: 47 账号类型 资金账号 证券代码 持仓数量 可用数量 平均建仓成本 市值 0 2 55001947 113045 10 10 133.480000 1342.95 1 2 55001947 113577 10 10 152.445000 1216.06 2 2 55001947 118005 10 10 121.770000 1200.26 3 2 55001947 512480 3500 3500 1.559429 5113.50 4 2 55001947 512530 100 100 1.601000 159.30 5 2 55001947 516160 800 800 2.836250 2170.40 6 2 55001947 562310 11600 11600 1.026431 11530.40 7 2 55001947 600276 5000 5000 63.064168 329500.00 8 2 55001947 600592 4600 4600 23.851933 111458.00 9 2 55001947 600617 100 100 4.030000 469.00 ``` ### 32获取持股2 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.position() print(df) ``` 结果 ``` 持仓数量: 47 账号类型 资金账号 证券代码 证券代码1 股票余额 可用余额 成本价 参考成本价 市值 冻结数量 0 2 55001947 113045 113045.SH 10 10 133.480000 133.480000 1342.48 0 1 2 55001947 113577 113577.SH 10 10 152.445000 152.445000 1215.64 0 2 2 55001947 118005 118005.SH 10 10 121.770000 121.770000 1199.86 0 3 2 55001947 512480 512480.SH 3500 3500 1.559429 1.559429 5117.00 0 4 2 55001947 512530 512530.SH 100 100 1.601000 1.601000 159.30 0 5 2 55001947 516160 516160.SH 800 800 2.836250 2.836250 2172.00 0 6 2 55001947 562310 562310.SH 11600 11600 1.026431 1.026431 11542.00 0 7 2 55001947 600276 600276.SH 5000 5000 63.064168 63.064168 329450.00 0 8 2 55001947 600592 600592.SH 4600 4600 23.851933 23.851933 111366.00 0 9 2 55001947 600617 600617.SH 100 100 4.030000 4.030000 476.00 0 ``` 底层源代码 ``` def position(self): ''' 持股 ''' try: positions = self.xt_trader.query_stock_positions(self.acc) print("持仓数量:", len(positions)) data=pd.DataFrame() if len(positions) != 0: for i in range(len(positions)): df=pd.DataFrame() df['账号类型']=[positions[i].account_type] df['资金账号']=[positions[i].account_id] df['证券代码']=[positions[i].stock_code] df['证券代码1']=[positions[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['股票余额']=[positions[i].volume] df['可用余额']=[positions[i].can_use_volume] df['成本价']=[positions[i].open_price] df['参考成本价']=[positions[i].open_price] df['市值']=[positions[i].market_value] df['冻结数量']=[positions[i].frozen_volume] data=pd.concat([data,df],ignore_index=True) return data else: df=pd.DataFrame() df['账号类型']=None df['资金账号']=None df['证券代码']=None df['股票余额']=None df['可用余额']=None df['成本价']=None df['市值']=None df['选择']=None df['持股天数']=None df['交易状态']=None df['明细']=None df['证券名称']=None df['冻结数量']=None df['市价']=None df['盈亏']=None df['盈亏比(%)']=None df['当日买入']=None df['当日卖出']=None return df except: df=pd.DataFrame() return df ``` ### 33获取股票新可转债ipo数据 调用代码 ``` 0 没有数据/处理出现错误 Empty DataFrame Columns: [品种名称, 品种类型, 最小申购额度, 最大申购额度, 申购日期, 发行价, 证券代码] Index: [] ``` 底层代码 ``` ef query_stock_ipo_data(self): ''' 获取股票新可转债ipo数据 dict 新股新债信息数据集 { stock1: info1, stock2: info2, ... } stock - str 品种代码，例如 '301208.SZ' info - dict 新股信息 name - str 品种名称 type - str 品种类型 STOCK - 股票，BOND - 债券 minPurchaseNum / maxPurchaseNum - int 最小 / 最大申购额度 单位为股（股票）/ 张（债券） purchaseDate - str 申购日期 issuePrice - float 发行价 ''' try: data=self.xt_trader.query_ipo_data() df=pd.DataFrame(data).T df['证券代码']=df.index df.columns=['品种名称','品种类型','最大申购额度','最小申购额度','申购日期','发行价','证券代码'] return df except: print('没有数据/处理出现错误') df=pd.DataFrame() df['品种名称']=None df['品种类型']=None df['最小申购额度']=None df['最大申购额度']=None df['申购日期']=None df['发行价']=None df['证券代码']=None return df ``` ### 34目标数量下单 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.order_target_volume(stock='513100',amount=1000,price=1.844) print(df) ``` 结果 ``` 目标数量下单513100 目标数量1000 持有数量100 可以用数量100 需要买入数量900 ('buy', 900, 1.844) ``` 底层代码 ``` def order_target_volume(self,stock='501018',amount=1000,price=12): ''' 目标数量下单 stock: 标的代码 amount: 期望的最终数量 price:价格 trader_type针对买入账户没有持股的股票，一般不改动 ''' hold_stock=self.position() try: del hold_stock['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] if hold_stock.shape[0]>0: stock=str(stock) df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #持有的价值 hold_value=df1['市值'].tolist()[-1] else: av_num=0 hold_num=0 hold_value=0 else: av_num=0 hold_num=0 hold_value=0 buy_sell_num=amount-float(hold_num) buy_sell_value=buy_sell_num*price #存在买入差额 if buy_sell_num>0: buy_sell_num=self.adjust_amount(stock=stock,amount=buy_sell_num) #可以资金大于买卖的差额 if buy_sell_num>=10: #可以资金大于买卖差额 if cash>=buy_sell_value: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要买入数量{}'.format(stock,amount,hold_num,av_num,buy_sell_num)) return 'buy',buy_sell_num,price else: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要买入数量{} 可用金额{}小于下单金额{} 不交易'.format(stock,amount,hold_num,av_num,buy_sell_num,cash,buy_sell_value)) return '',0,price else: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要买入数量{}小于10不交易'.format(stock,amount,hold_num,av_num,buy_sell_num)) return '',0,price #存在卖出空间： elif buy_sell_num <0: #可以卖出的数量多 buy_sell_num=abs(buy_sell_num) buy_sell_num=self.adjust_amount(stock=stock,amount=buy_sell_num) if av_num>=buy_sell_num: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要卖出数量{}'.format(stock,amount,hold_num,av_num,buy_sell_num)) return 'sell',buy_sell_num,price else: #可以卖出的不足卖出全部可以卖出的 print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 小于需要卖出数量{} 直接卖出'.format(stock,amount,hold_num,av_num,buy_sell_num)) return 'sell',buy_sell_num,price else: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要卖出数量{}等于0不交易'.format(stock,amount,hold_num,av_num,buy_sell_num)) return '',0,price ``` ### 35按金额下单 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.order_value(stock='513100',value=1000,price=1.844,trader_type='buy') print(df) ``` 结果 ``` 持仓数量: 47 按金额下单513100 交易类型buy 可用资金15857465.63大于 下单金额1000 下单数量500 ('buy', 500, 1.844) ``` 底层源代码 ``` def order_value(self,stock='501018',value=1000,price=1.33,trader_type='buy'): ''' 按金额下单 stock: 证券代码 value下单金额 value大于0买入，小0卖出 prive交易的的价格 ''' hold_stock=self.position() account=self.balance() cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] amount=value/price amount=self.adjust_amount(stock=stock,amount=amount) if trader_type=='buy': #这里按道理需要考虑手续费，看隔日资金 if cash>=value: if amount>=10: print('按金额下单{} 交易类型{} 可用资金{}大于 下单金额{} 下单数量{}'.format(stock,trader_type,cash,value,amount)) return 'buy',amount,price else: print('按金额下单{} 交易类型{} 可用资金{}大于 下单金额{} 下单数量{}小于最小下单单位不交易'.format(stock,trader_type,cash,value,amount)) return '',0,price else: print('按金额下单{} 交易类型{} 可用资金{}小于 下单金额{} 下单数量{} 不交易'.format(stock,trader_type,cash,value,amount)) return '',0,price elif trader_type=='sell': df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #可用余额大于下单数量 if av_num>=amount: print('按金额下单{} 交易类型{} 持有数量{} 可用数量{}大于 下单数量{} 下单数量{}'.format(stock,trader_type,hold_num,av_num,amount,amount)) return 'sell',amount,price else: if av_num>=10: print('按金额下单{} 交易类型{} 持有数量{} 可用数量{}小于 下单数量{} 直接卖出全部下单数量{}'.format(stock,trader_type,hold_num,av_num,amount,av_num)) return 'sell',av_num,price else: print('按金额下单{} 交易类型{} 持有数量{} 可用数量{}小于 下单数量{} 下单数量{}小于最小单位不交易'.format(stock,trader_type,hold_num,av_num,amount,av_num)) return '',0,price else: return '',0,price else: print('按金额下单{} 交易类型{}未知道 不交易'.format(stock,trader_type)) return '',0,price ``` ### 36调整数量函数 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.adjust_amount(stock='513100',amount=110) print(df) ``` 结果 ``` 链接qmt 0 100 ``` 底层代码 ``` def adjust_amount(self,stock='',amount=''): ''' 调整数量 ''' if stock[:3] in ['110','113','123','127','128','111'] or stock[:2] in ['11','12']: amount=math.floor(amount/10)*10 else: amount=math.floor(amount/100)*100 return amount ``` ### 37目标价值下单 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.order_target_value(stock='501018',value=1000,price=1.33) print(df) ``` 结果 ``` 链接qmt 0 持仓数量: 47 目标价值下单501018 目标价值1000 可用资金15857465.63大于买卖资金931.0 目标数量700 持有数量0 可用数量0 买入差额700 ('buy', 700, 1.33) ``` 底层源代码 ``` def order_target_value(self,stock='501018',value=1000,price=1.33): ''' 目标价值下单 stock: 股票名字 value: 股票价值，value = 最新价 * 手数 * 保证金率（股票为1） * 乘数（股票为100） prive交易的的价格 ''' hold_stock=self.position() try: del hold_stock['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] amount=math.floor(value/price) if hold_stock.shape[0]>0: stock=str(stock) df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #持有的价值 hold_value=df1['市值'].tolist()[-1] else: av_num=0 hold_num=0 hold_value=0 else: av_num=0 hold_num=0 hold_value=0 #买卖价值差转成数量 #可转债最新10 amount=self.adjust_amount(stock=stock,amount=amount) #买卖的差额 buy_sell_num=math.floor(amount-float(hold_num)) buy_sell_num=self.adjust_amount(stock=stock,amount=buy_sell_num) buy_sell_value=buy_sell_num*price #存在买入差额,买入的大于持有的 if buy_sell_num>0: if buy_sell_num>=10: #可用现金大于买卖的差额 if cash>=buy_sell_value: print('目标价值下单{} 目标价值{} 可用资金{}大于买卖资金{} 目标数量{} 持有数量{} 可用数量{} 买入差额{}'.format(stock,value,cash,buy_sell_value,amount,hold_num,av_num,buy_sell_num)) return 'buy',buy_sell_num,price else: print('目标价值下单{} 目标价值{} 可用资金{}小于买卖资金{} 目标数量{} 持有数量{} 可用数量{} 买入差额{}不下单'.format(stock,value,cash,buy_sell_value,amount,hold_num,av_num,buy_sell_num)) return '',0,price else: print('目标价值下单{} 目标价值{} 可用资金{} 买卖资金{} 目标数量{} 持有数量{} 可用数量{} 买入差额{}不下单小于最小单位去10'.format(stock,value,cash,buy_sell_value,amount,hold_num,av_num,buy_sell_num)) return '',0,price #存在卖出空间,目标数量小于持有数量卖出： elif buy_sell_num <0: #可以卖出的数量多 if av_num>=buy_sell_num: buy_sell_num=abs(buy_sell_num) buy_sell_num=self.adjust_amount(stock=stock,amount=buy_sell_num) print('目标价值下单{} 目标价值{} 目标数量{} 持有数量{} 可用数量{} 卖出差额{}'.format(stock,value,amount,hold_num,av_num,buy_sell_num)) return 'sell',buy_sell_num,price else: #可以卖出的不足卖出全部可以卖出的 print('目标价值下单{} 目标价值{} 目标数量{} 持有数量{} 可用数量{}小于卖出数量 卖出差额{}'.format(stock,value,amount,hold_num,av_num,buy_sell_num)) return 'sell',av_num,price else: print('目标价值下单{} 目标价值{} 目标数量{} 等于持有数量{} 可用数量{} 卖出差额{}不下单'.format(stock,value,amount,hold_num,av_num,buy_sell_num)) return '',0,price ``` ### 38百分比交易 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.order_percent(stock='501018',percent=0.1,price=1.33,trader_type='buy') print(df) ``` 结果 ``` 链接qmt 0 持仓数量: 47 委托数量 8 没有委托2/委托已经成交 百分比交易501018 下单类型buy 百分比0.1 下单数量1706500 可以资金15857465.63大于目标资金2269744.674 买入数量1706500 ('buy', 1706500, 1.33) ``` 底层源代码 ``` def order_percent(self,stock='501018',percent=0.1,price=1.33,trader_type='buy'): ''' 百分比交易 percent下单百分比 ''' hold_stock=self.position() account=self.balance() cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type='金额') #目标金额=目标百分比-委托金额 target_value=total_asset*percent-entrusts_amount #数量 amount=target_value/price amount=self.adjust_amount(stock=stock,amount=amount) if trader_type=='buy': #这里按道理要考虑手续费看个资金 if cash>=target_value: if amount>=10: print('百分比交易{} 下单类型{} 百分比{} 下单数量{} 可以资金{}大于目标资金{} 买入数量{}'.format(stock,trader_type,percent,amount,cash,target_value,amount)) return 'buy',amount,price else: print('百分比交易{} 下单类型{} 百分比{} 下单数量{} 可以资金{}大于目标资金{} 买入数量{}小于10不下单'.format(stock,trader_type,percent,amount,cash,target_value,amount)) return '',0,price else: print('百分比交易{} 下单类型{} 百分比{} 下单数量{} 可以资金{}小于目标资金{} 买入数量{}'.format(stock,trader_type,percent,amount,cash,target_value,amount)) return '',0,price elif trader_type=='sell': if hold_stock.shape[0]>0: stock=str(stock) df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #持有的价值 hold_value=df1['市值'].tolist()[-1] #可用数量大于卖出数量 if av_num>=amount: print('百分比交易{} 下单类型{} 百分比{} 持有数量{} 可以数量{} 大于等于下单数量{} 下单{}'.format(stock,trader_type,percent,hold_num,cash,amount,amount)) return 'sell',amount,price else: print('百分比交易{} 下单类型{} 百分比{} 持有数量{} 可以数量{} 小于下单数量{} 下单{}'.format(stock,trader_type,percent,hold_num,cash,amount,av_num)) return 'sell',av_num,price else: print('{}账户没有持股不支持交易类型{}'.format(stock,trader_type)) return '',0,price else: print('账户没有持股不支持交易类型{}'.format(trader_type)) return '',0,price else: print('未知的交易类型{}'.format(trader_type)) return '',0,price ``` ### 39目标百分比下单 调用代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.order_target_percent(stock='501018',target_percent=0.1,price=1.33) print(df) ``` 结果 ``` 链接qmt 0 持仓数量: 47 目标百分比下单501018 目标百分比0.1 目标数量1707997.7834586464 可以资金15857465.63大于目标资金2271637.0519999997 持有数量0 可用数量0 买入差额1707900 ('buy', 1707900, 1.33) ``` 底层源代码 ``` def order_target_percent(self,stock='501018',target_percent=0.1,price=1.33): ''' 目标百分比下单 ''' hold_stock=self.position() account=self.balance() cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] #entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type='金额') #目标金额 target_value=total_asset*target_percent #目标数量 target_amount=target_value/price amount=self.adjust_amount(stock=stock,amount=target_amount) if hold_stock.shape[0]>0: stock=str(stock) df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #持有的价值 hold_value=df1['市值'].tolist()[-1] else: av_num=0 hold_num=0 hold_value=0 else: av_num=0 hold_num=0 hold_value=0 #没有买入数量,目标数量-持有数量 buy_sell_amount=amount-hold_num #大于0 存在买入的差额 if buy_sell_amount>=10: #可以现金大于目标金额 这里要考虑手续看个人资金 if cash>=target_value: print('目标百分比下单{} 目标百分比{} 目标数量{} 可以资金{}大于目标资金{} 持有数量{} 可用数量{} 买入差额{}'.format(stock,target_percent,target_amount,cash,target_value,hold_num,av_num,buy_sell_amount)) return 'buy',buy_sell_amount,price else: print('目标百分比下单{} 目标百分比{} 目标数量{} 可以资金{}小于目标资金{} 持有数量{} 可用数量{} 买入差额{}不下单'.format(stock,target_percent,target_amount,cash,target_value,hold_num,av_num,buy_sell_amount)) return '',0,price elif buy_sell_amount<=10 and buy_sell_amount>=0: print('目标百分比下单{} 目标百分比{} 目标数量{} 可以资金{}目标资金{} 持有数量{} 可用数量{} 买入差额{}小于10不下单'.format(stock,target_percent,target_amount,cash,target_value,hold_num,av_num,buy_sell_amount)) return '',0,price else: #可用买入的差额小于0 卖出 buy_sell_amount=abs(buy_sell_amount) #可用数量大于差额 if av_num>=buy_sell_amount: print('目标百分比下单{} 目标百分比{} 目标数量{} 持有数量{} 可用数量{} 大于差额{} 卖出差额{}'.format(stock,target_percent,target_amount,hold_num,av_num,buy_sell_amount,buy_sell_amount)) return 'sell',buy_sell_amount,price else: print('目标百分比下单{} 目标百分比{} 目标数量{} 持有数量{} 可用数量{} 小于差额{} 卖出全部{}'.format(stock,target_percent,target_amount,hold_num,av_num,buy_sell_amount,av_num)) return 'sell',av_num,price ``` ### 40目标百分比下单数量模式 源代码 ``` def order_target_percent_volume(self,stock='501018',target_percent=0.1,price=1.33): ''' 目标百分比下单数量模式 ''' hold_stock=self.position() try: del hold_stock['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] #entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type='金额') #目标金额 target_value=total_asset*target_percent #目标数量 target_amount=target_value/price trader_type,trader_amount,price=self.order_target_volume(stock=stock,amount=target_amount,price=price) return trader_type,trader_amount,price ``` ### 41目标百分比下单金额模式 源代码 ``` def order_target_percent_value(self,stock='501018',target_percent=0.1,price=1.33): ''' 目标百分比下单金额模式 ''' hold_stock=self.position() try: del hold_stock['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] #entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type='金额') #目标金额 target_value=total_asset*target_percent #目标数量 target_amount=target_value/price trader_type,trader_amount,price=self.order_target_value(stock=stock,value=target_value,price=price) return trader_type,trader_amount,price ``` ### 42一键清仓 调用源代码 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.one_click_clearance() print(df) ``` 结果 ``` 交易类型24 代码127079.SZ 价格166.278 数量10 订单编号1098925442 一键清仓128101 持有数量10 可用数量10 卖出数量10 None 交易类型24 代码128101.SZ 价格124.199 数量10 订单编号1098925443 '128117.SZ' 一键清仓159351 持有数量200 可用数量200 卖出数量200 None on order callback: 127079.SZ 50 10829 on order callback: 128101.SZ 50 10830 交易类型24 代码159351.SZ 价格1.177 数量200 订单编号1098925444 一键清仓159680 持有数量200 可用数量200 卖出数量200 None on order callback: 159351.SZ 50 10831 交易类型24 代码159680.SZ 价格1.4880000000000002 数量200 订单编号1098925446 一键清仓159915 持有数量100 可用数量100 卖出数量100 None on order callback: 159680.SZ 50 10832 on trade callback 55001947 159351.SZ 1098925444 on order callback: 159351.SZ 56 10831 on trade callback 交易类型24 代码159915.SZ 价格3.051 数量100 订单编号1098925447 55001947 118005.SH 1098925401 一键清仓300120 持有数量2400 可用数量2400 卖出数量2400 on order callback: 118005.SH 56 10797 None on order callback: 159915.SZ 50 10833 交易类型24 代码300120.SZ 价格11.700000000000001 数量2400 订单编号1098925448 一键清仓300339 持有数量400 可用数量400 卖出数量400 None on order callback: 300120.SZ 50 10834 on trade callback 55001947 300120.SZ 1098925448 on order callback: 300120.SZ 56 10834 交易类型24 代码300339.SZ 价格58.75 数量400 订单编号1098925450 一键清仓300458 持有数量400 可用数量400 卖出数量400 None on order callback: 300339.SZ 50 10835 on trade callback 55001947 603020.SH 1098925414 on order callback: 603020.SH 55 10807 交易类型24 代码300458.SZ 价格47.53 数量400 订单编号1098925451 一键清仓301152 持有数量3000 可用数量3000 卖出数量3000 None on order callback: 300458.SZ 50 10836 on order callback: 301152.SZ 50 10837 交易类型24 代码301152.SZ 价格31.259999999999998 数量3000 订单编号1098925452 一键清仓513100 持有数量100 可用数量100 卖出数量100 None 交易类型24 代码513100.SH 价格1.883 数量100 订单编号1098925453 on order callback: None 513100.SH 50 10838 ``` 底源代码 ``` def one_click_clearance(self): ''' 一键清仓 ''' hold_stock=self.position() if hold_stock.shape[0]>0: for stock,hold_num,av_num in zip(hold_stock["证券代码"].tolist(), hold_stock['可用余额'].tolist(),hold_stock['股票余额'].tolist()): try: stock_1=self.adjust_stock(stock=stock) price=self.get_full_tick(code_list=[stock_1])[stock_1]['lastPrice'] if av_num>=10: print('一键清仓{} 持有数量{} 可用数量{} 卖出数量{}'.format(stock,hold_num,av_num,av_num)) self.sell(security=stock,amount=av_num,price=price) else: print('一键清仓{} 持有数量{} 可用数量{}小于0 卖出数量{} 不交易'.format(stock,hold_num,av_num,av_num)) except Exception as e: print(e) else: print("一键清仓 账户没有持股，清仓不了") ``` ### 43一键撤单全部 调用接口 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.one_click_cancel_order_all() print(df) ``` 结果 ``` 链接qmt 0 委托数量 51 一键撤单603196 未成交数量200 订单编号1098925416 委托类型24 撤单成功 一键撤单002241 未成交数量1100 订单编号1098925433 委托类型24 撤单成功 一键撤单123221 未成交数量10 订单编号1098925439 委托类型24 撤单成功 一键撤单127078 未成交数量10 订单编号1098925441 委托类型24 撤单成功 一键撤单127079 未成交数量10 订单编号1098925442 委托类型24 撤单成功 一键撤单128101 未成交数量10 订单编号1098925443 委托类型24 撤单成功 一键撤单159915 未成交数量100 订单编号1098925447 委托类型24 撤单成功 一键撤单300339 未成交数量400 订单编号1098925450 委托类型24 撤单成功 一键撤单300458 未成交数量400 订单编号1098925451 委托类型24 撤单成功 None ``` 底层代码 ``` def one_click_cancel_order_all(self): """ 一键撤单全部 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") ``` ### 44一键撤单全部买入委托 源代码 ``` def one_click_cancel_order_buy(self): """ 一键撤单全部买入委托 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): if data_type==23 or data_type=='买入': #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{}不是买入 撤单失败'.format(stock,amount,order_id,data_type)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") ``` ### 45一键撤单全部卖出委托 源代码 ``` def one_click_cancel_order_sell(self): """ 一键撤单全部卖出委托 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): if data_type==24 or data_type=='卖出': #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{}不是卖出 撤单失败'.format(stock,amount,order_id,data_type)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") ``` ### 46一键撤单个股全部买入委托 ``` def one_click_cancel_order_buy_by_stock(self,stock='600031'): """ 一键撤单个股全部买入委托 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: df=df[df['证券代码']==stock] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): if data_type==23 or data_type=='买入': #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{}不是买入 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 没有可以撤单的内容'.format(stock)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") ``` ### 47一键撤单个股全部卖出委托 ``` def one_click_cancel_order_sell_by_stock(self,stock='600031'): """ 一键撤单个股全部卖出委托 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: df=df[df['证券代码']==stock] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): if data_type==24 or data_type=='卖出': #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{}不是卖出 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 没有可以撤单的内容'.format(stock)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") ``` ### 48国债逆回购1 逆回购 ``` from qmt_trader.qmt_trader import qmt_trader from xtquant import xtconstant trader=qmt_trader( path= r'D:\国金QMT交易端模拟/userdata_mini', account='55001947', account_type='STOCK') trader.connect() df=trader.reverse_repurchase_of_treasury_bonds_1() print(df) ``` 结果 ``` {'204001.SH': {'time': 1761016086000, 'timetag': '20251021 11:08:06', 'lastPrice': 1.33, 'open': 1.41, 'high': 1.43, 'low': 1.255, 'lastClose': 1.16, 'amount': 465696481000, 'volume': 465696481, 'pvolume': 4656964810, 'stockStatus': 3, 'openInt': 13, 'settlementPrice': 0, 'lastSettlementPrice': 1.16, 'askPrice': [1.335, 1.34, 1.345, 1.35, 1.355], 'bidPrice': [1.33, 1.325, 1.32, 1.315, 1.31], 'askVol': [112107, 3285776, 4792684, 7053556, 1810415], 'bidVol': [38912, 969833, 709373, 1054072, 1194964]}} {'131810.SZ': {'time': 1761016083000, 'timetag': '20251021 11:08:03', 'lastPrice': 1.31, 'open': 1.425, 'high': 1.425, 'low': 1.255, 'lastClose': 1.145, 'amount': 35555502000, 'volume': 35555502, 'pvolume': 355555020, 'stockStatus': 3, 'openInt': 13, 'settlementPrice': 0, 'lastSettlementPrice': 1.145, 'askPrice': [1.315, 1.32, 1.325, 1.33, 1.335], 'bidPrice': [1.31, 1.305, 1.3, 1.29, 1.285], 'askVol': [12206, 247396, 63860, 118764, 56044], 'bidVol': [77191, 1153840, 354602, 120000, 18248]}} 204001.SH 1.33 None 交易类型24 代码204001.SH 价格1.33 数量112400 订单编号1098925817 ('交易成功', '国债逆回购交易类型 代码204001.SH 价格1.33 数量112400 订单编号1098925817') ``` 结果 ![输入图片说明](12image.png) ### 49信用账户 ``` def query_credit_detail(self): ''' 账户数据 释义 查询信用资金账号对应的资产 参数 account - StockAccount 资金账号 返回 该信用账户对应的资产对象XtCreditDetail组成的list或者None 备注 None表示查询失败 通常情况下一个资金账号只有一个详细信息数据 示例 查询信用资金账号1208970161对应的资产信息 ''' account = StockAccount(self.account, self.account_type) positions=self.xt_trader.query_credit_detail(account) data=pd.DataFrame() if len(positions) != 0: for i in range(len(positions)): df=pd.DataFrame() df['账号类型']=[positions[i].account_type] df['资金账号']=[positions[i].account_id] df['账号状态']=[positions[i].m_nStatus] df['更新时间']=[positions[i].m_nUpdateTime] df['计算参数']=[positions[i].m_nCalcConfig] df['冻结金额']=[positions[i].m_dFrozenCash] df['总资产']=[positions[i].m_dBalance] df['可用金额']=[positions[i].m_dAvailable] df['持仓盈亏']=[positions[i].m_dPositionProfit] df['总市值']=[positions[i].m_dMarketValue] df['可取金额']=[positions[i].m_dFetchBalance] df['股票市值']=[positions[i].m_dStockValue] df['基金市值']=[positions[i].m_dFundValue] df['总负债']=[positions[i].m_dTotalDebt] df['可用保证金']=[positions[i].m_dEnableBailBalance] df['维持担保比例']=[positions[i].m_dPerAssurescaleValue] df['净资产']=[positions[i].m_dAssureAsset] df['融资负债']=[positions[i].m_dFinDebt] df['融资本金']=[positions[i].m_dFinDealAvl] df['融资息费']=[positions[i].m_dFinFee] df['融券负债']=[positions[i].m_dSloDebt] df['融券市值']=[positions[i].m_dSloMarketValue] df['融券息费']=[positions[i].m_dSloFee] df['其它费用']=[positions[i].m_dOtherFare] df['融资授信额度']=[positions[i].m_dFinMaxQuota] df['融资可用额度']=[positions[i].m_dFinEnableQuota] df['融资冻结额度']=[positions[i].m_dFinUsedQuota] df['融券授信额度']=[positions[i].m_dSloMaxQuota] df['融券可用额度']=[positions[i].m_dSloEnableQuota] df['融券冻结额度']=[positions[i].m_dSloUsedQuota] df['融券卖出资金']=[positions[i].m_dSloSellBalance] df['已用融券卖出资金']=[positions[i].m_dUsedSloSellBalance] df['剩余融券卖出资金']=[positions[i].m_dSurplusSloSellBalance] data=pd.concat([data,df],ignore_index=True) return data else: print('没有数据') df=pd.DataFrame() return df def query_stk_compacts(self): ''' 释义 查询资金账号对应的负债合约 参数 account - StockAccount 资金账号 返回 该账户对应的负债合约对象StkCompacts组成的list或者None 备注 None表示查询失败或者负债合约列表为空 示例 查询信用资金账号1208970161对应的负债合约 ''' account = StockAccount(self.account, self.account_type) compacts=self.xt_trader.query_stk_compacts(account) print(len(compacts)) data=pd.DataFrame() if len(compacts) != 0: for i in range(len(compacts)): df=pd.DataFrame() df['账号类型']=[compacts[i].account_type] df['资金账号']=[compacts[i].account_id] df['合约类型']=[compacts[i].compact_type] df['头寸来源']=[compacts[i].cashgroup_prop] df['证券市场']=[compacts[i].exchange_id] df['开仓日期']=[compacts[i].open_date] df['合约证券数量']=[compacts[i].business_vol] df['未还合约数量']=[compacts[i].real_compact_vol] df['到期日']=[compacts[i].ret_end_date] df['合约金额']=[compacts[i].business_balance] df['合约息费']=[compacts[i].businessFare] df['未还合约金额']=[compacts[i].real_compact_balance] df['未还合约息费']=[compacts[i].real_compact_fare] df['已还息费']=[compacts[i].repaid_fare] df['已还金额']=[compacts[i].repaid_balance] df['证券代码']=[compacts[i].instrument_id] df['合约编号']=[compacts[i].compact_id] df['定位串']=[compacts[i].position_str] data=pd.concat([data,df],ignore_index=True) return data else: print('没有负债合约') df=pd.DataFrame() return df def query_credit_subjects(self): ''' 释义 查询资金账号对应的融资融券标的 参数 account - StockAccount 资金账号 返回 该账户对应的融资融券标的对象CreditSubjects组成的list或者None 备注 None表示查询失败或者融资融券标的列表为空 示例 查询信用资金账号1208970161对应的融资融券标的 ''' account = StockAccount(self.account, self.account_type) compacts=self.xt_trader.query_credit_subjects(account) print(len(compacts)) data=pd.DataFrame() if len(compacts) != 0: for i in range(len(compacts)): df=pd.DataFrame() df['账号类型']=[compacts[i].account_type] df['资金账号']=[compacts[i].account_id] df['融券状态']=[compacts[i].slo_status] df['证券市场']=[compacts[i].exchange_id] df['融券保证金比例']=[compacts[i].slo_ratio] df['融资保证金比例']=[compacts[i].fin_ratio] df['证券代码']=[compacts[i].instrument_id] data=pd.concat([data,df],ignore_index=True) return data else: print('没有融资融券标的') df=pd.DataFrame() return df def query_credit_slo_code(self): ''' 释义 查询资金账号对应的可融券数据 参数 account - StockAccount 资金账号 返回 该账户对应的可融券数据对象CreditSloCode组成的list或者None 备注 None表示查询失败或者可融券数据列表为空 示例 查询信用资金账号1208970161对应的可融券数据 ''' account = StockAccount(self.account, self.account_type) compacts=self.xt_trader.query_credit_slo_code(account) print(len(compacts)) data=pd.DataFrame() if len(compacts) != 0: for i in range(len(compacts)): df=pd.DataFrame() df['账号类型']=[compacts[i].account_type] df['资金账号']=[compacts[i].account_id] df['头寸来源']=[compacts[i].cashgroup_prop] df['证券市场']=[compacts[i].exchange_id] df['融券可融数量']=[compacts[i].enable_amount] df['证券代码']=[compacts[i].instrument_id] data=pd.concat([data,df],ignore_index=True) return data else: print('没有可融券数据') df=pd.DataFrame() return df def query_credit_assure(self): ''' 释义 查询资金账号对应的标的担保品 参数 account - StockAccount 资金账号 返回 该账户对应的标的担保品对象CreditAssure组成的list或者None 备注 None表示查询失败或者标的担保品列表为空 示例 查询信用资金账号1208970161对应的标的担保品 ''' account = StockAccount(self.account, self.account_type) compacts=self.xt_trader.query_credit_assure(account) print(len(compacts)) data=pd.DataFrame() if len(compacts) != 0: for i in range(len(compacts)): df=pd.DataFrame() df['账号类型']=[compacts[i].account_type] df['资金账号']=[compacts[i].account_id] df['是否可做担保']=[compacts[i].assure_status] df['证券市场']=[compacts[i].exchange_id] df['担保品折算比例']=[compacts[i].assure_ratio] df['证券代码']=[compacts[i].instrument_id] data=pd.concat([data,df],ignore_index=True) return data else: print('没有对应的标的担保品') df=pd.DataFrame() return df def check_stock_weight(self,stock='600031',user_ratio=0.1): ''' 检查个股的权重 ''' account=self.balance() position=self.position() total_cash=account['总资产'].tolist() total_cash=total_cash*user_ratio if position.shape[0]>0: df=position[position['证券代码']==stock] if df.shape[0]>0: market_value=df['市值'].tolist()[-1] return market_value/total_cash else: return 0 else: return 0 ``` ### 50全部源代码 ``` from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback from xtquant.xttype import StockAccount from xtquant import xtconstant import time import pandas as pd import random import math import json from xtquant import xtdata import math def conv_time(ct): ''' conv_time(1476374400000) --> '20161014000000.000' ''' local_time = time.localtime(ct / 1000) data_head = time.strftime('%Y%m%d%H%M%S', local_time) data_secs = (ct - int(ct)) * 1000 time_stamp = '%s.%03d' % (data_head, data_secs) return time_stamp class MyXtQuantTraderCallback(XtQuantTraderCallback): def on_disconnected(self): """ 连接断开 :return: """ print("connection lost") def on_stock_order(self, order): """ 委托回报推送 :param order: XtOrder对象 :return: """ print("on order callback:") print(order.stock_code, order.order_status, order.order_sysid) def on_stock_asset(self, asset): """ 资金变动推送 :param asset: XtAsset对象 :return: """ print("on asset callback") print(asset.account_id, asset.cash, asset.total_asset) def on_stock_trade(self, trade): """ 成交变动推送 :param trade: XtTrade对象 :return: """ print("on trade callback") print(trade.account_id, trade.stock_code, trade.order_id) def on_stock_position(self, position): """ 持仓变动推送 :param position: XtPosition对象 :return: """ print("on position callback") print(position.stock_code, position.volume) def on_order_error(self, order_error): """ 委托失败推送 :param order_error:XtOrderError 对象 :return: """ print("on order_error callback") print(order_error.order_id, order_error.error_id, order_error.error_msg) def on_cancel_error(self, cancel_error): """ 撤单失败推送 :param cancel_error: XtCancelError 对象 :return: """ print("on cancel_error callback") print(cancel_error.order_id, cancel_error.error_id, cancel_error.error_msg) def on_order_stock_async_response(self, response): """ 异步下单回报推送 :param response: XtOrderResponse 对象 :return: """ print("on_order_stock_async_response") print(response.account_id, response.order_id, response.seq) class qmt_trader: def __init__(self,path= r'D:/国金QMT交易端模拟/userdata_mini', session_id = 123456,account='55009640',account_type='STOCK', is_slippage=True,slippage=0.01) -> None: self.xt_trader='' self.acc='' self.path=path self.session_id=int(self.random_session_id()) self.account=account self.account_type=account_type if is_slippage==True: self.slippage=slippage else: self.slippage=0 print('操作方式,登录qmt,选择行情加交易选,择极简模式') print('作者:索普量化') print('作者微信:xms_quants1,开实盘qmt可以联系我,开户也可以') print("作者知识星球:金融量化交易研究院 https://t.zsxq.com/19VzjjXNi") print("开源网页教程https://gitee.com/quants/qmt_trader") def random_session_id(self): ''' 随机id ''' session_id='' for i in range(0,9): session_id+=str(random.randint(1,9)) return session_id def select_slippage(self,stock='600031',price=15.01,trader_type='buy'): ''' 选择滑点 安价格来滑点，比如0.01就是一块 etf3位数,股票可转债2位数 ''' stock=self.adjust_stock(stock=stock) data_type=self.select_data_type(stock=stock) if data_type=='fund' or data_type=='bond': slippage=self.slippage/10 if trader_type=='buy' or trader_type==23: price=price+slippage else: price=price-slippage else: slippage=self.slippage if trader_type=='buy' or trader_type==23: price=price+slippage else: price=price-slippage return price def check_is_trader_date(self): ''' 检测是不是交易时间 ''' loc=time.localtime() tm_hour=loc.tm_hour tm_min=loc.tm_min #利用通用时间，不考虑中午不交易 is_trader='' wo=loc.tm_wday with open('分析配置.json','r+',encoding='utf-8') as f: com=f.read() text=json.loads(com) trader_time=text['交易时间段'] start_date=text['交易开始时间'] end_date=text['交易结束时间'] if wo<=trader_time: if (tm_hour>=start_date) and (tm_hour<=end_date): is_trader=True return True else: is_trader=False return False else: print('周末') return False def check_is_trader_date_1(self,trader_time=4,start_date=9,end_date=14,start_mi=0,jhjj='否'): ''' 检测是不是交易时间 ''' if jhjj=='是': jhjj_time=15 else: jhjj_time=30 loc=time.localtime() tm_hour=loc.tm_hour tm_min=loc.tm_min wo=loc.tm_wday if wo<=trader_time: if tm_hour>=start_date and tm_hour<=end_date: if tm_hour==9 and tm_min=start_mi: return True else: return False else: return False else: print('周末') return False def select_data_type(self,stock='600031'): ''' 选择数据类型 ''' stock=str(stock) if stock[:2] in ['11','12'] or stock[:3] in ['123','110','113','123','127','128','118','132','120']: return 'bond' elif stock[:2] in ['51','15','50','16','18','52']: return 'fund' else: return 'stock' def adjust_stock(self,stock='600031.SH'): ''' 调整代码 ''' if stock[-2:]=='SH' or stock[-2:]=='SZ' or stock[-2:]=='sh' or stock[-2:]=='sz': stock=stock.upper() else: if stock[:3] in ['600','601','603','605','688','689', ] or stock[:2] in ['11','51','58']: stock=stock+'.SH' else: stock=stock+'.SZ' return stock def adjust_hold_data(self,stock='603918',trader_type='sell',price=12,amount=100): ''' 模拟持股数据 ''' #stock=self.adjust_stock(stock=stock) price=float(price) amount=float(amount) try: df=pd.read_excel(r'持股数据\持股数据.xlsx',dtype='object') del df['Unnamed: 0'] except: try: df=pd.read_excel(r'持股数据.xlsx',dtype='object') except: df=self.position() df.index=df['证券代码'] df1=df[df['证券代码']==stock] if df1.shape[0]>0: #可用余额 available_balance=df1['可用余额'].tolist()[-1] #股票余额 stock_balance=df1['股票余额'].tolist()[-1] if trader_type=='buy': stock_balance+=float(amount) available_balance+=float(amount) elif trader_type=='sell': available_balance-=float(amount) stock_balance-=float(amount) if available_balance<=0: available_balance=0 if stock_balance<=0: stock_balance=0 else: pass df1['可用余额']=[available_balance] df1['股票余额']=[stock_balance] data=df.drop(stock,axis=0) data=pd.concat([data,df1],ignore_index=True) try: data.to_excel(r'持股数据\持股数据.xlsx') print('持股数据调整成功') return data except: data.to_excel(r'持股数据.xlsx') return data else: df2=pd.DataFrame() df2['明细']=['0'] df2['证券代码']=[stock] df2['证券名称']=['0'] df2['股票余额']=[amount] df2['可用余额']=[amount] df2['冻结数量']=[0] df2['成本价']=[price] df2['市价']=[price] df2['盈亏']=[0] df2['盈亏比(%)']=[0] df2['市值']=[amount*price] df2['当日买入']=[0] df2['当日卖出']=[0] df2['交易市场']=[0] df2['持股天数']=[0] data=pd.concat([df,df2],ignore_index=True) try: data.to_excel(r'持股数据\持股数据.xlsx') print('持股数据调整成功') print('{}没有持股'.format(stock)) return data except: data.to_excel(r'持股数据.xlsx') return data def adjust_account_cash(self,stock='128036',trader_type='buy',price=123,amount=10): ''' 调整账户资金 ''' #stock=self.adjust_stock(stock=stock) price=float(price) amount=float(amount) try: df=pd.read_excel(r'账户数据\账户数据.xlsx',dtype='object') del df['Unnamed: 0'] except: try: df=pd.read_excel(r'账户数据.xlsx',dtype='object') except: df=self.balance() value=price*amount #可用余额 av_user_cash=float(df['可用金额'].tolist()[-1]) if trader_type=='buy' and av_user_cash >=value+5: av_user_cash-=value elif trader_type=='buy' and av_user_cash =value: print('允许买入{} 可用现金{}大于买入金额{} 价格{} 数量{}'.format(stock,cash,value,price,amount)) return True else: print('不允许买入{} 可用现金{}小于买入金额{} 价格{} 数量{}'.format(stock,cash,value,price,amount)) return False def check_stock_is_av_sell(self,stock='128036',amount=10): ''' 检查是否可以卖出 ''' #stock=self.adjust_stock(stock=stock) hold_data=self.position() try: del hold_data['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass #买入是价值 cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] stock_list=hold_data['证券代码'].tolist() if stock in stock_list: hold_num=hold_data[hold_data['证券代码']==stock]['可用余额'].tolist()[-1] if hold_num>=amount: print('允许卖出：{} 持股{} 卖出{}'.format(stock,hold_num,amount)) return True else: print('不允许卖出持股不足：{} 持股{} 卖出{}'.format(stock,hold_num,amount)) return False else: print('不允许卖出没有持股：{} 持股{} 卖出{}'.format(stock,0,amount)) return False def connect(self): ''' 连接 path qmt userdata_min是路径 session_id 账户的标志,随便 account账户, account_type账户内类型 ''' print('链接qmt') # path为mini qmt客户端安装目录下userdata_mini路径 path = self.path # session_id为会话编号，策略使用方对于不同的Python策略需要使用不同的会话编号 session_id = self.session_id xt_trader = XtQuantTrader(path, session_id) # 创建资金账号为1000000365的证券账号对象 account=self.account account_type=self.account_type acc = StockAccount(account_id=account,account_type=account_type) # 创建交易回调类对象，并声明接收回调 callback = MyXtQuantTraderCallback() xt_trader.register_callback(callback) # 启动交易线程 xt_trader.start() # 建立交易连接，返回0表示连接成功 connect_result = xt_trader.connect() if connect_result==0: # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = xt_trader.subscribe(acc) print(subscribe_result) self.xt_trader=xt_trader self.acc=acc return xt_trader,acc else: print('qmt连接失败') def order_stock(self,stock_code='600031.SH', order_type=xtconstant.STOCK_BUY, order_volume=100,price_type=xtconstant.FIX_PRICE,price=20,strategy_name='',order_remark=''): ''' 下单，统一接口 :param account: 证券账号 :param stock_code: 证券代码, 例如"600000.SH" :param order_type: 委托类型, 23:买, 24:卖 :param order_volume: 委托数量, 股票以'股'为单位, 债券以'张'为单位 :param price_type: 报价类型, 详见帮助手册 :param price: 报价价格, 如果price_type为指定价, 那price为指定的价格, 否则填0 :param strategy_name: 策略名称 :param order_remark: 委托备注 :return: 返回下单请求序号, 成功委托后的下单请求序号为大于0的正整数, 如果为-1表示委托失败 ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = self.xt_trader.subscribe(self.acc) print(self.xt_trader.query_stock_asset_async(account=self.acc,callback=subscribe_result)) #print(subscribe_result) stock_code = self.adjust_stock(stock=stock_code) price=self.select_slippage(stock=stock_code,price=price,trader_type=order_type) # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态 fix_result_order_id = self.xt_trader.order_stock(account=self.acc,stock_code=stock_code, order_type=order_type, order_volume=order_volume, price_type=price_type, price=price, strategy_name=strategy_name, order_remark=order_remark) print('交易类型{} 代码{} 价格{} 数量{} 订单编号{}'.format(order_type,stock_code,price,order_volume,fix_result_order_id)) return fix_result_order_id def buy(self,security='600031.SH', order_type=xtconstant.STOCK_BUY, amount=100,price_type=xtconstant.FIX_PRICE,price=20,strategy_name='',order_remark=''): ''' 单独独立股票买入函数 ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = self.xt_trader.subscribe(self.acc) print(self.xt_trader.query_stock_asset_async(account=self.acc,callback=subscribe_result)) #print(subscribe_result) stock_code =self.adjust_stock(stock=security) price=self.select_slippage(stock=security,price=price,trader_type='buy') order_volume=amount # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态 if order_volume>0: fix_result_order_id = self.xt_trader.order_stock_async(account=self.acc,stock_code=stock_code, order_type=order_type, order_volume=order_volume, price_type=price_type, price=price, strategy_name=strategy_name, order_remark=order_remark) print('交易类型{} 代码{} 价格{} 数量{} 订单编号{}'.format(order_type,stock_code,price,order_volume,fix_result_order_id)) return fix_result_order_id else: print('买入 标的{} 价格{} 委托数量{}小于0有问题'.format(stock_code,price,order_volume)) def sell(self,security='600031.SH', order_type=xtconstant.STOCK_SELL, amount=100,price_type=xtconstant.FIX_PRICE,price=20,strategy_name='',order_remark=''): ''' 单独独立股票卖出函数 ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = self.xt_trader.subscribe(self.acc) print(self.xt_trader.query_stock_asset_async(account=self.acc,callback=subscribe_result)) #print(subscribe_result) stock_code =self.adjust_stock(stock=security) price=self.select_slippage(stock=security,price=price,trader_type='sell') order_volume=amount # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态 if order_volume>0: fix_result_order_id = self.xt_trader.order_stock(account=self.acc,stock_code=stock_code, order_type=order_type, order_volume=order_volume, price_type=price_type, price=price, strategy_name=strategy_name, order_remark=order_remark) print('交易类型{} 代码{} 价格{} 数量{} 订单编号{}'.format(order_type,stock_code,price,order_volume,fix_result_order_id)) return fix_result_order_id else: print('卖出 标的{} 价格{} 委托数量{}小于0有问题'.format(stock_code,price,order_volume)) def get_full_tick(self,code_list=['600031.SH','600111.SH']): ''' 例子 models=qmt_data() stock_list=['600031.SH','600111.SH'] df=models.get_full_tick() print(df) 释义 获取全推数据 参数 code_list - 代码列表，支持传入市场代码或合约代码两种方式 传入市场代码代表订阅全市场，示例：['SH', 'SZ'] 传入合约代码代表订阅指定的合约，示例：['600000.SH', '000001.SZ'] 返回 dict 数据集 { stock1 : data1, stock2 : data2, ... } 备注 无 获取除权数据 ''' df=xtdata.get_full_tick(code_list=code_list) return df def reverse_repurchase_of_treasury_bonds(self,security='131810.SZ',buy_ratio=0.005, order_type=xtconstant.STOCK_SELL ,price_type=xtconstant.FIX_PRICE,strategy_name='',order_remark=''): ''' 国债逆回购 ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 account=self.balance() av_cash=account['可用金额'].tolist()[-1] av_cash=float(av_cash) av_cash=av_cash*buy_ratio spot_data=self.get_full_tick(code_list=[security]) print('{}实时数据'.format(security),spot_data) price=spot_data[security]['bidPrice'][0] price=float(price) amount=math.floor((av_cash)/1000)*1000 subscribe_result = self.xt_trader.subscribe(self.acc) print(self.xt_trader.query_stock_asset_async(account=self.acc,callback=subscribe_result)) #print(subscribe_result) stock_code =self.adjust_stock(stock=security) #price=self.select_slippage(stock=security,price=price,trader_type='sell') order_volume=amount # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态 if order_volume>0: fix_result_order_id = self.xt_trader.order_stock(account=self.acc,stock_code=stock_code, order_type=order_type, order_volume=order_volume, price_type=price_type, price=price, strategy_name=strategy_name, order_remark=order_remark) text='国债逆回购交易类型{} 代码{} 价格{} 数量{} 订单编号{}'.format(order_type,stock_code,price,order_volume,fix_result_order_id) return '交易成功',text else: text='国债逆回购卖出 标的{} 价格{} 委托数量{}小于0有问题'.format(stock_code,price,order_volume) return '交易失败',text def get_bidPrice1(self,stock_code): price = self.get_full_tick([stock_code]) print(price) bidPrice = price[stock_code]['bidPrice'] bidPrice1=bidPrice[0] return(bidPrice1) def reverse_repurchase_of_treasury_bonds_1(self,buy_ratio=0.5): ''' 国债逆回购1,新的函数 购买比例buy_ratio ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 account=self.balance() av_cash=account['可用金额'].tolist()[-1] av_cash=float(av_cash) av_cash=av_cash*buy_ratio stock_code_sh = '204001.SH' stock_code_sz = '131810.SZ' price_sh = self.get_bidPrice1(stock_code_sh) price_sz = self.get_bidPrice1(stock_code_sz) bidPrice1 = max(price_sh,price_sz) if price_sh > price_sz: stock_code = stock_code_sh else: stock_code = stock_code_sz print(stock_code,bidPrice1) price=bidPrice1 stock=stock_code #下单的数量要是1000 amount = int(av_cash/1000) #想下取整1000的倍数 amount=math.floor(amount/10)*100 #借出钱sell if amount>0: self.slippage=0 fix_result_order_id =self.sell(security=stock,amount=amount,price=price) text='国债逆回购交易类型 代码{} 价格{} 数量{} 订单编号{}'.format(stock,price,amount,fix_result_order_id) return '交易成功',text else: text='国债逆回购卖出 标的{} 价格{} 委托数量{}小于0有问题'.format(stock,price,amount) return '交易失败',text def get_invest_in_ETF(self,stock='511010',buy_ratio=0.5): ''' 定投etd,国债ETF 可用金额买 ''' account=self.balance() av_cash=account['可用金额'].tolist()[-1] av_cash=float(av_cash) av_cash=av_cash*buy_ratio stock=self.adjust_stock(stock=stock) price= self.get_bidPrice1(stock) amount=av_cash/price #下单的数量是10 stock=self.adjust_stock(stock=stock) amount=self.adjust_amount(stock=stock,amount=amount) if amount>0: fix_result_order_id=self.buy(security=stock,price=price,amount=amount) text='可用金额定投ETF类型 代码{} 价格{} 数量{} 订单编号{}'.format(stock,price,amount,fix_result_order_id) return '交易成功',text else: text='可用金额定投ET 标的{} 价格{} 委托数量{}小于0有问题/可用金额不足'.format(stock,price,amount) return '交易失败',text def order_stock_async(self,stock_code='600031.SH', order_type=xtconstant.STOCK_BUY, order_volume=100,price_type=xtconstant.FIX_PRICE,price=20,strategy_name='',order_remark=''): ''' 释义 - 对股票进行异步下单操作，异步下单接口如果正常返回了下单请求序号seq，会收到on_order_stock_async_response的委托反馈 * 参数 - account - StockAccount 资金账号 - stock_code - str 证券代码， 如'600000.SH' - order_type - int 委托类型 - order_volume - int 委托数量，股票以'股'为单位，债券以'张'为单位 - price_type - int 报价类型 - price - float 委托价格 - strategy_name - str 策略名称 - order_remark - str 委托备注 ''' # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功 subscribe_result = self.xt_trader.subscribe(self.acc) print(self.xt_trader.query_stock_asset_async(account=self.acc,callback=subscribe_result)) #print(subscribe_result) stock_code = self.adjust_stock(stock=stock_code) price=self.select_slippage(stock=stock_code,price=price,trader_type=order_type) # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态 fix_result_order_id = self.xt_trader.order_stock_async(account=self.acc,stock_code=stock_code, order_type=order_type, order_volume=order_volume, price_type=price_type, price=price, strategy_name=strategy_name, order_remark=order_remark) print('交易类型{} 代码{} 价格{} 数量{} 订单编号{}'.format(order_type,stock_code,price,order_volume,fix_result_order_id)) return fix_result_order_id def cancel_order_stock(self,order_id=12): ''' :param account: 证券账号 :param order_id: 委托编号, 报单时返回的编号 :return: 返回撤单成功或者失败, 0:成功, -1:委托已完成撤单失败, -2:未找到对应委托编号撤单失败, -3:账号未登陆撤单失败 ''' # 使用订单编号撤单 cancel_order_result = self.xt_trader.cancel_order_stock(account=self.acc,order_id=order_id) if cancel_order_result==0: print('成功') elif cancel_order_result==-1: print('委托已完成撤单失败') elif cancel_order_result==-2: print('找到对应委托编号撤单失败') elif cancel_order_result==-3: print('账号未登陆撤单失败') else: pass return cancel_order_result def cancel_order_stock_async(self,order_id=12): ''' * 释义 - 根据订单编号对委托进行异步撤单操作 * 参数 - account - StockAccount 资金账号 - order_id - int 下单接口返回的订单编号 * 返回 - 返回撤单请求序号, 成功委托后的撤单请求序号为大于0的正整数, 如果为-1表示委托失败 * 备注 - 如果失败，则通过撤单失败主推接口返回撤单失败信息 ''' # 使用订单编号撤单 cancel_order_result = self.xt_trader.cancel_order_stock_async(account=self.acc,order_id=order_id) if cancel_order_result==0: print('成功') elif cancel_order_result==-1: print('委托已完成撤单失败') elif cancel_order_result==-2: print('找到对应委托编号撤单失败') elif cancel_order_result==-3: print('账号未登陆撤单失败') else: pass return cancel_order_result def query_stock_asset(self): ''' :param account: 证券账号 :return: 返回当前证券账号的资产数据 ''' # 查询证券资产 asset = self.xt_trader.query_stock_asset(account=self.acc) data_dict={} if asset: data_dict['账号类型']=asset.account_type data_dict['资金账户']=asset.account_id data_dict['可用金额']=asset.cash data_dict['冻结金额']=asset.frozen_cash data_dict['持仓市值']=asset.market_value data_dict['总资产']=asset.total_asset return data_dict else: print('获取失败资金') data_dict['账号类型']=[None] data_dict['资金账户']=[None] data_dict['可用金额']=[None] data_dict['冻结金额']=[None] data_dict['持仓市值']=[None] data_dict['总资产']=[None] return data_dict def balance(self): ''' pandas数据 ''' try: asset = self.xt_trader.query_stock_asset(account=self.acc) df=pd.DataFrame() if asset: df['账号类型']=[asset.account_type] df['资金账户']=[asset.account_id] df['可用金额']=[asset.cash] df['冻结金额']=[asset.frozen_cash] df['持仓市值']=[asset.market_value] df['总资产']=[asset.total_asset] return df except: print('获取账户失败，读取上次数据，谨慎使用') df=pd.DataFrame() return df def query_stock_orders(self): ''' 当日委托 :param account: 证券账号 :param cancelable_only: 仅查询可撤委托 :return: 返回当日所有委托的委托对象组成的list ''' orders = self.xt_trader.query_stock_orders(self.acc) print("委托数量", len(orders)) data=pd.DataFrame() if len(orders) != 0: for i in range(len(orders)): df=pd.DataFrame() df['账号类型']=[orders[i].account_type] df['资金账号']=[orders[i].account_id] df['证券代码']=[orders[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['订单编号']=[orders[i].order_id] df['柜台合同编号']=[orders[i].order_sysid] df['报单时间']=[orders[i].order_time] df['委托类型']=[orders[i].order_type] df['委托数量']=[orders[i].order_volume] df['报价类型']=[orders[i].price_type] df['委托价格']=[orders[i].price] df['成交数量']=[orders[i].traded_volume] df['成交均价']=[orders[i].traded_price] df['委托状态']=[orders[i].order_status] df['委托状态描述']=[orders[i].status_msg] df['策略名称']=[orders[i].strategy_name] df['委托备注']=[orders[i].order_remark] data=pd.concat([data,df],ignore_index=True) data['报单时间']=pd.to_datetime(data['报单时间'],unit='s') return data else: print('目前没有委托') return data def today_entrusts(self): ''' 今天委托 ''' def select_data(x): if x==48: return '未报' elif x==49: return '待报' elif x==50: return '已报' elif x==51: return '已报待撤' elif x==52: return '部分待撤' elif x==53: return '部撤' elif x==54: return '已撤' elif x==55: return '部成' elif x==56: return '已成' elif x==57: return '废单' else: return '废单' orders = self.xt_trader.query_stock_orders(self.acc) print("委托数量", len(orders)) data=pd.DataFrame() if len(orders) != 0: for i in range(len(orders)): df=pd.DataFrame() df['账号类型']=[orders[i].account_type] df['资金账号']=[orders[i].account_id] df['证券代码']=[orders[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['订单编号']=[orders[i].order_id] df['柜台合同编号']=[orders[i].order_sysid] df['报单时间']=[orders[i].order_time] df['委托类型']=[orders[i].order_type] df['委托数量']=[orders[i].order_volume] df['报价类型']=[orders[i].price_type] df['委托价格']=[orders[i].price] df['成交数量']=[orders[i].traded_volume] df['成交均价']=[orders[i].traded_price] df['委托状态']=[orders[i].order_status] df['委托状态描述']=[orders[i].status_msg] df['策略名称']=[orders[i].strategy_name] df['委托备注']=[orders[i].order_remark] data=pd.concat([data,df],ignore_index=True) data['报单时间']=df['报单时间'].apply(conv_time) data['委托状态翻译']=data['委托状态'].apply(select_data) data['未成交数量']=data['委托数量']-data['成交数量'] data['未成交价值']=data['未成交数量']*data['委托价格'] return data else: print('目前没有委托') return data def get_instrument_detail(self,stock_code='600031.SH'): ''' models=qmt_data() df=models.get_instrument_detail() print(df) 释义 获取合约基础信息 参数 stock_code - string 合约代码 iscomplete - bool 是否获取全部字段，默认为False 返回 dict 数据字典，{ field1 : value1, field2 : value2, ... }，找不到指定合约时返回None iscomplete为False时，返回以下字段 ExchangeID - string 合约市场代码 InstrumentID - string 合约代码 InstrumentName - string 合约名称 ProductID - string 合约的品种ID(期货) ProductName - string 合约的品种名称(期货) ExchangeCode - string 交易所代码 UniCode - string 统一规则代码 CreateDate - str 上市日期(期货) OpenDate - str IPO日期(股票) ExpireDate - int 退市日或者到期日 PreClose - float 前收盘价格 SettlementPrice - float 前结算价格 UpStopPrice - float 当日涨停价 DownStopPrice - float 当日跌停价 FloatVolume - float 流通股本 TotalVolume - float 总股本 LongMarginRatio - float 多头保证金率 ShortMarginRatio - float 空头保证金率 PriceTick - float 最小价格变动单位 VolumeMultiple - int 合约乘数(对期货以外的品种，默认是1) MainContract - int 主力合约标记，1、2、3分别表示第一主力合约，第二主力合约，第三主力合约 LastVolume - int 昨日持仓量 InstrumentStatus - int 合约停牌状态 IsTrading - bool 合约是否可交易 IsRecent - bool 是否是近月合约 ''' df=xtdata.get_instrument_detail(stock_code) return df def get_check_stock_is_limit_down(self,stock='600031'): ''' 检查股票是否涨停跌停 ''' stock=self.adjust_stock(stock=stock) instrument=self.get_instrument_detail(stock_code=stock) spot_data=self.get_full_tick(code_list=[stock]) last_price=spot_data[stock]['lastPrice'] UpStopPrice=instrument['UpStopPrice'] DownStopPrice=instrument['DownStopPrice'] if last_price>=UpStopPrice: return '涨停' elif last_price<=DownStopPrice: return '跌停' else: return '正常' def get_check_not_trader_today_entrusts(self,stock='600031',trader_type='buy',data_type='数量'): ''' 检查没有成交的当日委托 ''' stock=self.adjust_stock(stock=stock) df=self.today_entrusts() stock=str(stock)[:6] if df.shape[0]>0: df1=df[df['委托状态']<=53] if df1.shape[0]>0: df2=df1[df1['证券代码']==stock] if df2.shape[0]>0: if trader_type=='buy': df2=df2[df['委托类型']==23] if data_type=='数量': amount=df2['未成交数量'].sum() print('{}委托买入数量{}'.format(stock,amount)) return amount,df2 else: value=df2['未成交价值'].sum() print('{}委托买入价值{}'.format(stock,value)) return value,df2 else: df2=df2[df['委托类型']==24] if data_type=='数量': amount=df2['未成交数量'].sum() print('{}委托卖出数量{}'.format(stock,amount)) return amount,df2 else: value=df2['未成交价值'].sum() print('{}价值{}'.format(stock,value)) return value,df2 else: print('{}没有委托1/委托已经成交'.format(stock)) return 0,'没有委托1/委托已经成交' else: print('没有委托2/委托已经成交') return 0,'没有委托2/委托已经成交' else: print('今天没有委托3/委托已经成交') return 0,'没有委托/委托已经成交' def cancel_order_stock_async_by_code(self,cancel_type='all',stock='600031',num='all'): ''' 通过证券代码来撤单 类型cancel_type=all/buy/sell/one 在有多个单时候选择怎么样撤单num=0/all ''' # 使用订单编号撤单 entrusts=self.today_entrusts() entrusts=entrusts[entrusts['委托状态']<=48] entrusts=entrusts[entrusts['委托状态']<=53] if entrusts.shape[0]>0: #stock=self.adjust_stock(stock=stock) entrusts['证券代码']=entrusts['证券代码'].astype(str) stock_list=entrusts['证券代码'].tolist() if stock in stock_list: if cancel_type=='all': order_id_list=entrusts['订单编号'].tolist() for order_id in order_id_list: self.cancel_order_stock_async(order_id=order_id) elif cancel_type=='buy': entrusts_buy=entrusts[entrusts['委托类型']==xtconstant.STOCK_BUY] order_id_list=entrusts_buy['订单编号'].tolist() for order_id in order_id_list: self.cancel_order_stock_async(order_id=order_id) elif cancel_type=='sell': entrusts_sell=entrusts[entrusts['委托类型']==xtconstant.STOCK_SELL] order_id_list=entrusts_sell['订单编号'].tolist() for order_id in order_id_list: self.cancel_order_stock_async(order_id=order_id) else: entrusts_on=entrusts[entrusts['证券代码']==stock] if num=='all': order_id_list=entrusts_on['订单编号'].tolist() for order_id in order_id_list: self.cancel_order_stock_async(order_id=order_id) else: order_id_list=entrusts_on['订单编号'].tolist() self.cancel_order_stock_async(order_id=order_id_list[num]) def query_stock_trades(self): ''' 当日成交 ''' trades = self.xt_trader.query_stock_trades(self.acc) print("成交数量:", len(trades)) data=pd.DataFrame() if len(trades) != 0: for i in range(len(trades)): df=pd.DataFrame() df['账号类型']=[trades[i].account_type] df['资金账号']=[trades[i].account_id] df['证券代码']=[trades[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['委托类型']=[trades[i].order_type] df['成交编号']=[trades[i].traded_id] df['成交时间']=[trades[i].traded_time] df['成交均价']=[trades[i].traded_price] df['成交数量']=[trades[i].traded_volume] df['成交金额']=[trades[i].traded_amount] df['订单编号']=[trades[i].order_id] df['柜台合同编号']=[trades[i].order_sysid] df['策略名称']=[trades[i].strategy_name] df['委托备注']=[trades[i].order_remark] df['多空方向']=[trades[i].direction] df['交易操作']=[trades[i].offset_flag] data=pd.concat([data,df],ignore_index=True) data['成交时间']=pd.to_datetime(data['成交时间'],unit='s') return data else: print('今日没有成交') return data def today_trades(self): ''' 今日成交 ''' trades = self.xt_trader.query_stock_trades(self.acc) print("成交数量:", len(trades)) data=pd.DataFrame() if len(trades) != 0: for i in range(len(trades)): df=pd.DataFrame() df['账号类型']=[trades[i].account_type] df['资金账号']=[trades[i].account_id] df['证券代码']=[trades[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['委托类型']=[trades[i].order_type] df['成交编号']=[trades[i].traded_id] df['成交时间']=[trades[i].traded_time] df['成交均价']=[trades[i].traded_price] df['成交数量']=[trades[i].traded_volume] df['成交金额']=[trades[i].traded_amount] df['订单编号']=[trades[i].order_id] df['柜台合同编号']=[trades[i].order_sysid] df['策略名称']=[trades[i].strategy_name] df['委托备注']=[trades[i].order_remark] data=pd.concat([data,df],ignore_index=True) def select_data(x): if x==xtconstant.STOCK_BUY: return '证券买入' elif x==xtconstant.STOCK_SELL: return '证券卖出' else: return '无' df['操作']=df['委托类型'].apply(select_data) data['成交时间']=pd.to_datetime(data['成交时间'],unit='s') return data else: print('今日没有成交') return data def query_stock_positions(self): ''' 查询账户所有的持仓 ''' positions = self.xt_trader.query_stock_positions(self.acc) print("持仓数量:", len(positions)) data=pd.DataFrame() if len(positions) != 0: for i in range(len(positions)): df=pd.DataFrame() df['账号类型']=[positions[i].account_type] df['资金账号']=[positions[i].account_id] df['证券代码']=[positions[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['持仓数量']=[positions[i].volume] df['可用数量']=[positions[i].can_use_volume] df['平均建仓成本']=[positions[i].open_price] df['市值']=[positions[i].market_value] data=pd.concat([data,df],ignore_index=True) return data else: print('没有持股') df=pd.DataFrame() df['账号类型']=[None] df['资金账号']=[None] df['证券代码']=[None] df['持仓数量']=[None] df['可用数量']=[None] df['平均建仓成本']=[None] df['市值']=[None] return df def position(self): ''' 持股 ''' try: positions = self.xt_trader.query_stock_positions(self.acc) print("持仓数量:", len(positions)) data=pd.DataFrame() if len(positions) != 0: for i in range(len(positions)): df=pd.DataFrame() df['账号类型']=[positions[i].account_type] df['资金账号']=[positions[i].account_id] df['证券代码']=[positions[i].stock_code] df['证券代码1']=[positions[i].stock_code] df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['股票余额']=[positions[i].volume] df['可用余额']=[positions[i].can_use_volume] df['成本价']=[positions[i].open_price] df['参考成本价']=[positions[i].open_price] df['市值']=[positions[i].market_value] df['冻结数量']=[positions[i].frozen_volume] data=pd.concat([data,df],ignore_index=True) return data else: df=pd.DataFrame() df['账号类型']=None df['资金账号']=None df['证券代码']=None df['股票余额']=None df['可用余额']=None df['成本价']=None df['市值']=None df['选择']=None df['持股天数']=None df['交易状态']=None df['明细']=None df['证券名称']=None df['冻结数量']=None df['市价']=None df['盈亏']=None df['盈亏比(%)']=None df['当日买入']=None df['当日卖出']=None return df except: df=pd.DataFrame() return df def query_stock_position(self,stock_code='600031.SH'): ''' 通过证券代码查持股 ''' position = self.xt_trader.query_stock_position(self.acc, stock_code) df={} if position: df['账号类型']=position.account_type df['资金账号']=position.account_id df['证券代码']=position.stock_code df['证券代码']=df['证券代码'].apply(lambda x:str(x)[:6]) df['持仓数量']=position.volume df['可用数量']=position.can_use_volume df['平均建仓成本']=position.open_price df['市值']=position.market_value return df else: print('没有持股') return {} def query_stock_ipo_data(self): ''' 获取股票新可转债ipo数据 dict 新股新债信息数据集 { stock1: info1, stock2: info2, ... } stock - str 品种代码，例如 '301208.SZ' info - dict 新股信息 name - str 品种名称 type - str 品种类型 STOCK - 股票，BOND - 债券 minPurchaseNum / maxPurchaseNum - int 最小 / 最大申购额度 单位为股（股票）/ 张（债券） purchaseDate - str 申购日期 issuePrice - float 发行价 ''' try: data=self.xt_trader.query_ipo_data() df=pd.DataFrame(data).T df['证券代码']=df.index df.columns=['品种名称','品种类型','最大申购额度','最小申购额度','申购日期','发行价','证券代码'] return df except: print('没有数据/处理出现错误') df=pd.DataFrame() df['品种名称']=None df['品种类型']=None df['最小申购额度']=None df['最大申购额度']=None df['申购日期']=None df['发行价']=None df['证券代码']=None return df def get_buy_stock_ipo(self): ''' 可转债新股一起申购 ''' df=self.query_stock_ipo_data() for trader_type,name,stock,amount,price in zip(df['品种类型'],df['品种名称'],df['证券代码'],df['最大申购额度'],df['发行价']): self.buy(security=stock,amount=amount,price=price) print('新股/可转债申购 交易类型{} 名称{} 代码{} 数量{} 价格{}'.format(trader_type,name,stock,amount,price)) def query_stock_new_purchase_limit(self): ''' 释义 查询新股申购额度 参数 account - StockAccount 资金账号 返回 dict 新股申购额度数据集 { type1: number1, type2: number2, ... } type - str 品种类型 KCB - 科创板，SH - 上海，SZ - 深圳 number - int 可申购股数 备注 数据仅代表股票申购额度，债券的申购额度固定10000张 ''' #有问题 print(self.account) df=self.xt_trader.query_new_purchase_limit(account=self.account) print(df) def run_forever(self): ''' 阻塞线程，接收交易推送 ''' self.xt_trader.run_forever() def stop(self): self.xt_trader.stop() def order_target_volume(self,stock='501018',amount=1000,price=12): ''' 目标数量下单 stock: 标的代码 amount: 期望的最终数量 price:价格 trader_type针对买入账户没有持股的股票，一般不改动 ''' hold_stock=self.position() try: del hold_stock['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] if hold_stock.shape[0]>0: stock=str(stock) df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #持有的价值 hold_value=df1['市值'].tolist()[-1] else: av_num=0 hold_num=0 hold_value=0 else: av_num=0 hold_num=0 hold_value=0 buy_sell_num=amount-float(hold_num) buy_sell_value=buy_sell_num*price #存在买入差额 if buy_sell_num>0: buy_sell_num=self.adjust_amount(stock=stock,amount=buy_sell_num) #可以资金大于买卖的差额 if buy_sell_num>=10: #可以资金大于买卖差额 if cash>=buy_sell_value: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要买入数量{}'.format(stock,amount,hold_num,av_num,buy_sell_num)) return 'buy',buy_sell_num,price else: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要买入数量{} 可用金额{}小于下单金额{} 不交易'.format(stock,amount,hold_num,av_num,buy_sell_num,cash,buy_sell_value)) return '',0,price else: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要买入数量{}小于10不交易'.format(stock,amount,hold_num,av_num,buy_sell_num)) return '',0,price #存在卖出空间： elif buy_sell_num <0: #可以卖出的数量多 buy_sell_num=abs(buy_sell_num) buy_sell_num=self.adjust_amount(stock=stock,amount=buy_sell_num) if av_num>=buy_sell_num: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要卖出数量{}'.format(stock,amount,hold_num,av_num,buy_sell_num)) return 'sell',buy_sell_num,price else: #可以卖出的不足卖出全部可以卖出的 print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 小于需要卖出数量{} 直接卖出'.format(stock,amount,hold_num,av_num,buy_sell_num)) return 'sell',buy_sell_num,price else: print('目标数量下单{} 目标数量{} 持有数量{} 可以用数量{} 需要卖出数量{}等于0不交易'.format(stock,amount,hold_num,av_num,buy_sell_num)) return '',0,price def order_value(self,stock='501018',value=1000,price=1.33,trader_type='buy'): ''' 按金额下单 stock: 证券代码 value下单金额 value大于0买入，小0卖出 prive交易的的价格 ''' hold_stock=self.position() account=self.balance() cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] amount=value/price amount=self.adjust_amount(stock=stock,amount=amount) if trader_type=='buy': #这里按道理需要考虑手续费，看隔日资金 if cash>=value: if amount>=10: print('按金额下单{} 交易类型{} 可用资金{}大于 下单金额{} 下单数量{}'.format(stock,trader_type,cash,value,amount)) return 'buy',amount,price else: print('按金额下单{} 交易类型{} 可用资金{}大于 下单金额{} 下单数量{}小于最小下单单位不交易'.format(stock,trader_type,cash,value,amount)) return '',0,price else: print('按金额下单{} 交易类型{} 可用资金{}小于 下单金额{} 下单数量{} 不交易'.format(stock,trader_type,cash,value,amount)) return '',0,price elif trader_type=='sell': df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #可用余额大于下单数量 if av_num>=amount: print('按金额下单{} 交易类型{} 持有数量{} 可用数量{}大于 下单数量{} 下单数量{}'.format(stock,trader_type,hold_num,av_num,amount,amount)) return 'sell',amount,price else: if av_num>=10: print('按金额下单{} 交易类型{} 持有数量{} 可用数量{}小于 下单数量{} 直接卖出全部下单数量{}'.format(stock,trader_type,hold_num,av_num,amount,av_num)) return 'sell',av_num,price else: print('按金额下单{} 交易类型{} 持有数量{} 可用数量{}小于 下单数量{} 下单数量{}小于最小单位不交易'.format(stock,trader_type,hold_num,av_num,amount,av_num)) return '',0,price else: return '',0,price else: print('按金额下单{} 交易类型{}未知道 不交易'.format(stock,trader_type)) return '',0,price def adjust_amount(self,stock='',amount=''): ''' 调整数量 ''' if stock[:3] in ['110','113','123','127','128','111'] or stock[:2] in ['11','12']: amount=math.floor(amount/10)*10 else: amount=math.floor(amount/100)*100 return amount def order_target_value(self,stock='501018',value=1000,price=1.33): ''' 目标价值下单 stock: 股票名字 value: 股票价值，value = 最新价 * 手数 * 保证金率（股票为1） * 乘数（股票为100） prive交易的的价格 ''' hold_stock=self.position() try: del hold_stock['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] amount=math.floor(value/price) if hold_stock.shape[0]>0: stock=str(stock) df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #持有的价值 hold_value=df1['市值'].tolist()[-1] else: av_num=0 hold_num=0 hold_value=0 else: av_num=0 hold_num=0 hold_value=0 #买卖价值差转成数量 #可转债最新10 amount=self.adjust_amount(stock=stock,amount=amount) #买卖的差额 buy_sell_num=math.floor(amount-float(hold_num)) buy_sell_num=self.adjust_amount(stock=stock,amount=buy_sell_num) buy_sell_value=buy_sell_num*price #存在买入差额,买入的大于持有的 if buy_sell_num>0: if buy_sell_num>=10: #可用现金大于买卖的差额 if cash>=buy_sell_value: print('目标价值下单{} 目标价值{} 可用资金{}大于买卖资金{} 目标数量{} 持有数量{} 可用数量{} 买入差额{}'.format(stock,value,cash,buy_sell_value,amount,hold_num,av_num,buy_sell_num)) return 'buy',buy_sell_num,price else: print('目标价值下单{} 目标价值{} 可用资金{}小于买卖资金{} 目标数量{} 持有数量{} 可用数量{} 买入差额{}不下单'.format(stock,value,cash,buy_sell_value,amount,hold_num,av_num,buy_sell_num)) return '',0,price else: print('目标价值下单{} 目标价值{} 可用资金{} 买卖资金{} 目标数量{} 持有数量{} 可用数量{} 买入差额{}不下单小于最小单位去10'.format(stock,value,cash,buy_sell_value,amount,hold_num,av_num,buy_sell_num)) return '',0,price #存在卖出空间,目标数量小于持有数量卖出： elif buy_sell_num <0: #可以卖出的数量多 if av_num>=buy_sell_num: buy_sell_num=abs(buy_sell_num) buy_sell_num=self.adjust_amount(stock=stock,amount=buy_sell_num) print('目标价值下单{} 目标价值{} 目标数量{} 持有数量{} 可用数量{} 卖出差额{}'.format(stock,value,amount,hold_num,av_num,buy_sell_num)) return 'sell',buy_sell_num,price else: #可以卖出的不足卖出全部可以卖出的 print('目标价值下单{} 目标价值{} 目标数量{} 持有数量{} 可用数量{}小于卖出数量 卖出差额{}'.format(stock,value,amount,hold_num,av_num,buy_sell_num)) return 'sell',av_num,price else: print('目标价值下单{} 目标价值{} 目标数量{} 等于持有数量{} 可用数量{} 卖出差额{}不下单'.format(stock,value,amount,hold_num,av_num,buy_sell_num)) return '',0,price def order_percent(self,stock='501018',percent=0.1,price=1.33,trader_type='buy'): ''' 百分比交易 percent下单百分比 ''' hold_stock=self.position() account=self.balance() cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type='金额') #目标金额=目标百分比-委托金额 target_value=total_asset*percent-entrusts_amount #数量 amount=target_value/price amount=self.adjust_amount(stock=stock,amount=amount) if trader_type=='buy': #这里按道理要考虑手续费看个资金 if cash>=target_value: if amount>=10: print('百分比交易{} 下单类型{} 百分比{} 下单数量{} 可以资金{}大于目标资金{} 买入数量{}'.format(stock,trader_type,percent,amount,cash,target_value,amount)) return 'buy',amount,price else: print('百分比交易{} 下单类型{} 百分比{} 下单数量{} 可以资金{}大于目标资金{} 买入数量{}小于10不下单'.format(stock,trader_type,percent,amount,cash,target_value,amount)) return '',0,price else: print('百分比交易{} 下单类型{} 百分比{} 下单数量{} 可以资金{}小于目标资金{} 买入数量{}'.format(stock,trader_type,percent,amount,cash,target_value,amount)) return '',0,price elif trader_type=='sell': if hold_stock.shape[0]>0: stock=str(stock) df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #持有的价值 hold_value=df1['市值'].tolist()[-1] #可用数量大于卖出数量 if av_num>=amount: print('百分比交易{} 下单类型{} 百分比{} 持有数量{} 可以数量{} 大于等于下单数量{} 下单{}'.format(stock,trader_type,percent,hold_num,cash,amount,amount)) return 'sell',amount,price else: print('百分比交易{} 下单类型{} 百分比{} 持有数量{} 可以数量{} 小于下单数量{} 下单{}'.format(stock,trader_type,percent,hold_num,cash,amount,av_num)) return 'sell',av_num,price else: print('{}账户没有持股不支持交易类型{}'.format(stock,trader_type)) return '',0,price else: print('账户没有持股不支持交易类型{}'.format(trader_type)) return '',0,price else: print('未知的交易类型{}'.format(trader_type)) return '',0,price def order_target_percent(self,stock='501018',target_percent=0.1,price=1.33): ''' 目标百分比下单 ''' hold_stock=self.position() account=self.balance() cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] #entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type='金额') #目标金额 target_value=total_asset*target_percent #目标数量 target_amount=target_value/price amount=self.adjust_amount(stock=stock,amount=target_amount) if hold_stock.shape[0]>0: stock=str(stock) df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #持有的价值 hold_value=df1['市值'].tolist()[-1] else: av_num=0 hold_num=0 hold_value=0 else: av_num=0 hold_num=0 hold_value=0 #没有买入数量,目标数量-持有数量 buy_sell_amount=amount-hold_num #大于0 存在买入的差额 if buy_sell_amount>=10: #可以现金大于目标金额 这里要考虑手续看个人资金 if cash>=target_value: print('目标百分比下单{} 目标百分比{} 目标数量{} 可以资金{}大于目标资金{} 持有数量{} 可用数量{} 买入差额{}'.format(stock,target_percent,target_amount,cash,target_value,hold_num,av_num,buy_sell_amount)) return 'buy',buy_sell_amount,price else: print('目标百分比下单{} 目标百分比{} 目标数量{} 可以资金{}小于目标资金{} 持有数量{} 可用数量{} 买入差额{}不下单'.format(stock,target_percent,target_amount,cash,target_value,hold_num,av_num,buy_sell_amount)) return '',0,price elif buy_sell_amount<=10 and buy_sell_amount>=0: print('目标百分比下单{} 目标百分比{} 目标数量{} 可以资金{}目标资金{} 持有数量{} 可用数量{} 买入差额{}小于10不下单'.format(stock,target_percent,target_amount,cash,target_value,hold_num,av_num,buy_sell_amount)) return '',0,price else: #可用买入的差额小于0 卖出 buy_sell_amount=abs(buy_sell_amount) #可用数量大于差额 if av_num>=buy_sell_amount: print('目标百分比下单{} 目标百分比{} 目标数量{} 持有数量{} 可用数量{} 大于差额{} 卖出差额{}'.format(stock,target_percent,target_amount,hold_num,av_num,buy_sell_amount,buy_sell_amount)) return 'sell',buy_sell_amount,price else: print('目标百分比下单{} 目标百分比{} 目标数量{} 持有数量{} 可用数量{} 小于差额{} 卖出全部{}'.format(stock,target_percent,target_amount,hold_num,av_num,buy_sell_amount,av_num)) return 'sell',av_num,price def order_target_percent_volume(self,stock='501018',target_percent=0.1,price=1.33): ''' 目标百分比下单数量模式 ''' hold_stock=self.position() try: del hold_stock['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] #entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type='金额') #目标金额 target_value=total_asset*target_percent #目标数量 target_amount=target_value/price trader_type,trader_amount,price=self.order_target_volume(stock=stock,amount=target_amount,price=price) return trader_type,trader_amount,price def order_target_percent_value(self,stock='501018',target_percent=0.1,price=1.33): ''' 目标百分比下单金额模式 ''' hold_stock=self.position() try: del hold_stock['Unnamed: 0'] except: pass account=self.balance() try: del account['Unnamed: 0'] except: pass cash=account['可用金额'].tolist()[-1] frozen_cash=account['冻结金额'].tolist()[-1] market_value=account['持仓市值'].tolist()[-1] total_asset=account['总资产'].tolist()[-1] #entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type='金额') #目标金额 target_value=total_asset*target_percent #目标数量 target_amount=target_value/price trader_type,trader_amount,price=self.order_target_value(stock=stock,value=target_value,price=price) return trader_type,trader_amount,price def one_click_clearance(self): ''' 一键清仓 ''' hold_stock=self.position() if hold_stock.shape[0]>0: for stock,hold_num,av_num in zip(hold_stock["证券代码"].tolist(), hold_stock['可用余额'].tolist(),hold_stock['股票余额'].tolist()): try: stock_1=self.adjust_stock(stock=stock) price=self.get_full_tick(code_list=[stock_1])[stock_1]['lastPrice'] if av_num>=10: print('一键清仓{} 持有数量{} 可用数量{} 卖出数量{}'.format(stock,hold_num,av_num,av_num)) self.sell(security=stock,amount=av_num,price=price) else: print('一键清仓{} 持有数量{} 可用数量{}小于0 卖出数量{} 不交易'.format(stock,hold_num,av_num,av_num)) except Exception as e: print(e) else: print("一键清仓 账户没有持股，清仓不了") def one_click_cancel_order_all(self): """ 一键撤单全部 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") def one_click_cancel_order_buy(self): """ 一键撤单全部买入委托 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): if data_type==23 or data_type=='买入': #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{}不是买入 撤单失败'.format(stock,amount,order_id,data_type)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") def one_click_cancel_order_sell(self): """ 一键撤单全部卖出委托 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): if data_type==24 or data_type=='卖出': #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{}不是卖出 撤单失败'.format(stock,amount,order_id,data_type)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") def one_click_cancel_order_buy_by_stock(self,stock='600031'): """ 一键撤单个股全部买入委托 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: df=df[df['证券代码']==stock] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): if data_type==23 or data_type=='买入': #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{}不是买入 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 没有可以撤单的内容'.format(stock)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") def one_click_cancel_order_sell_by_stock(self,stock='600031'): """ 一键撤单个股全部卖出委托 """ df=self.today_entrusts() if df.shape[0]>0: df=df[df['委托状态']>=48] df=df[df['委托状态']<=53] if df.shape[0]>0: df=df[df['证券代码']==stock] if df.shape[0]>0: for stock,amount,order_id,data_type,in zip(df['证券代码'],df['未成交数量'],df['订单编号'],df['委托类型']): if data_type==24 or data_type=='卖出': #撤单 cancel_order_result=self.cancel_order_stock_async(order_id=int(order_id)) if cancel_order_result>=0: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单成功'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{} 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 未成交数量{} 订单编号{} 委托类型{}不是卖出 撤单失败'.format(stock,amount,order_id,data_type)) else: print('一键撤单{} 没有可以撤单的内容'.format(stock)) else: print("一键撤单 没有可以撤的单") else: print("一键撤单 没有委托") def check_av_target_trader(self,data_type='数量',trader_type='buy',amount=1000,limit_volume=2000, value=2000,limit_value=4000,stock='501018',price=2.475): ''' 检查模块资金分配 data_type='数量'/资金, trader_type='buy',交易类型 amount=1000,每次交易的数量股 limit_volume=2000,单一标的持股限制 value=2000,每次交易金额 limit_value=4000,单一标的金额限制 stock='501018',代码 price=2.475交易的价格 ''' self.get_check_not_trader_today_entrusts() #stock=self.adjust_stock(stock=stock) stock=str(stock)[:6] self.open_set='' try: hold_stock=self.position() except: hold_stock=pd.read_excel(r'持股数据\持股数据.xlsx',dtype='object') if data_type=='数量': if hold_stock.shape[0]>0: stock=str(stock) if trader_type=='buy': df1=hold_stock[hold_stock['证券代码']==stock] #标的有持股 if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #委托数量 entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type=data_type) #买卖的差额 av_buy_sell=limit_volume-hold_num-entrusts_amount #持股限制大于现在的持有数量 #可以买入的数量大于每次交易的数量 if av_buy_sell>=amount: amount=self.adjust_amount(stock=stock,amount=amount) if amount<=0: print('数量模块1{} 可以买入的数量{} 小于0'.format(stock,amount)) return '','','' else: return 'buy',amount,price else: #可以买入的数量小于每次交易的数量 msg='数量模块2{} 可以买入的数量{} 小于每次交易数量{}不交易'.format(stock,av_buy_sell,amount) print(msg) return '',amount,price else: #如果没有持股，直接买入， #持有数量为0 #委托数量 entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='buy',data_type=data_type) av_buy_sell=limit_volume-0-entrusts_amount #持股限制大于现在的持有数量 #可以买入的数量大于每次交易的数量 if av_buy_sell>=amount: amount=self.adjust_amount(stock=stock,amount=amount) if amount<=0: print('数量模块3{} 可以买入的数量{} 小于0'.format(stock,amount)) return '',amount,price else: return 'buy',amount,price else: #可以买入的数量小于每次交易的数量 msg='数量模块4{} 可以买入的数量{} 小于每次交易数量{}不交易'.format(stock,av_buy_sell,amount) print(msg) return '',amount,price #单一标的有持股卖出 else: #卖 df1=hold_stock[hold_stock['证券代码']==stock] #有持股 if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] #可以卖出的数量 #委托数量 entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='sell',data_type=data_type) av_buy_sell=hold_num-amount-entrusts_amount av_num=self.adjust_amount(stock,amount=av_num) if av_buy_sell>=amount: return 'sell',amount,price else: if av_num>0: return 'sell',av_num,price else: print('数量模块5不卖出 可以数量0 小于固定交易数量{} '.format(amount)) return '',amount,price else: print('数量模块6持股卖出没有持股 可以数量0 小于固定交易数量{} '.format(amount)) return '',amount,price #账户没有持股，为空 else: if trader_type=='buy': #委托数量 entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type=trader_type,data_type=data_type) av_buy_sell=limit_volume-0-entrusts_amount #持股限制大于现在的持有数量 #可以买入的数量大于每次交易的数量 if av_buy_sell>=amount: amount=self.adjust_amount(stock=stock,amount=amount) if amount<=0: print('数量模块7{} 可以买入的数量{} 小于0'.format(stock,amount)) return '',amount,price else: return 'buy',amount,price else: #可以买入的数量小于每次交易的数量 msg='数量模块8{} 可以买入的数量{} 小于每次交易数量{}不交易'.format(stock,av_buy_sell,amount) print(msg) return '',amount,price else: print('数量模块9{} 账户持股为空不能卖出'.format(stock)) return '',amount,price else: #金额 amount=value/price amount=self.adjust_amount(stock=stock,amount=amount) limit_volume=limit_value/price limit_volume=self.adjust_amount(stock=stock,amount=limit_volume) if hold_stock.shape[0]>0: stock=str(stock) df1=hold_stock[hold_stock['证券代码']==stock] stock=str(stock) if trader_type=='buy': df1=hold_stock[hold_stock['证券代码']==stock] #单一标的有持股 if df1.shape[0]>0: #可以使用的数量兼容t0 av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] hold_value=df1['市值'].tolist()[-1] hold_num=self.adjust_amount(stock=stock,amount=hold_value/price) if hold_value>=limit_value: print('资金模块1{} 持股的价值{}大于持股价值{}限制不交易'.format(stock,hold_value,limit_value)) return '',price,'' else: #买卖的差额 #委托数量 entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type=trader_type,data_type='金额') av_buy_sell=limit_volume-hold_num-entrusts_amount if av_buy_sell>=amount: amount=self.adjust_amount(stock=stock,amount=amount) if amount<=0: print('资金模块2{} 可以买入的数量{} 小于0'.format(stock,amount)) return '','','' else: return 'buy',amount,price else: #可以买入的数量小于每次交易的数量 msg='资金模块3{} 可以买入的数量{} 小于每次交易数量{}不交易'.format(stock,av_buy_sell,amount) print(msg) return '',amount,price #单一标的账户没有持股买入 else: amount=value/price amount=self.adjust_amount(stock=stock,amount=amount) limit_volume=limit_value/price limit_volume=self.adjust_amount(stock=stock,amount=limit_volume) #委托数量 entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type=trader_type,data_type='金额') av_buy_sell=limit_volume-0-entrusts_amount if av_buy_sell>=amount: if amount<=0: print('资金模块4{} 可以买入的数量{} 小于0'.format(stock,av_buy_sell)) return '',amount,price else: return 'buy',amount,price else: #可以买入的数量小于每次交易的数量 msg='资金模块5{} 可以买入的数量{} 小于每次交易数量{}不交易'.format(stock,av_buy_sell,amount) print(msg) return '',amount,price #单一有持股卖出 else: #卖 df1=hold_stock[hold_stock['证券代码']==stock] if df1.shape[0]>0: #可以使用的数量兼容t0 amount=value/price amount=self.adjust_amount(stock=stock,amount=amount) limit_volume=limit_value/price limit_volume=self.adjust_amount(stock=stock,amount=limit_volume) stock=str(stock) av_num=df1['可用余额'].tolist()[-1] #持有数量 hold_num=df1['股票余额'].tolist()[-1] hold_value=df1['市值'].tolist()[-1] hold_num=self.adjust_amount(stock=stock,amount=hold_value/price) #委托数量 entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type='sell',data_type='金额') #可以卖出的数量 av_buy_sell=hold_num-amount-entrusts_amount if av_buy_sell>=amount: return 'sell',amount,price else: if av_num>0: return 'sell',av_num,price else: #可以买入的数量小于每次交易的数量 msg='资金模块6持股卖出{} 可用数量{}小于0'.format(stock,av_num) print(msg) return '',amount,price else: msg='资金模块7有持股卖出{} 可用数量小于0'.format(stock) print(msg) return '',amount,price #账户没有持股买入 else: if trader_type=='buy': amount=value/price amount=self.adjust_amount(stock,amount=amount) limit_volume=limit_value/price limit_volume=self.adjust_amount(stock=stock,amount=limit_volume) #委托数量 entrusts_amount,entrusts_df=self.get_check_not_trader_today_entrusts(stock=stock,trader_type=trader_type,data_type='金额') av_buy_sell=limit_volume-0-entrusts_amount if av_buy_sell>=amount: if amount<=0: print('资金模块8{} 可以买入的数量{} 小于0'.format(stock,av_buy_sell)) return '',amount,price else: return 'buy',amount,price else: #可以买入的数量小于每次交易的数量 msg='资金模块9持股买入{} 可以买入的数量{} 小于每次交易数量{}不交易'.format(stock,av_buy_sell,amount) print(msg) return '',amount,price else: print('资金模块10持股为空{}不卖出'.format(stock)) return '','','' def query_credit_detail(self): ''' 账户数据 释义 查询信用资金账号对应的资产 参数 account - StockAccount 资金账号 返回 该信用账户对应的资产对象XtCreditDetail组成的list或者None 备注 None表示查询失败 通常情况下一个资金账号只有一个详细信息数据 示例 查询信用资金账号1208970161对应的资产信息 ''' account = StockAccount(self.account, self.account_type) positions=self.xt_trader.query_credit_detail(account) data=pd.DataFrame() if len(positions) != 0: for i in range(len(positions)): df=pd.DataFrame() df['账号类型']=[positions[i].account_type] df['资金账号']=[positions[i].account_id] df['账号状态']=[positions[i].m_nStatus] df['更新时间']=[positions[i].m_nUpdateTime] df['计算参数']=[positions[i].m_nCalcConfig] df['冻结金额']=[positions[i].m_dFrozenCash] df['总资产']=[positions[i].m_dBalance] df['可用金额']=[positions[i].m_dAvailable] df['持仓盈亏']=[positions[i].m_dPositionProfit] df['总市值']=[positions[i].m_dMarketValue] df['可取金额']=[positions[i].m_dFetchBalance] df['股票市值']=[positions[i].m_dStockValue] df['基金市值']=[positions[i].m_dFundValue] df['总负债']=[positions[i].m_dTotalDebt] df['可用保证金']=[positions[i].m_dEnableBailBalance] df['维持担保比例']=[positions[i].m_dPerAssurescaleValue] df['净资产']=[positions[i].m_dAssureAsset] df['融资负债']=[positions[i].m_dFinDebt] df['融资本金']=[positions[i].m_dFinDealAvl] df['融资息费']=[positions[i].m_dFinFee] df['融券负债']=[positions[i].m_dSloDebt] df['融券市值']=[positions[i].m_dSloMarketValue] df['融券息费']=[positions[i].m_dSloFee] df['其它费用']=[positions[i].m_dOtherFare] df['融资授信额度']=[positions[i].m_dFinMaxQuota] df['融资可用额度']=[positions[i].m_dFinEnableQuota] df['融资冻结额度']=[positions[i].m_dFinUsedQuota] df['融券授信额度']=[positions[i].m_dSloMaxQuota] df['融券可用额度']=[positions[i].m_dSloEnableQuota] df['融券冻结额度']=[positions[i].m_dSloUsedQuota] df['融券卖出资金']=[positions[i].m_dSloSellBalance] df['已用融券卖出资金']=[positions[i].m_dUsedSloSellBalance] df['剩余融券卖出资金']=[positions[i].m_dSurplusSloSellBalance] data=pd.concat([data,df],ignore_index=True) return data else: print('没有数据') df=pd.DataFrame() return df def query_stk_compacts(self): ''' 释义 查询资金账号对应的负债合约 参数 account - StockAccount 资金账号 返回 该账户对应的负债合约对象StkCompacts组成的list或者None 备注 None表示查询失败或者负债合约列表为空 示例 查询信用资金账号1208970161对应的负债合约 ''' account = StockAccount(self.account, self.account_type) compacts=self.xt_trader.query_stk_compacts(account) print(len(compacts)) data=pd.DataFrame() if len(compacts) != 0: for i in range(len(compacts)): df=pd.DataFrame() df['账号类型']=[compacts[i].account_type] df['资金账号']=[compacts[i].account_id] df['合约类型']=[compacts[i].compact_type] df['头寸来源']=[compacts[i].cashgroup_prop] df['证券市场']=[compacts[i].exchange_id] df['开仓日期']=[compacts[i].open_date] df['合约证券数量']=[compacts[i].business_vol] df['未还合约数量']=[compacts[i].real_compact_vol] df['到期日']=[compacts[i].ret_end_date] df['合约金额']=[compacts[i].business_balance] df['合约息费']=[compacts[i].businessFare] df['未还合约金额']=[compacts[i].real_compact_balance] df['未还合约息费']=[compacts[i].real_compact_fare] df['已还息费']=[compacts[i].repaid_fare] df['已还金额']=[compacts[i].repaid_balance] df['证券代码']=[compacts[i].instrument_id] df['合约编号']=[compacts[i].compact_id] df['定位串']=[compacts[i].position_str] data=pd.concat([data,df],ignore_index=True) return data else: print('没有负债合约') df=pd.DataFrame() return df def query_credit_subjects(self): ''' 释义 查询资金账号对应的融资融券标的 参数 account - StockAccount 资金账号 返回 该账户对应的融资融券标的对象CreditSubjects组成的list或者None 备注 None表示查询失败或者融资融券标的列表为空 示例 查询信用资金账号1208970161对应的融资融券标的 ''' account = StockAccount(self.account, self.account_type) compacts=self.xt_trader.query_credit_subjects(account) print(len(compacts)) data=pd.DataFrame() if len(compacts) != 0: for i in range(len(compacts)): df=pd.DataFrame() df['账号类型']=[compacts[i].account_type] df['资金账号']=[compacts[i].account_id] df['融券状态']=[compacts[i].slo_status] df['证券市场']=[compacts[i].exchange_id] df['融券保证金比例']=[compacts[i].slo_ratio] df['融资保证金比例']=[compacts[i].fin_ratio] df['证券代码']=[compacts[i].instrument_id] data=pd.concat([data,df],ignore_index=True) return data else: print('没有融资融券标的') df=pd.DataFrame() return df def query_credit_slo_code(self): ''' 释义 查询资金账号对应的可融券数据 参数 account - StockAccount 资金账号 返回 该账户对应的可融券数据对象CreditSloCode组成的list或者None 备注 None表示查询失败或者可融券数据列表为空 示例 查询信用资金账号1208970161对应的可融券数据 ''' account = StockAccount(self.account, self.account_type) compacts=self.xt_trader.query_credit_slo_code(account) print(len(compacts)) data=pd.DataFrame() if len(compacts) != 0: for i in range(len(compacts)): df=pd.DataFrame() df['账号类型']=[compacts[i].account_type] df['资金账号']=[compacts[i].account_id] df['头寸来源']=[compacts[i].cashgroup_prop] df['证券市场']=[compacts[i].exchange_id] df['融券可融数量']=[compacts[i].enable_amount] df['证券代码']=[compacts[i].instrument_id] data=pd.concat([data,df],ignore_index=True) return data else: print('没有可融券数据') df=pd.DataFrame() return df def query_credit_assure(self): ''' 释义 查询资金账号对应的标的担保品 参数 account - StockAccount 资金账号 返回 该账户对应的标的担保品对象CreditAssure组成的list或者None 备注 None表示查询失败或者标的担保品列表为空 示例 查询信用资金账号1208970161对应的标的担保品 ''' account = StockAccount(self.account, self.account_type) compacts=self.xt_trader.query_credit_assure(account) print(len(compacts)) data=pd.DataFrame() if len(compacts) != 0: for i in range(len(compacts)): df=pd.DataFrame() df['账号类型']=[compacts[i].account_type] df['资金账号']=[compacts[i].account_id] df['是否可做担保']=[compacts[i].assure_status] df['证券市场']=[compacts[i].exchange_id] df['担保品折算比例']=[compacts[i].assure_ratio] df['证券代码']=[compacts[i].instrument_id] data=pd.concat([data,df],ignore_index=True) return data else: print('没有对应的标的担保品') df=pd.DataFrame() return df def check_stock_weight(self,stock='600031',user_ratio=0.1): ''' 检查个股的权重 ''' account=self.balance() position=self.position() total_cash=account['总资产'].tolist() total_cash=total_cash*user_ratio if position.shape[0]>0: df=position[position['证券代码']==stock] if df.shape[0]>0: market_value=df['市值'].tolist()[-1] return market_value/total_cash else: return 0 else: return 0 if __name__=='__main__': models=qmt_trader(r'D:/国金QMT交易端模拟/userdata_mini', session_id = 123456,account='55001947',account_type='STOCK', is_slippage=True,slippage=0.01) models.connect() print(models.balance()) print(models.position()) models.buy() ```