# encoding:gbk

'''

实盘可以执行

固定数量

'''

import datetime





ACCOUNT = ''





def init(ContextInfo):

    ContextInfo.set_account(ACCOUNT)





def get_position_infos():

    # 信用账户可用资金

    position_infos = get_trade_detail_data(ACCOUNT, 'stock', 'position')

    



    pos_dict={}

    for pos in position_infos:

        code = pos.m_strInstrumentID

        if pos.m_nVolume > 0:

            pos_dict[code] = pos.m_nVolume

    return pos_dict

    

datax = get_position_infos() # 这里error



def handlebar(ContextInfo):

    if ContextInfo.is_last_bar():

        current = datetime.datetime.now().strftime('%H:%M:%S.%f')

        print(datax)

        

# coding:gbk

def init(C):

    pass



def handlebar(C):

    iopv = get_etf_iopv("159928.SZ")

    print(f'基金净值为{iopv}')

    info = get_etf_info('513520.SH')

    print(f'基金申购信息： {info}')

# coding:gbk

# 公众号:可转债量化分析

DEBUG = True

import time

def get_datetime(ContextInfo):

    # 获取当前时间

    index = ContextInfo.barpos

    realtime = ContextInfo.get_bar_timetag(index)

    date = timetag_to_datetime(realtime, "%Y-%m-%d %H:%M:%S")

    if DEBUG:

        print('当前日期 ', date)

    return date

    

def init(ContextInfo):

    print("==============start==========")

    ContextInfo.start = '2024-03-27 10:00:00'

    ContextInfo.end = '2024-03-29 10:00:00'

    # 

    #ContextInfo.end = '2023-01-05'

    #ContextInfo.start = '2023-01-16'

    print('init')

    

def handlebar(ContextInfo):

    # 回测的时候不需要

    #if not ContextInfo.is_last_bar():

    #    print('return')

    #    return

    get_datetime(ContextInfo)

    print('handlebar')

    data = ContextInfo.get_market_data(['quoter'], stock_code = ['123167.SZ'], skip_paused = True, period = 'tick', dividend_type = 'front')

    

    #data = ContextInfo.get_market_data(['close'], stock_code = ['113567.SH'], skip_paused = True, period = '1d', dividend_type = 'front')

    #print(type(data))

    print(data)



def stop(ContextInfo):

    print( 'strategy is stop !')

# 用前须知



## xtdata提供和MiniQmt的交互接口，本质是和MiniQmt建立连接，由MiniQmt处理行情数据请求，再把结果回传返回到python层。使用的行情服务器以及能获取到的行情数据和MiniQmt是一致的，要检查数据或者切换连接时直接操作MiniQmt即可。



## 对于数据获取接口，使用时需要先确保MiniQmt已有所需要的数据，如果不足可以通过补充数据接口补充，再调用数据获取接口获取。



## 对于订阅接口，直接设置数据回调，数据到来时会由回调返回。订阅接收到的数据一般会保存下来，同种数据不需要再单独补充。



# 代码讲解



# 从本地python导入xtquant库，如果出现报错则说明安装失败

from xtquant import xtdata

import time



# 设定一个标的列表

code_list = ["000001.SZ"]

# 设定获取数据的周期

period = "1d"



# 下载标的行情数据

if 1:

    ## 为了方便用户进行数据管理，xtquant的大部分历史数据都是以压缩形式存储在本地的

    ## 比如行情数据，需要通过download_history_data下载，财务数据需要通过

    ## 所以在取历史数据之前，我们需要调用数据下载接口，将数据下载到本地

    for i in code_list:

        xtdata.download_history_data(i,period=period,incrementally=True) # 增量下载行情数据（开高低收,等等）到本地

    

    xtdata.download_financial_data(code_list) # 下载财务数据到本地

    xtdata.download_sector_data() # 下载板块数据到本地

    # 更多数据的下载方式可以通过数据字典查询



# 读取本地历史行情数据

history_data = xtdata.get_market_data_ex(,code_list,period=period,count=-1)

print(history_data)

print("=" * 20)



# 如果需要盘中的实时行情，需要向服务器进行订阅后才能获取

# 订阅后，get_market_data函数于get_market_data_ex函数将会自动拼接本地历史行情与服务器实时行情



# 向服务器订阅数据

for i in code_list:

    xtdata.subscribe_quote(i,period=period,count=-1) # 设置count = -1来取到当天所有实时行情



# 等待订阅完成

time.sleep(1)



# 获取订阅后的行情

kline_data = xtdata.get_market_data_ex(,code_list,period=period)

print(kline_data)



# 获取订阅后的行情，并以固定间隔进行刷新,预期会循环打印10次

for i in range(10):

    # 这边做演示，就用for来循环了，实际使用中可以用while True

    kline_data = xtdata.get_market_data_ex(,code_list,period=period)

    print(kline_data)

    time.sleep(3) # 三秒后再次获取行情



# 如果不想用固定间隔触发，可以以用订阅后的回调来执行

# 这种模式下当订阅的callback回调函数将会异步的执行，每当订阅的标的tick发生变化更新，callback回调函数就会被调用一次

# 本地已有的数据不会触发callback

    

# 定义的回测函数

    ## 回调函数中，data是本次触发回调的数据，只有一条

def f(data):

    # print(data)

    

    code_list = list(data.keys())    # 获取到本次触发的标的代码



    kline_in_callabck = xtdata.get_market_data_ex(,code_list,period = period)    # 在回调中获取klines数据

    print(kline_in_callabck)



for i in code_list:

    xtdata.subscribe_quote(i,period=period,count=-1,callback=f) # 订阅时设定回调函数



# 使用回调时，必须要同时使用xtdata.run()来阻塞程序，否则程序运行到最后一行就直接结束退出了。

xtdata.run()

#coding:utf-8

import time, datetime, traceback, sys

from xtquant import xtdata

from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback

from xtquant.xttype import StockAccount

from xtquant import xtconstant



#定义一个类 创建类的实例 作为状态的容器

class _a():

    pass

A = _a()

A.bought_list = 

A.hsa = xtdata.get_stock_list_in_sector('沪深A股')



def interact():

    """执行后进入repl模式"""

    import code

    code.InteractiveConsole(locals=globals()).interact()

xtdata.download_sector_data()



def f(data):

    now = datetime.datetime.now()

    for stock in data:

        if stock not in A.hsa:

            continue

        cuurent_price = data[stock]['lastPrice']

        pre_price = data[stock]['lastClose']

        ratio = cuurent_price / pre_price - 1 if pre_price > 0 else 0

        if ratio > 0.09 and stock not in A.bought_list:

            print(f"{now} 最新价 买入 {stock} 200股")

            async_seq = xt_trader.order_stock_async(acc, stock, xtconstant.STOCK_BUY, 200, xtconstant.LATEST_PRICE, -1, 'strategy_name', stock)

            A.bought_list.append(stock)

    

class MyXtQuantTraderCallback(XtQuantTraderCallback):

    def on_disconnected(self):

        """

        连接断开

        :return:

        """

        print(datetime.datetime.now(),'连接断开回调')



    def on_stock_order(self, order):

        """

        委托回报推送

        :param order: XtOrder对象

        :return:

        """

        print(datetime.datetime.now(), '委托回调', order.order_remark)





    def on_stock_trade(self, trade):

        """

        成交变动推送

        :param trade: XtTrade对象

        :return:

        """

        print(datetime.datetime.now(), '成交回调', trade.order_remark)





    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)

        print(f"委托报错回调 {order_error.order_remark} {order_error.error_msg}")



    def on_cancel_error(self, cancel_error):

        """

        撤单失败推送

        :param cancel_error: XtCancelError 对象

        :return:

        """

        print(datetime.datetime.now(), sys._getframe().f_code.co_name)



    def on_order_stock_async_response(self, response):

        """

        异步下单回报推送

        :param response: XtOrderResponse 对象

        :return:

        """

        print(f"异步委托回调 {response.order_remark}")



    def on_cancel_order_stock_async_response(self, response):

        """

        :param response: XtCancelOrderResponse 对象

        :return:

        """

        print(datetime.datetime.now(), sys._getframe().f_code.co_name)



    def on_account_status(self, status):

        """

        :param response: XtAccountStatus 对象

        :return:

        """

        print(datetime.datetime.now(), sys._getframe().f_code.co_name)





if __name__ == '__main__':

    print("start")

    #指定客户端所在路径

    path = r'D:\qmt\sp3\迅投极速交易终端 睿智融科版\userdata_mini'

    # 生成session id 整数类型 同时运行的策略不能重复

    session_id = int(time.time())

    xt_trader = XtQuantTrader(path, session_id)

    # 开启主动请求接口的专用线程 开启后在on_stock_xxx回调函数里调用XtQuantTrader.query_xxx函数不会卡住回调线程，但是查询和推送的数据在时序上会变得不确定

    # 详见: http://docs.thinktrader.net/vip/pages/ee0e9b/#开启主动请求接口的专用线程

    # xt_trader.set_relaxed_response_order_enabled(True)



    # 创建资金账号为 800068 的证券账号对象

    acc = StockAccount('800068', 'STOCK')

    # 创建交易回调类对象，并声明接收回调

    callback = MyXtQuantTraderCallback()

    xt_trader.register_callback(callback)

    # 启动交易线程

    xt_trader.start()

    # 建立交易连接，返回0表示连接成功

    connect_result = xt_trader.connect()

    print('建立交易连接，返回0表示连接成功', connect_result)

    # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功

    subscribe_result = xt_trader.subscribe(acc)

    print('对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功', subscribe_result)



    #这一行是注册全推回调函数 包括下单判断 安全起见处于注释状态 确认理解效果后再放开

    # xtdata.subscribe_whole_quote(["SH", "SZ"], callback=f)

    # 阻塞主线程退出

    xt_trader.run_forever()

    # 如果使用vscode pycharm等本地编辑器 可以进入交互模式 方便调试 （把上一行的run_forever注释掉 否则不会执行到这里）

    interact()

def get_all_market_code(ContextInfo):



    all_market_codes = [item for item in ContextInfo.get_stock_list_in_sector('沪深A股') if not item.endswith('BJ')]

    return filter_ST_stock(ContextInfo, all_market_codes)

    

    

def filter_ST_stock(ContextInfo, code_list):

    result = []

    for code in code_list:

        if re.search('(st)|(ST)|(\*st)|(\*ST)|(退)',ContextInfo.get_stock_name(code)):

            print('排除 ： ',ContextInfo.get_stock_name(code),code)

            continue

        result.append(code)

    return result

    

global_dict = {}



def init(ContextInfo):

    now = time.ctime()

    print('策略初始化{}'.format(now))

    need_download = 1

    global_dict['start_date'] = '20231201'

    global_dict['end_date'] = ''

    global_dict['code_list'] = get_all_market_code(ContextInfo)

    

# coding:gbk

import time





class G():

    pass





g = G()





def init(ContextInfo):

    g.hsa = [item for item in ContextInfo.get_stock_list_in_sector('沪深A股') if not item.endswith('BJ')]

    g.vol_dict = {}

    for stock in g.hsa:

        g.vol_dict[stock] = ContextInfo.get_last_volume(stock)

    ContextInfo.run_time("execution", "1nSecond", "2019-10-14 13:20:00")





def execution(ContextInfo):

    t0 = time.time()

    full_tick = ContextInfo.get_full_tick(g.hsa)

    total_market_value = 0

    total_ratio = 0

    count = 0

    for stock in g.hsa:

        if full_tick[stock]['lastClose'] == 0:

            continue

        ratio = full_tick[stock]['lastPrice'] / full_tick[stock]['lastClose'] - 1

        rise_price = round(full_tick[stock]['lastClose'] * 1.2, 2) if stock[0] == '3' or stock[:3] == '688' else round(

            full_tick[stock]['lastClose'] * 1.1, 2)

        # 如果要打印涨停品种

        if abs(full_tick[stock]['lastPrice'] - rise_price) <0.01:

            print(f"涨停股票 {stock} {ContextInfo.get_stock_name(stock)}")



        market_value = full_tick[stock]['lastPrice'] * g.vol_dict[stock]

        total_ratio += ratio * market_value

        total_market_value += market_value

        count += 1

    # print(count)

    total_ratio /= total_market_value

    total_ratio *= 100

    print(f'A股加权涨幅 {round(total_ratio, 2)}% 函数运行耗时{round(time.time() - t0, 5)}秒')

#-*-coding:gbk-*-

import datetime

code = '838402.BJ'

def init(ContextInfo):

    now = datetime.datetime.now()

    print(now)



def handlebar(ContextInfo):

    index = ContextInfo.barpos

    realtime = ContextInfo.get_bar_timetag(index)

    date = timetag_to_datetime(realtime, "%Y-%m-%d %H:%M:%S")

    info = ContextInfo.get_full_tick(stock_code=["838402.BJ"])

    print(info)

#-*-coding:gbk-*-

import datetime



code = '838402.BJ'

def init(ContextInfo):

    now = datetime.datetime.now()

    print(now)

    download_history_data(code,"1d","20240105","")



def handlebar(ContextInfo):

    index = ContextInfo.barpos

    realtime = ContextInfo.get_bar_timetag(index)

    date = timetag_to_datetime(realtime, "%Y-%m-%d %H:%M:%S")

    print(date)

    hist = ContextInfo.get_market_data_ex(['close'],[code], period = "1d",count = 1)

    print(hist)

class a():

	pass

A = a()

class A():

	pass

a = A()

class GlobalCls():

    pass

    

g = GlobalCls()

文件编码声明： #coding:gbk 是指定源文件的编码格式为GBK。在Python 3中，通常使用UTF-8作为文件编码格式，因此可以将该行删除或更改为#coding:utf-8。



类名和函数名： 根据PEP 8命名约定，类名应该使用大写字母开头的驼峰命名法（例如A改为A）。同样，函数名应该使用小写字母开头的小写命名法（例如init改为init，f改为f）。



类和实例： 在代码中定义了一个空类a，但没有给它任何属性或方法。如果不需要这个类，可以将其删除。



缩进和代码格式： Python非常依赖于正确的缩进，以指示代码块的层次结构。请确保代码的缩进是一致的，并使用适当的缩进级别（通常是4个空格）。



代码注释： 代码中有一些注释，但是大部分是被注释掉的。良好的注释可以增加代码的可读性和可维护性，建议在关键部分添加更多有用的注释。



异常处理： 代码中没有包含任何异常处理机制。在实际应用中，建议对可能引发异常的操作进行适当的异常处理，以提高代码的健壮性。

		rise_price = round(full_tick[stock]['lastClose'] *1.2,2) if stock[0] == '3' or stock[:3] == '688' else round(full_tick[stock]['lastClose'] *1.1,2)

#-*-coding:gbk-*-

import time

start = False

ACCOUNT = ''



def init(ContextInfo):

    now = time.ctime()

    print(now)

    ContextInfo.run_time("execution","30nSecond","2023-04-14 13:20:00")





def execution(ContextInfo):

    data = ContextInfo.get_stock_list_in_sector('沪深A股')

    print(len(data))



def handlebar(ContextInfo):

    pass

【2023-10-25 15:18:45.533】  start trading mode

【2023-10-25 15:18:45.533】  Wed Oct 25 15:18:45 2023



【2023-10-25 15:18:45.533】  5074

['000001.SZ', '000002.SZ', '000004.SZ', '000005.SZ', '000006.SZ', '000007.SZ', '000008.SZ', '000009.SZ', '000010.SZ', '000011.SZ', '000012.SZ', '000014.SZ', '000016.SZ', '000017.SZ', '000019.SZ', '000020.SZ', '000021.SZ', '000023.SZ', '000025.SZ', '000026.SZ', '000027.SZ', '000028.SZ', '000029.SZ', '000030.SZ', '000031.SZ', '000032.SZ', '000034.SZ', '000035.SZ', '000036.SZ', '000037.SZ', '000039.SZ', '000040.SZ', '000042.SZ', '000045.SZ', '000046.SZ', '000048.SZ', '000049.SZ', '000050.SZ', '000055.SZ', '000056.SZ', '000058.SZ', '000059.SZ', '000060.SZ', '000061.SZ', '000062.SZ', '000063.SZ', '000065.SZ', '000066.SZ', '000068.SZ', '000069.SZ', '000070.SZ', '000078.SZ', '000088.SZ', '000089.SZ', '000090.SZ', '000096.SZ', '000099.SZ', '000100.SZ', '000151.SZ', '000153.SZ', '000155.SZ', '000156.SZ', '000157.SZ', '000158.SZ', '000159.SZ', '000166.SZ', '000301.SZ', '000333.SZ', '000338.SZ', '000400.SZ', '000401.SZ', '000402.SZ', '000403.SZ', '000404.SZ', '000407.SZ', '000408.SZ', '000409.SZ', '000410.SZ', '000411.SZ', '000413.SZ', '000415.SZ', '000416.SZ', '000417.SZ', '000419.SZ', '000420.SZ', '000421.SZ', '000422.SZ', '000423.SZ', '000425.SZ', '000426.SZ',

from xtquant import xtdata

data = xtdata.get_market_data(field_list=['time', 'open', 'close', 'high', 'low', 'volume', 'amount'], stock_list=['603000.SH'], period='1d', start_time='20230101')

print(data)

量化新人用QMT+chat GPT快速上手量化策略（一）QMT基础介绍



量化新人用QMT+chat GPT快速上手量化策略（二）QMT均线盘后选股



量化新人用QMT+chat GPT快速上手量化策略（三）一个基本的回测策略代码



量化新人用QMT+chat GPT快速上手量化策略（四） QMT运行一个策略的整体流程



量化新人用QMT+chat GPT快速上手量化策略（五）  获取股票数据



量化新人用QMT+chat GPT快速上手量化策略（六） tablib计算指标



量化新人用QMT+chat GPT快速上手量化策略（七） 下单代码编写

def init(ContextInfo):

    ContextInfo.run_time('execution', '3nSecond', '2019-10-14 13:20:00',)



def execution(ContextInfo):

    if not ContextInfo.is_last_bar():

        return

    data = ContextInfo.get_market_data_ex(

        [], ['123136.SZ'], period='tick'

        , start_time='', end_time='', count=1

        , dividend_type='follow', fill_data=True

        , subscribe=True)

    print(data)

    

    

def handlebar(ContextInfo):

    #计算当前主图的cci

    pass

m_strAccountID: 资金账号，账号，账号，资金账号



m_strExchangeID: 证券市场



m_strExchangeName: 交易市场



m_strProductID: 品种代码



m_strProductName: 品种名称



m_strInstrumentID: 证券代码



m_strInstrumentName: 证券名称，合约名称



m_strOrderRef: 内部委托号，下单引用等于股票的内部委托号



m_nOrderPriceType: EBrokerPriceType 类型，例如市价单、限价单



m_nDirection: EEntrustBS 类型，操作，多空，期货多空，股票买卖永远是 48，其他的 dir 同理



m_nOffsetFlag: EOffset_Flag_Type类型，买卖/开平，用此字段区分股票买卖，期货开、平仓，期权买卖等



m_nHedgeFlag: EHedge_Flag_Type 类型，投保



m_dLimitPrice: 委托价格,限价单的限价，就是报价



m_nVolumeTotalOriginal: 委托量，最初委托量



m_nOrderSubmitStatus: EEntrustSubmitStatus 类型，报单状态，提交状态，股票中不需要报单状态



m_strOrderSysID: 合同编号，委托号



m_nOrderStatus: EEntrustStatus，委托状态



m_nVolumeTraded: 成交数量，已成交量



m_nVolumeTotal: 委托剩余量，当前总委托量，股票的含义是总委托量减去成交量



m_nErrorID: 状态信息



m_strErrorMsg: 状态信息



m_nTaskId：任务号



m_dFrozenMargin: 冻结金额，冻结保证金



m_dFrozenCommission: 冻结手续费



m_strInsertDate: 委托日期，报单日期



m_strInsertTime: 委托时间



m_dTradedPrice: 成交均价（股票）



m_dCancelAmount: 已撤数量



m_strOptName: 买卖标记，展示委托属性的中文



m_dTradeAmount: 成交金额，成交额，期货 = 均价 * 量 * 合约乘数



m_eEntrustType: EEntrustTypes，委托类别



m_strCancelInfo: 废单原因



m_strUnderCode: 标的证券代码



m_eCoveredFlag: ECoveredFlag，备兑标记 '0' - 非备兑，'1' - 备兑



m_dOrderPriceRMB: 委托价格（人民币），目前用于港股通



m_dTradeAmountRMB: 成交金额（人民币），目前用于港股通



m_dReferenceRate: 汇率，目前用于港股通



m_strCompactNo: 合约编号



m_eCashgroupProp: EXTCompactBrushSource类型，头寸来源



m_dShortOccupedMargin: 预估在途占用保证金，用于期权



m_strXTTrade: 是否是迅投交易



m_strAccountKey: 账号key，唯一区别不同账号的key



m_strRemark：投资备注

attr EBrokerPriceType value  <class 'EBrokerPriceType'>

attr ECoveredFlag value  <class 'ECoveredFlag'>

attr EEntrustBS value  <class 'EEntrustBS'>

attr EEntrustStatus value  <class 'EEntrustStatus'>

attr EEntrustSubmitStatus value  <class 'EEntrustSubmitStatus'>

attr EEntrustTypes value  <class 'EEntrustTypes'>

attr EFutureTradeType value  <class 'EFutureTradeType'>

attr EHedge_Flag_Type value  <class 'EHedge_Flag_Type'>

attr EOffset_Flag_Type value  <class 'EOffset_Flag_Type'>

attr ESideFlag value  <class 'ESideFlag'>

attr EXTCompactBrushSource value  <class 'EXTCompactBrushSource'>

attr EXTCompactStatus value  <class 'EXTCompactStatus'>

attr EXTCompactType value  <class 'EXTCompactType'>

attr EXTSloTypeQueryMode value  <class 'EXTSloTypeQueryMode'>

attr EXTSubjectsStatus value  <class 'EXTSubjectsStatus'>

attr __class__ value  <class 'COrderDetail'>

attr __delattr__ value  <method-wrapper '__delattr__' of COrderDetail object at 0x000000004AD59A60>

attr __dict__ value  {}

attr __dir__ value  <built-in method __dir__ of COrderDetail object at 0x000000004AD59A60>

attr __doc__ value  None

attr __eq__ value  <method-wrapper '__eq__' of COrderDetail object at 0x000000004AD59A60>

attr __format__ value  <built-in method __format__ of COrderDetail object at 0x000000004AD59A60>

attr __ge__ value  <method-wrapper '__ge__' of COrderDetail object at 0x000000004AD59A60>

attr __getattribute__ value  <method-wrapper '__getattribute__' of COrderDetail object at 0x000000004AD59A60>

attr __gt__ value  <method-wrapper '__gt__' of COrderDetail object at 0x000000004AD59A60>

attr __hash__ value  <method-wrapper '__hash__' of COrderDetail object at 0x000000004AD59A60>

attr __init__ value  <bound method __init__ of <COrderDetail object at 0x000000004AD59A60>>

attr __init_subclass__ value  <built-in method __init_subclass__ of Boost.Python.class object at 0x0000000044C55368>

attr __instance_size__ value  1088

attr __le__ value  <method-wrapper '__le__' of COrderDetail object at 0x000000004AD59A60>

attr __lt__ value  <method-wrapper '__lt__' of COrderDetail object at 0x000000004AD59A60>

attr __ne__ value  <method-wrapper '__ne__' of COrderDetail object at 0x000000004AD59A60>

attr __new__ value  <built-in method __new__ of Boost.Python.class object at 0x000007FEDCF525C0>

attr __reduce__ value  <bound method <unnamed Boost.Python function> of <COrderDetail object at 0x000000004AD59A60>>

attr __reduce_ex__ value  <built-in method __reduce_ex__ of COrderDetail object at 0x000000004AD59A60>

attr __repr__ value  <method-wrapper '__repr__' of COrderDetail object at 0x000000004AD59A60>

attr __setattr__ value  <method-wrapper '__setattr__' of COrderDetail object at 0x000000004AD59A60>

attr __sizeof__ value  <built-in method __sizeof__ of COrderDetail object at 0x000000004AD59A60>

attr __str__ value  <method-wrapper '__str__' of COrderDetail object at 0x000000004AD59A60>

attr __subclasshook__ value  <built-in method __subclasshook__ of Boost.Python.class object at 0x0000000044C55368>

attr __weakref__ value  None

attr j value  j

attr m_bEnable value  True

attr m_dCancelAmount value  0.0

attr m_dFrozenCommission value  0.15

attr m_dFrozenMargin value  1000.0

attr m_dLimitPrice value  2.3

用法： ContextInfo.get_market_data(fields, stock_code = , start_time = '', 

end_time = '', skip_paused = True, period = 'follow', 

dividend_type = 'follow', count = -1)

open -- 开盘价(str:numpy.float64)；

high -- 最高价(str:numpy.float64)；

low --最低价(str:numpy.float64)；

close -- 收盘价(str:numpy.float64)；

volume -- 交易量(str:numpy.float64)；

money -- 交易金额(str:numpy.float64)；

price -- 最新价(str:numpy.float64)；

preclose -- 昨收盘价(str:numpy.float64)(仅日线返回)；

high_limit -- 涨停价(str:numpy.float64)(仅日线返回)；

low_limit -- 跌停价(str:numpy.float64)(仅日线返回)；

unlimited -- 判断查询日是否无涨跌停限制(1：该日无涨跌停限制；0：该日有涨跌停限制)(str:numpy.float64)(仅日线返回)；

import pandas as pd

import datetime





def get_tick(code, start_time, end_time, period='tick'):

    from xtquant import xtdata



    xtdata.download_history_data(code, period=period, start_time=start_time, end_time=end_time)

    data = xtdata.get_local_data(field_list=, stock_code=

, period=period, count=10)

    result_list = data

    df = pd.DataFrame(result_list)



    df['time_str'] = df['time'].apply(lambda x: datetime.datetime.fromtimestamp(x / 1000.0))

    return df





def process_timestamp(df, filename):

    df = df.set_index('time_str')

    result = df.resample('3S').first().ffill()

    # result = result[(result.index >= '2022-07-20 09:30') & (result.index <= '2022-07-20 15:00')]

    result = result.reset_index()

    result.to_csv(filename + '.csv')





def dump_single_code_tick():

    # 导出单个转债的tick数据

    code='128022'

    start_date = '20210113'

    end_date = '20210130'



    post_fix = 'SZ' if code.startswith('12') else 'SH'

    code = '{}.{}'.format(code,post_fix)

    filename = '{}'.format(code)

    df = get_tick(code, start_date, end_date)

    process_timestamp(df, filename)



dump_single_code_tick()

    obj_list = get_trade_detail_data(ACCOUNT,'stock','position')

    for obj in obj_list:

        print(obj.m_strInstrumentID,obj.m_strInstrumentName,'----')

        # 查看有哪些属性字段

        print('='*10)

        for item in dir(obj):

            if not item.startswith('__'):

                print(item)

                

        print('='*10)

m_bIsToday

m_dAvgOpenPrice

m_dCloseAmount

m_dCloseProfit

m_dFloatProfit

m_dInstrumentValue

m_dLastPrice

m_dLastSettlementPrice

m_dMargin

m_dMarketValue

m_dOpenCost

m_dOpenPrice

m_dPositionCost

m_dPositionProfit

m_dProfitRate

m_dRealUsedMargin

m_dRedemptionVolume

m_dReferenceRate

m_dRoyalty

m_dSettlementPrice

m_dSingleCost

m_dStaticHoldMargin

m_dStockLastPrice

m_dStructFundVol

m_dTotalCost

m_eFutureTradeType

m_eSideFlag

m_nCanUseVolume

m_nCidIncrease

m_nCidIsDelist

m_nCidRateOfCurrentLine

m_nCidRateOfTotalValue

m_nCloseVolume

m_nCoveredVolume

m_nDirection

m_nEnableExerciseVolume

m_nFrozenVolume

m_nHedgeFlag

m_nLegId

m_nOnRoadVolume

m_nOptCombUsedVolume

m_nPREnableVolume

m_nVolume

m_nYesterdayVolume

m_strAccountID

m_strAccountKey

m_strComTradeID

m_strExchangeID

m_strExchangeName

m_strExpireDate

m_strInstrumentID

m_strInstrumentName

m_strOpenDate

m_strProductID

m_strProductName

m_strStockHolder

m_strTradeID

m_strTradingDay

m_xtTag