tqsdk.TqApi - 框架及核心业务

class tqsdk.TqApi(account: TqMultiAccount | TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None, auth: TqAuth | str | None = None, url: str | None = None, backtest: TqBacktest | TqReplay | None = None, web_gui: bool | str = False, debug: bool | str | None = None, loop: AbstractEventLoop | None = None, disable_print: bool = False, _stock: bool = True, _ins_url=None, _md_url=None, _td_url=None)

天勤接口及数据管理类

通常情况下, 一个线程中 应该只有一个 TqApi的实例, 它负责维护网络连接, 接收行情及账户数据, 并在内存中维护业务数据截面

创建天勤接口实例

Args:
account (None/TqAccount/TqKq/TqKqStock/TqSim/TqSimStock/TqZq/TqMultiAccount): [可选]交易账号:

  • None: 账号将根据环境变量决定, 默认为 TqSim

  • TqAccount : 使用实盘账号, 直连行情和交易服务器, 需提供期货公司/帐号/密码

  • TqKq : 使用快期账号登录，直连行情和快期模拟交易服务器

  • TqKqStock : 使用快期账号登录，直连行情和快期股票模拟交易服务器

  • TqSim : 使用 TqApi 自带的内部模拟账号

  • TqSimStock : 使用 TqApi 自带的内部股票模拟账号

  • TqZq : 使用众期账号

  • TqCtp : 使用直连 CTP 账号

  • TqRohon : 使用融航资管账号

  • TqJees : 使用杰宜斯资管账号

  • TqYida : 使用易达账号

  • TqMultiAccount : 多账户列表，列表中支持 TqAccount、TqKq、TqKqStock、 TqSim、TqSimStock、TqZq、TqRohon、TqJees、 TqYida 和 TqCtp 中的 0 至 N 个或者组合

auth (TqAuth/str): [必填]用户快期账户:
url (str): [可选]指定服务器的地址

  • 当 account 为 TqAccount、TqKq、TqKqStock 类型时, 可以通过该参数指定交易服务器地址, 默认使用对应账户的交易服务地址，行情地址使用快期账户对应的行情服务地址

  • 当 account 为 TqSim、TqSimStock 类型时, 可以通过该参数指定行情服务器地址, 默认使用快期账户对应的行情服务地址

backtest (TqBacktest): [可选] 进入时光机，此时强制要求 account 类型为 TqSim 或 TqSimStock

  • TqBacktest : 传入 TqBacktest 对象，进入回测模式 在回测模式下, TqBacktest 连接 wss://backtest.shinnytech.com/t/md/front/mobile 接收行情数据, 由 TqBacktest 内部完成回测时间段内的行情推进和 K 线、Tick 更新.

debug(bool/str): [可选] 是否将调试信息输出到指定文件，默认值为 None。

  • None [默认]: 根据账户情况不同，默认值的行为不同。

    • 仅有本地模拟账户 TqSim、TqSimStock 时，调试信息不输出。

    • 当有其他类型账户时，即 TqAccount、TqKq、TqKqStock， 调试信息输出到指定文件夹 `~/.tqsdk/logs`（如果磁盘剩余空间不足 10G 则不会输出调试信息）。

  • True: 调试信息会输出到指定文件夹 ~/.tqsdk/logs。

  • False: 不输出调试信息。

  • str: 指定一个日志文件名, 调试信息输出到指定文件。

disable_print(bool): [可选] 是否隐藏提示信息，默认值为 False

  • False [默认]: 打印提示信息。

  • True: 隐藏提示信息。

    • 提示信息会输出到标准输出流，即 sys.stdout，标准输出流默认指向控制台。

loop(asyncio.AbstractEventLoop): [可选] 使用指定的 IOLoop, 默认创建一个新的.

web_gui(bool/str): [可选]是否启用图形化界面功能, 默认不启用.

  • 启用图形化界面传入参数 web_gui=True 会每次以随机端口生成网页，也可以直接设置本机IP和端口 web_gui=[ip]:port 为网页地址， ip 可选，默认为 0.0.0.0，参考example 6

  • 为了图形化界面能够接收到程序传输的数据并且刷新，在程序中，需要循环调用 api.wait_update的形式去更新和获取数据

  • 推荐打开图形化界面的浏览器为Google Chrome 或 Firefox

Example1:

# 使用实盘帐号直连行情和交易服务器
from tqsdk import TqApi, TqAuth, TqAccount
api = TqApi(TqAccount("H海通期货", "022631", "123456"), auth=TqAuth("快期账户", "账户密码"))

Example2:

# 使用快期模拟帐号连接行情服务器
from tqsdk import TqApi, TqAuth, TqKq
api = TqApi(TqKq(), auth=TqAuth("快期账户", "账户密码"))  # 根据填写的快期账户参数连接指定的快期模拟账户

Example3:

# 使用模拟帐号直连行情服务器
from tqsdk import TqApi, TqAuth, TqSim
api = TqApi(TqSim(), auth=TqAuth("快期账户", "账户密码"))  # 不填写参数则默认为 TqSim() 模拟账号

Example4:

# 进行策略回测
from datetime import date
from tqsdk import TqApi, TqAuth, TqBacktest
api = TqApi(backtest=TqBacktest(start_dt=date(2018, 5, 1), end_dt=date(2018, 10, 1)), auth=TqAuth("快期账户", "账户密码"))

Example5:

# 进行策略复盘
from datetime import date
from tqsdk import TqApi, TqAuth, TqReplay
api = TqApi(backtest=TqReplay(replay_dt=date(2019, 12, 16)), auth=TqAuth("快期账户", "账户密码"))

Example6:

# 开启 web_gui 功能，使用默认参数True
from tqsdk import TqApi, TqAuth
api = TqApi(web_gui=True, auth=TqAuth("快期账户", "账户密码"))

Example7:

# 开启 web_gui 功能，使用本机IP端口固定网址生成
from tqsdk import TqApi, TqAuth
api = TqApi(web_gui=":9876", auth=TqAuth("快期账户", "账户密码"))  # 等价于 api = TqApi(web_gui="0.0.0.0:9876", auth=TqAuth("快期账户", "账户密码"))
copy() → TqApi

创建当前TqApi的一个副本. 这个副本可以在另一个线程中使用

Returns:

TqApi: 返回当前TqApi的一个副本. 这个副本可以在另一个线程中使用

close() → None

关闭天勤接口实例并释放相应资源

Example:

# m1901开多3手
from tqsdk import TqApi, TqAuth
from contextlib import closing

with closing(TqApi(auth=TqAuth("快期账户", "账户密码")) as api:
    api.insert_order(symbol="DCE.m1901", direction="BUY", offset="OPEN", volume=3)
get_quote(symbol: str) → Quote

获取指定合约的盘口行情.

Args:

symbol (str): 指定合约代码。

Returns:

Quote: 返回一个盘口行情引用. 其内容将在 wait_update() 时更新.

注意: 1. 在 tqsdk 还没有收到行情数据包时, 此对象中各项内容为 NaN 或 0 2. 天勤接口从0.8版本开始，合约代码格式变更为 交易所代码.合约代码 的格式. 可用的交易所代码如下：

  • CFFEX: 中金所

  • SHFE: 上期所

  • DCE: 大商所

  • CZCE: 郑商所

  • INE: 能源交易所(原油)

  • SSE: 上交所

  • SZSE: 深交所

  • GFEX: 广期所

Example1:

# 获取 SHFE.cu1812 合约的报价
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu1812")
print(quote.last_price)
while api.wait_update():
    print(quote.last_price)

# 预计的输出是这样的:
nan
24575.0
24575.0
...

Example2:

# 协程示例，为每个合约创建 task
from tqsdk import TqApi, TqAuth

async def demo(SYMBOL):
    quote = await api.get_quote(SYMBOL)  # 支持 await 异步，这里会订阅合约，等到收到合约行情才返回
    print(f"quote: {SYMBOL}", quote.datetime, quote.last_price)  # 这一行就会打印出合约的最新行情
    async with api.register_update_notify() as update_chan:
        async for _ in update_chan:
            if api.is_changing(quote):
                print(SYMBOL, quote.datetime, quote.last_price)
            # ... 策略代码 ...

api = TqApi(auth=TqAuth("快期账户", "账户密码"))

symbol_list = ["SHFE.rb2107", "DCE.m2109"]  # 设置合约代码
for symbol in symbol_list:
    api.create_task(demo(symbol))  # 为每个合约创建异步任务

while True:
    api.wait_update()
get_quote_list(symbols: List[str]) → QuoteList

获取指定合约列表的盘口行情.

Args:

symbols (list of str): 合约代码列表

Returns:

list of Quote: 返回一个列表，每个元素为指定合约盘口行情引用。

注意: 1. 在 tqsdk 还没有收到行情数据包时, 此对象中各项内容为 NaN 或 0 2. 天勤接口从0.8版本开始，合约代码格式变更为 交易所代码.合约代码 的格式. 可用的交易所代码如下：

  • CFFEX: 中金所

  • SHFE: 上期所

  • DCE: 大商所

  • CZCE: 郑商所

  • INE: 能源交易所(原油)

  • SSE: 上交所

  • SZSE: 深交所

  • GFEX: 广期所

Example:

# 获取 SHFE.cu1812 合约的报价
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote_list = api.get_quote_list(["SHFE.cu2105", "SHFE.cu2112"])
print(quote_list[0].last_price, quote_list[1].last_price)
while api.wait_update():
    print(quote_list[0].last_price, quote_list[1].last_price)

# 预计的输出是这样的:
24575.0 24545.0
24575.0 24545.0
...
get_trading_status(symbol: str) → TradingStatus

获取指定合约的交易状态，便于实现开盘抢单功能。

Args:

symbol (str): 合约代码

Returns:

TradingStatus: 返回指定合约交易状态引用。

Example:

# 在集合竞价时下单
from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
ts = api.get_trading_status("SHFE.cu2201")
print(ts.trade_status)
while True:
  api.wait_update()
  if ts.trade_status == "AUCTIONORDERING":
    order = api.insert_order("SHFE.cu2201","BUY","OPEN", 1, 71400)
    break
# insert_order指令会在下一次wait_update()发出
api.wait_update()
api.close()
get_kline_serial(symbol: str | List[str], duration_seconds: int, data_length: int = 200, adj_type: str | None = None, **kwargs) → DataFrame

获取k线序列数据

请求指定合约及周期的K线数据. 序列数据会随着时间推进自动更新

Args:
symbol (str/list of str): 指定合约代码或合约代码列表.

  • str: 一个合约代码

  • list of str: 合约代码列表 （一次提取多个合约的K线并根据相同的时间向第一个合约（主合约）对齐)

duration_seconds (int): K线数据周期, 以秒为单位。例如: 1分钟线为60,1小时线为3600,日线为86400。 注意: 周期在日线以内时此参数可以任意填写, 在日线以上时只能是日线(86400)的整数倍, 最大为28天 (86400*28)。

data_length (int): 需要获取的序列长度。默认200根, 返回的K线序列数据是从当前最新一根K线开始往回取data_length根。 每个序列最大支持请求 10000 个数据

adj_type (str/None): [可选]指定复权类型，默认为 None。adj_type 参数只对股票和基金类型合约有效。 "F" 表示前复权；"B" 表示后复权；None 表示不做处理。

chart_id (str): [Deprecated] 由 api 自动生成，此参数不再使用

**获取后的 kline 对象请不要修改/重命名原始的 kline 序列，可能会导致后续的 kline 数据不更新 **

注：关于传入合约代码列表 获取多合约K线的说明：

  1. 主合约的字段名为原始K线数据字段，从第一个副合约开始，字段名在原始字段后加数字，如第一个副合约的开盘价为 "open1" , 第二个副合约的收盘价为 "close2"。

  2. 每条K线都包含了订阅的所有合约数据，即：如果任意一个合约（无论主、副）在某个时刻没有数据（即使其他合约在此时有数据）, 则不能对齐，此多合约K线在该时刻那条数据被跳过，现象表现为K线不连续（如主合约有夜盘，而副合约无夜盘，则生成的多合约K线无夜盘时间的数据）。

  3. 若设置了较大的序列长度参数，而所有可对齐的数据并没有这么多，则序列前面部分数据为NaN（这与获取单合约K线且数据不足序列长度时情况相似）。

  4. 若主合约与副合约的交易时间在所有合约数据中最晚一根K线时间开始往回的 10000*周期 时间段内完全不重合，则无法生成多合约K线，程序会报出获取数据超时异常。

  5. datetime、duration是所有合约公用的字段，则未单独为每个副合约增加一份副本，这两个字段使用原始字段名（即没有数字后缀）。

  6. 暂不支持复权 获取多合约K线，若填入 adj_type，程序会报参数错误。

Returns:

pandas.DataFrame: 本函数总是返回一个 pandas.DataFrame 实例. 行数=data_length, 包含以下列:

  • id: 1234 (k线序列号)

  • datetime: 1501080715000000000 (K线起点时间(按北京时间)，自unix epoch(1970-01-01 00:00:00 GMT)以来的纳秒数)

  • open: 51450.0 (K线起始时刻的最新价)

  • high: 51450.0 (K线时间范围内的最高价)

  • low: 51450.0 (K线时间范围内的最低价)

  • close: 51450.0 (K线结束时刻的最新价)

  • volume: 11 (K线时间范围内的成交量)

  • open_oi: 27354 (K线起始时刻的持仓量)

  • close_oi: 27355 (K线结束时刻的持仓量)

Example1:

# 获取 SHFE.cu1812 的1分钟线
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("SHFE.cu1812", 60)
print(klines.iloc[-1].close)
while True:
    api.wait_update()
    print(klines.iloc[-1].close)

# 预计的输出是这样的:
50970.0
50970.0
50960.0
...

Example2:

# 获取按时间对齐的多合约K线
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
# 获取 CFFEX.IF1912 按照K线时间向 SHFE.au2006 对齐的K线
klines = api.get_kline_serial(["SHFE.au2006", "CFFEX.IF2006"], 5, data_length=10)
print("多合约K线：", klines.iloc[-1])
while True:
    api.wait_update()
    if api.is_changing(klines.iloc[-1], ["close1", "close"]):  # 判断任何一个收盘价是否有更新
        dif = klines.close1 - klines.close  # 使用对齐的K线直接计算价差等数据
        print("价差序列：", dif)

Example3:

# 使用tqsdk自带的时间转换函数, 将最后一根K线的纳秒时间转换为 datetime.datetime 类型
from tqsdk import tafunc
...

klines = api.get_kline_serial("DCE.jd2001", 10)
kline_time = tafunc.time_to_datetime(klines.iloc[-1]["datetime"])  # datetime.datetime 类型值
print(type(kline_time), kline_time)
print(kline_time.year, kline_time.month, kline_time.day, kline_time.hour, kline_time.minute, kline_time.second)
...
get_tick_serial(symbol: str, data_length: int = 200, adj_type: str | None = None, **kwargs) → DataFrame

获取tick序列数据

请求指定合约的Tick序列数据. 序列数据会随着时间推进自动更新

Args:

symbol (str): 指定合约代码.

data_length (int): 需要获取的序列长度。每个序列最大支持请求 10000 个数据

adj_type (str/None): [可选]指定复权类型，默认为 None。adj_type 参数只对股票和基金类型合约有效。 "F" 表示前复权；"B" 表示后复权；None 表示不做处理。

chart_id (str): [Deprecated] 由 api 自动生成，此参数不再使用

Returns:

pandas.DataFrame: 本函数总是返回一个 pandas.DataFrame 实例. 行数=data_length, 包含以下列:

  • id: 12345 tick序列号

  • datetime: 1501074872000000000 (tick从交易所发出的时间(按北京时间)，自unix epoch(1970-01-01 00:00:00 GMT)以来的纳秒数)

  • last_price: 3887.0 (最新价)

  • average: 3820.0 (当日均价)

  • highest: 3897.0 (当日最高价)

  • lowest: 3806.0 (当日最低价)

  • ask_price1: 3886.0 (卖一价)

  • ask_volume1: 3 (卖一量)

  • bid_price1: 3881.0 (买一价)

  • bid_volume1: 18 (买一量)

  • volume: 7823 (当日成交量)

  • amount: 19237841.0 (成交额)

  • open_interest: 1941 (持仓量)

Example:

# 获取 SHFE.cu1812 的Tick序列
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
serial = api.get_tick_serial("SHFE.cu1812")
while True:
    api.wait_update()
    print(serial.iloc[-1].bid_price1, serial.iloc[-1].ask_price1)

# 预计的输出是这样的:
50860.0 51580.0
50860.0 51580.0
50820.0 51580.0
...
get_kline_data_series(symbol: str | List[str], duration_seconds: int, start_dt: date | datetime, end_dt: date | datetime, adj_type: str | None = None) → DataFrame

获取指定时间段内的 K 线序列，TqSdk 会缓存已经下载过的合约，提升代码执行效率、节约请求流量。

本接口仅限专业版用户使用，如需购买专业版或者申请试用，请访问 https://www.shinnytech.com/tqsdk-buy/。

该函数返回的对象不会更新，不建议在循环内调用该方法。

Args:

symbol (str): 指定合约代码。当前只支持单个合约。

duration_seconds (int): K 线数据周期, 以秒为单位。例如: 1 分钟线为 60，1 小时线为 3600，日线为 86400。 注意: 周期在日线以内时此参数可以任意填写, 在日线以上时只能是日线(86400)的整数倍

start_dt (date/datetime): 起始时间

  • date: 指的是交易日

  • datetime: 指的是具体时间点，如果没有指定时区信息，则默认为北京时间

end_dt (date/datetime): 结束时间

  • date: 指的是交易日

  • datetime: 指的是具体时间点，如果没有指定时区信息，则默认为北京时间

adj_type (str/None): [可选]指定复权类型，默认为 None。adj_type 参数只对股票和基金类型合约有效。 "F" 表示前复权；"B" 表示后复权；None 表示不做处理。

Returns:

pandas.DataFrame: 本函数总是返回一个 pandas.DataFrame 实例。包含以下列:

  • id: 1234 (k线序列号)

  • datetime: 1501080715000000000 (K线起点时间(按北京时间)，自unix epoch(1970-01-01 00:00:00 GMT)以来的纳秒数)

  • open: 51450.0 (K线起始时刻的最新价)

  • high: 51450.0 (K线时间范围内的最高价)

  • low: 51450.0 (K线时间范围内的最低价)

  • close: 51450.0 (K线结束时刻的最新价)

  • volume: 11 (K线时间范围内的成交量)

  • open_oi: 27354 (K线起始时刻的持仓量)

  • close_oi: 27355 (K线结束时刻的持仓量)

Example:

# 获取 SHFE.cu1805 合约 20180101-06:00:00 ~ 20180601-16:00:00 的 1 分钟线
from tqsdk import TqApi, TqAuth
from tqsdk.ta import MA, MACD

api = TqApi(auth=TqAuth("快期账户", "账户密码"))

kline_data = api.get_kline_data_series(symbol = "SHFE.cu1805", duration_seconds=60,
            start_dt = datetime(2018, 1, 1, 6, 0, 0), end_dt = datetime(2018, 6, 1, 16, 0, 0))
print(kline_data)

ma = MA(kline_data, 30)  # 计算 MA 指标
print(list(ma["ma"]))

macd = MACD(kline_data, 12, 26, 9)  # 计算 MACD 指标
print(list(macd["diff"]))
print(list(macd["dea"]))
print(list(macd["bar"]))

api.close()
get_tick_data_series(symbol: str | List[str], start_dt: date | datetime, end_dt: date | datetime, adj_type: str | None = None) → DataFrame

获取指定时间段内的 tick 序列，TqSdk 会缓存已经下载过的合约，提升代码执行效率、节约请求流量。

本接口仅限专业版用户使用，如需购买专业版或者申请试用，请访问 https://www.shinnytech.com/tqsdk-buy/。

该函数返回的对象不会更新，不建议在循环内调用该方法。

Args:

symbol (str): 指定合约代码。当前只支持单个合约。

start_dt (date/datetime): 起始时间

  • date: 指的是交易日

  • datetime: 指的是具体时间点，如果没有指定时区信息，则默认为北京时间

end_dt (date/datetime): 结束时间

  • date: 指的是交易日

  • datetime: 指的是具体时间点，如果没有指定时区信息，则默认为北京时间

adj_type (str/None): [可选]指定复权类型，默认为 None。adj_type 参数只对股票和基金类型合约有效。 "F" 表示前复权；"B" 表示后复权；None 表示不做处理。

Returns:

pandas.DataFrame: 本函数总是返回一个 pandas.DataFrame 实例。包含以下列:

  • id: 12345 tick序列号

  • datetime: 1501074872000000000 (tick从交易所发出的时间(按北京时间)，自unix epoch(1970-01-01 00:00:00 GMT)以来的纳秒数)

  • last_price: 3887.0 (最新价)

  • average: 3820.0 (当日均价)

  • highest: 3897.0 (当日最高价)

  • lowest: 3806.0 (当日最低价)

  • ask_price1: 3886.0 (卖一价)

  • ask_volume1: 3 (卖一量)

  • bid_price1: 3881.0 (买一价)

  • bid_volume1: 18 (买一量)

  • volume: 7823 (当日成交量)

  • amount: 19237841.0 (成交额)

  • open_interest: 1941 (持仓量)

Example:

# 获取 SHFE.cu1805 合约 20180201-06:00:00 ~ 20180301-16:00:00 的 tick 数据
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))

tick_data = api.get_tick_data_series(symbol = "SHFE.cu1805",
            start_dt = datetime(2018, 2, 1, 6, 0, 0), end_dt = datetime(2018, 3, 1, 16, 0, 0))
print(tick_data)

ma = MA(tick_data, 30)  # 计算 MA 指标
print(list(ma["ma"]))

api.close()
get_trading_calendar(start_dt: date | datetime, end_dt: date | datetime) → DataFrame

获取一段时间内的交易日历信息，每年的交易日历将在交易所新一年的节假日安排后更新

Args:
start_dt (date/datetime): 起始时间

  • date: 指的是交易日

  • datetime: 指的指的是该时间点所在年月日日期

end_dt (date/datetime): 结束时间

  • date: 指的是交易日

  • datetime: 指的指的是该时间点所在年月日日期

Returns:

pandas.DataFrame: 包含以下列:

  • date: (datetime64[ns]) 日期，为北京时间的日期

  • trading: (bool) 是否是交易日

Example:

from datetime import date
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
cld = api.get_trading_calendar(start_dt=date(2021,2,1), end_dt=date(2021,3,1))
print(cld)

# 预期输出如下
#         date  trading
# 0  2021-02-01    True
# 1  2021-02-02    True
# 2  2021-02-03    True
# ......
# 26 2021-02-27   False
# 27 2021-02-28   False
# 28 2021-03-01    True

api.close()
query_his_cont_quotes(symbol: str | List[str], n: int = 200) → DataFrame

获取指定的主连合约最近 n 天的标的。

Args:
symbol (str/list of str): 指定主连合约代码或主连合约代码列表.

  • str: 一个合约代码

  • list of str: 合约代码列表 （一次提取多个合约的K线并根据相同的时间向第一个合约（主合约）对齐)

n：返回 n 个交易日交易日的对应品种的主力, 默认值为 200

Returns：

pandas.DataFrame: 包含 n 行数据，列数为指定主连合约代码个数加 1，有以下列:

  • date: (datetime64[ns]) 日期

  • 主连代码: (str) 对应的标的合约

注意:

如果返回的时间段中，还未上市的主连合约，其对应的标的合约值为空字符串。

Example:

from datetime import date
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
conts = api.query_his_cont_quotes(symbol=['KQ.m@DCE.a', 'KQ.m@DCE.eg'], n=20)
print(conts)

# 预期输出如下
#         date KQ.m@DCE.a KQ.m@DCE.eg
# 0  2021-08-13  DCE.a2109  DCE.eg2109
# 1  2021-08-16  DCE.a2111  DCE.eg2109
# 2  2021-08-17  DCE.a2111  DCE.eg2109
# ......
# 17 2021-09-07  DCE.a2111  DCE.eg2201
# 18 2021-09-08  DCE.a2111  DCE.eg2201
# 19 2021-09-09  DCE.a2111  DCE.eg2201

api.close()
add_risk_rule(rule: TqRiskRule) → None

添加一项风控规则实例。

Args:

rule (TqRiskRule): 风控规则实例，必须是 TqRiskRule 的子类型

delete_risk_rule(rule: TqRiskRule) → None

删除一项风控规则实例。

Args:

rule (TqRiskRule): 风控规则实例，必须是 TqRiskRule 的子类型

insert_order(symbol: str, direction: str, offset: str = '', volume: int = 0, limit_price: str | float | None = None, advanced: str | None = None, order_id: str | None = None, account: TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None) → Order

发送下单指令. 注意: 指令将在下次调用 wait_update() 时发出

Args:

symbol (str): 拟下单的合约symbol, 格式为 交易所代码.合约代码, 例如 "SHFE.cu1801"

direction (str): "BUY" 或 "SELL"

offset (str): "OPEN", "CLOSE" 或 "CLOSETODAY" (上期所和上期能源分平今/平昨, 平今用"CLOSETODAY", 平昨用"CLOSE"; 其他交易所直接用"CLOSE" 按照交易所的规则平仓), 股票交易中该参数无需填写

volume (int): 下单交易数量, 期货为下单手数, A 股股票为股数

limit_price (float | str): [可选] 下单价格, 默认为 None, 股票交易目前仅支持限价单, 该字段必须指定。

  • 数字类型: 限价单，按照限定价格或者更优价格成交

  • None: 市价单，默认值就是市价单 (郑商所期货/期权、大商所期货支持)

  • "BEST": 最优一档，以对手方实时最优一档价格为成交价格成交（仅中金所支持）

  • "FIVELEVEL": 最优五档，在对手方实时最优五个价位内以对手方价格为成交价格依次成交（仅中金所支持）

advanced (str): [可选] "FAK", "FOK"。默认为 None, 股票交易中该参数不支持。

  • None: 对于限价单，任意手数成交，委托单当日有效；对于市价单、最优一档、最优五档(与 FAK 指令一致)，任意手数成交，剩余撤单。

  • "FAK": 剩余即撤销，指在指定价位成交，剩余委托自动被系统撤销。(限价单、市价单、最优一档、最优五档有效)

  • "FOK": 全成或全撤，指在指定价位要么全部成交，否则全部自动被系统撤销。(限价单、市价单有效，郑商所期货品种不支持 FOK)

order_id (str): [可选]指定下单单号, 默认由 api 自动生成

account (TqAccount/TqKq/TqKqStock/TqSim): [可选]指定发送下单指令的账户实例, 多账户模式下，该参数必须指定

Returns:

Order: 返回一个委托单对象引用. 其内容将在 wait_update() 时更新.

Example1:

# 市价开3手 DCE.m1809 多仓
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
order = api.insert_order(symbol="DCE.m1809", direction="BUY", offset="OPEN", volume=3)
while True:
    api.wait_update()
    print("单状态: %s, 已成交: %d 手" % (order.status, order.volume_orign - order.volume_left))

# 预计的输出是这样的:
单状态: ALIVE, 已成交: 0 手
单状态: ALIVE, 已成交: 0 手
单状态: FINISHED, 已成交: 3 手
...

Example2:

# 限价开多3手 DCE.m1901
from tqsdk import TqApi, TqAuth
with TqApi(auth=TqAuth("快期账户", "账户密码")) as api:
    order = api.insert_order(symbol="DCE.m2009", direction="BUY", offset="OPEN", volume=3, limit_price=3000)
    while True:
        api.wait_update()
        print("单状态: %s, 已成交: %d 手" % (order.status, order.volume_orign - order.volume_left))

# 预计的输出是这样的:
单状态: ALIVE, 已成交: 0 手
单状态: ALIVE, 已成交: 0 手
单状态: FINISHED, 已成交: 3 手
...

Example3:

# 市价开多3手 DCE.m1901 FAK
from tqsdk import TqApi, TqAuth
with TqApi(auth=TqAuth("快期账户", "账户密码")) as api:
    order = api.insert_order(symbol="DCE.m2009", direction="BUY", offset="OPEN", volume=3, advanced="FAK")
    while True:
        api.wait_update()
        print("单状态: %s, 已成交: %d 手" % (order.status, order.volume_orign - order.volume_left))

# 预计的输出是这样的:
单状态: ALIVE, 已成交: 0 手
单状态: ALIVE, 已成交: 0 手
单状态: FINISHED, 已成交: 3 手
...

Example4:

# 多账户模式下, 分别获取各账户的成交记录
from tqsdk import TqApi, TqAuth, TqMultiAccount

account1 = TqAccount("H海通期货", "123456", "123456")
account2 = TqAccount("H宏源期货", "123456", "123456")
with TqApi(TqMultiAccount([account1, account2]), auth=TqAuth("快期账户", "账户密码")) as api:
    order1 = api.insert_order(symbol="DCE.m2101", direction="BUY", offset="OPEN", volume=3, account=account1)
    order2 = api.insert_order(symbol="DCE.m2103", direction="BUY", offset="OPEN", volume=3, account=account2)
    while order1.status != "FINISHED" or order2.status != "FINISHED":
        api.wait_update()
        print("委托单1已成交: %d 手, 委托单2已成交: %d 手", order1.volume_orign - order1.volume_left,
        order2.volume_orign - order2.volume_left)

# 预计的输出是这样的:
委托单1已成交: 0 手, 委托单2已成交: 3 手
...

Example5:

# 股票模拟下单
from tqsdk import TqApi, TqAuth, TqKqStock

account = TqKqStock()
with TqApi(account=account, auth=TqAuth("快期账户", "账户密码")) as api:
    order = api.insert_order("SSE.601456", direction="BUY", limit_price=None, volume=200)
    while order.status != "FINISHED":
        api.wait_update()
        print("已成交: %d 股" % (order.volume_orign - order.volume_left))

# 预计的输出是这样的:
已成交: 200 股
...
cancel_order(order_or_order_id: str | Order, account: TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None) → None

发送撤单指令. 注意: 指令将在下次调用 wait_update() 时发出

Args:

order_or_order_id (str/ Order ): 拟撤委托单或单号

account (TqAccount/TqKq/TqKqStock/TqSim/TqSimStock): [可选]指定发送撤单指令的账户实例, 多账户模式下, 该参数必须指定

Example1:

# 挂价开3手 DCE.m1809 多仓, 如果价格变化则撤单重下，直到全部成交
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("DCE.m1809")
order = {}

while True:
    api.wait_update()
    # 当行情有变化且当前挂单价格不优时，则撤单
    if order and api.is_changing(quote) and order.status == "ALIVE" and quote.bid_price1 > order.limit_price:
        print("价格改变，撤单重下")
        api.cancel_order(order)
    # 当委托单已撤或还没有下单时则下单
    if (not order and api.is_changing(quote)) or (api.is_changing(order) and order.volume_left != 0 and order.status == "FINISHED"):
        print("下单: 价格 %f" % quote.bid_price1)
        order = api.insert_order(symbol="DCE.m1809", direction="BUY", offset="OPEN", volume=order.get("volume_left", 3), limit_price=quote.bid_price1)
    if api.is_changing(order):
        print("单状态: %s, 已成交: %d 手" % (order.status, order.volume_orign - order.volume_left))


# 预计的输出是这样的:
下单: 价格 3117.000000
单状态: ALIVE, 已成交: 0 手
价格改变，撤单重下
下单: 价格 3118.000000
单状态: ALIVE, 已成交: 0 手
单状态: FINISHED, 已成交: 3 手
...

Example2:

# 多账户条件下, 股票账户依据期货账户下单结果进行操作
from tqsdk import TqApi, TqAuth, TqMultiAccount

future_account = TqAccount("N南华期货", "123456", "123456")
stock_account = TqAccount("N南华期货_股票", "88888888", "123456")
api = TqApi(TqMultiAccount([account1, account2]), auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("CFFEX.IF2011")
order1 = api.insert_order(symbol="CFFEX.IF2011", direction="SELL", offset="OPEN", volume=3, account=future_account)
while True:
    api.wait_update()
    # 当行情有变化且当前挂单价格不优时，则撤单
    if order1.status == "ALIVE" and api.is_changing(quote) and quote.bid_price1 > order.limit_price:
        api.cancel_order(order1, future_account)
    # 当期货账户下单成功后, 操作股票账户进行下单
    if order1.status == "FINISHED" and order1.volume_left == 0:
        order2 = api.insert_order(symbol="SSE.10002504", direction="BUY", volume=volume, account=stock_account)

api.close()
...
get_account(account: TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None) → Account

获取用户账户资金信息

Args:

account (TqAccount/TqKq/TqKqStock/TqSim/TqSimStock): [可选]指定获取账户资金信息的账户实例, 多账户模式下, 该参数必须指定

Returns:

Account / SecurityAccount: 返回一个账户对象引用. 其内容将在 wait_update() 时更新.

期货账户资金返回对象类型为 Account，股票账户资金返回对象类型为 SecurityAccount。

Example1:

# 获取当前浮动盈亏
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
account = api.get_account()
print(account.float_profit)

# 预计的输出是这样的:
2180.0
2080.0
2080.0
...

Example2:

# 多账户模式下, 分别获取各账户浮动盈亏
from tqsdk import TqApi, TqAuth, TqMultiAccount

account1 = TqAccount("N南华期货", "123456", "123456")
account2 = TqAccount("H宏源期货", "111111", "123456")
api = TqApi(TqMultiAccount([account1, account2]), auth=TqAuth("快期账户", "账户密码"))
account_info1 = account1.get_account()
account_info2 = account2.get_account()
print("账户 1 浮动盈亏 %f, 账户 2 浮动盈亏 %f", account_info1.float_profit, account_info2.float_profit)
api.close()

# 预计的输出是这样的:
账户 1 浮动盈亏 20580.0, 账户 2 浮动盈亏 -7390.0
...
get_position(symbol: str | None = None, account: TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None) → Position | Entity

获取用户持仓信息

Args:

symbol (str): [可选]合约代码, 不填则返回所有持仓

account (TqAccount/TqKq/TqKqStock/TqSim/TqSimStock): [可选]指定获取持仓信息的账户实例, 多账户模式下, 必须指定

Returns:

Position / SecurityPosition: 当指定了 symbol 时, 返回一个持仓对象引用. 其内容将在 wait_update() 时更新.

期货账户持仓返回对象类型为 Position，股票账户持仓返回对象类型为 SecurityPosition。

不填 symbol 参数调用本函数, 将返回包含用户所有持仓的一个tqsdk.objs.Entity对象引用, 使用方法与dict一致, 其中每个元素的key为合约代码, value为 Position。

注意: 为保留一些可供用户查询的历史信息, 如 volume_long_yd(本交易日开盘前的多头持仓手数) 等字段, 因此服务器会返回当天已平仓合约( pos_long 和 pos_short 等字段为0)的持仓信息

Example1:

# 获取 DCE.m1809 当前浮动盈亏
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
position = api.get_position("DCE.m1809")
print(position.float_profit_long + position.float_profit_short)
while api.wait_update():
    print(position.float_profit_long + position.float_profit_short)

# 预计的输出是这样的:
300.0
330.0
...

Example2:

# 多账户模式下, 分别获取各账户浮动盈亏
from tqsdk import TqApi, TqAuth, TqMultiAccount

account1 = TqAccount("N南华期货", "123456", "123456")
account2 = TqAccount("N宏源期货", "123456", "123456")
api = TqApi(TqMultiAccount([account1, account2]), auth=TqAuth("快期账户", "账户密码"))
position1 = account1.get_position("DCE.m2101")
position2 = account2.get_position("DCE.m2101")
print("账户 1 浮动盈亏 %f, 账户 2 浮动盈亏 %f", position1.float_profit_long + position2.float_profit_short,
      position1.float_profit_long + position2.float_profit_short)
api.close()

# 预计的输出是这样的:
账户 1 浮动盈亏 2140.0, 账户 2 浮动盈亏 0.00
...
get_order(order_id: str | None = None, account: TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None) → Order | Entity

获取用户委托单信息

Args:

order_id (str): [可选]单号, 不填单号则返回所有委托单

account (TqAccount/TqKq/TqKqStock/TqSim/TqSimStock): [可选]指定获取委托单号的账户实例, 多账户模式下, 该参数必须指定

Returns:

Order / SecurityOrder : 当指定了order_id时, 返回一个委托单对象引用. 其内容将在 wait_update() 时更新.

期货账户委托单返回对象类型为 Order，股票账户委托单返回对象类型为 SecurityOrder。

不填order_id参数调用本函数, 将返回包含用户所有委托单的一个tqsdk.objs.Entity对象引用, 使用方法与dict一致, 其中每个元素的key为委托单号, value为 Order

注意: 在刚下单后, tqsdk 还没有收到回单信息时, 此对象中各项内容为空

Example1:

# 获取当前总挂单手数
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
orders = api.get_order()
while True:
    api.wait_update()
    print(sum(order.volume_left for oid, order in orders.items() if order.status == "ALIVE"))

# 预计的输出是这样的:
3
3
0
...

Example2:

# 多账户模式下, 分别获取各账户浮动盈亏
from tqsdk import TqApi, TqAuth, TqMultiAccount

account1 = TqAccount("N南华期货", "123456", "123456")
account2 = TqAccount("N宏源期货", "123456", "123456")
api = TqApi(TqMultiAccount([account1, account2]), auth=TqAuth("快期账户", "账户密码"))
orders1 = account1.get_order()
order2 = account2.get_order(order_id="订单号")
print(len(orders1), order2.volume_left)
api.close()

# 预计的输出是这样的:
2 0
...
get_trade(trade_id: str | None = None, account: TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None) → Trade | Entity

获取用户成交信息

Args:

trade_id (str): [可选]成交号, 不填成交号则返回所有委托单

account (TqAccount/TqKq/TqKqStock/TqSim/TqSimStock): [可选]指定获取用户成交信息的账户实例, 多账户模式下, 该参数必须指定

Returns:

Trade / SecurityTrade: 当指定了trade_id时, 返回一个成交对象引用. 其内容将在 wait_update() 时更新.

期货账户成交返回对象类型为 Trade，股票账户成交返回对象类型为 SecurityTrade。

不填trade_id参数调用本函数, 将返回包含用户当前交易日所有成交记录的一个tqsdk.objs.Entity对象引用, 使用方法与dict一致, 其中每个元素的key为成交号, value为 Trade

推荐优先使用 trade_records() 获取某个委托单的相应成交记录, 仅当确有需要时才使用本函数.

Example:

# 多账户模式下, 分别获取各账户浮动盈亏
from tqsdk import TqApi, TqAuth, TqMultiAccount

account1 = TqAccount("N南华期货", "123456", "123456")
account2 = TqAccount("N宏源期货", "123456", "123456")
api = TqApi(TqMultiAccount([account1, account2]), auth=TqAuth("快期账户", "账户密码"))
trades1 = account1.get_trade()
trades2 = account2.get_trade()
print(len(trades1), len(trades2))
api.close()

# 预计的输出是这样的:
20 55
...
get_risk_management_rule(exchange_id: str | None = None, account: TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None) → RiskManagementRule | Entity

获取账户风控统计规则

Args:

exchange_id (str): [可选] 交易所代码, 不填交易所代码则返回所有交易所风控规则 目前支持设置风控规则的交易所 SSE（上海证券交易所）、SZSE（深圳证券交易所）

Returns:

RiskManagementRule: 当指定了 exchange_id 时, 返回该交易所的风控统计规则对象的引用.

不填 exchange_id 参数调用本函数, 将返回包含所有交易所风控规则的一个 tqsdk.objs.Entity 对象引用, 使用方法与dict一致, 其中每个元素的 key 为交易所代码, value为 RiskManagementRule。

Example:

from tqsdk import TqApi, TqAuth, TqAccount
api = TqApi(TqAccount("H海通期货", "022631", "123456"), auth=TqAuth("快期账户", "账户密码"))
rule = api.get_risk_management_rule(exchange_id="SSE")
print(exchange_id, rule['enable'])
print("自成交限制:", rule.self_trade)
print("频繁报撤单限制:", rule.frequent_cancellation)
print("成交持仓比限制:", rule.trade_position_ratio)
api.close()
set_risk_management_rule(exchange_id: str, enable: bool, count_limit: int | None = None, insert_order_count_limit: int | None = None, cancel_order_count_limit: int | None = None, cancel_order_percent_limit: float | None = None, trade_units_limit: int | None = None, trade_position_ratio_limit: float | None = None, account: TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None) → RiskManagementRule | None

设置交易所风控规则. 注意: 指令将在下次调用 wait_update() 时发出 调用本函数时，没有填写的可选参数会被服务器设置为默认值。

Args:

exchange_id (str): 交易所代码, "SSE" 或者 "SZSE"

enable (bool): 是否启用该规则

count_limit (int): [可选]最大自成交次数限制，如果未填写，服务器将根据交易所不同赋不同的默认值。

insert_order_count_limit (int): [可选]频繁报撤单起算报单次数，如果未填写，服务器将根据交易所不同赋不同的默认值。

cancel_order_count_limit (int): [可选]频繁报撤单起算撤单次数，如果未填写，服务器将根据交易所不同赋不同的默认值。

cancel_order_percent_limit (float): [可选]频繁报撤单撤单比例限额，为百分比，如果未填写，服务器将根据交易所不同赋不同的默认值。

trade_units_limit (int): [可选]成交持仓比起算成交手数，如果未填写，服务器将根据交易所不同赋不同的默认值。

trade_position_ratio_limit (float): [可选]成交持仓比例限额，为百分比，如果未填写，服务器将根据交易所不同赋不同的默认值，持仓数为该合约的净持仓。

Returns:

RiskManagementRule: 返回一个风控规则对象引用. 其内容将在 wait_update() 时更新.

Example:

from tqsdk import TqApi, TqAuth, TqAccount
api = TqApi(TqAccount("H海通期货", "022631", "123456"), auth=TqAuth("快期账户", "账户密码"))
# 开启 SSE 风控限制
api.set_risk_management_rule(exchange_id="SSE", enable=True)
api.wait_update()  # 真正把设置规则数据包发送到服务器
rule = api.get_risk_management_rule(exchange_id="SSE")
print(rule)
api.close()
get_risk_management_data(symbol: str | None = None, account: TqAccount | TqKq | TqZq | TqKqStock | TqSim | TqSimStock | TqCtp | TqRohon | TqJees | TqYida | None = None) → RiskManagementData | Entity

获取账户风控统计数据

Args:

symbol (str): [可选]合约代码, 不填合约代码则返回账户下所有持仓合约的风控统计数据

Returns:

RiskManagementData: 当指定了 symbol 时, 返回该合约下的风控统计数据对象引用. 其内容将在 wait_update() 时更新.

不填 symbol 参数调用本函数, 将返回包含用户所有持仓合约的一个 tqsdk.objs.Entity 对象引用, 使用方法与 dict 一致, 其中每个元素的 key 为合约代码, value为 RiskManagementData。

wait_update(deadline: float | None = None, _task: Task | List[Task] | None = None) → bool

等待业务数据更新

调用此函数将阻塞当前线程, 等待天勤主进程发送业务数据更新并返回

注: 它是TqApi中最重要的一个函数, 每次调用它时都会发生这些事:

  • 实际发出网络数据包(如行情订阅指令或交易指令等).

  • 尝试从服务器接收一个数据包, 并用收到的数据包更新内存中的业务数据截面.

  • 让正在运行中的后台任务获得动作机会(如策略程序创建的后台调仓任务只会在wait_update()时发出交易指令).

  • 如果没有收到数据包，则挂起等待.

Args:

deadline (float): [可选]指定截止时间，自unix epoch(1970-01-01 00:00:00 GMT)以来的秒数(time.time())。默认没有超时(无限等待)

Returns:

bool: 如果收到业务数据更新则返回 True, 如果到截止时间依然没有收到业务数据更新则返回 False

注意:

  • 由于存在网络延迟, 因此有数据更新不代表之前发出的所有请求都被处理了, 例如:

    from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu1812")
api.wait_update()
print(quote.datetime)

可能输出 ""(空字符串), 表示还没有收到该合约的行情

is_changing(obj: Any, key: str | List[str] | None = None) → bool

判定obj最近是否有更新

当业务数据更新导致 wait_update 返回后可以使用该函数判断 本次业务数据更新是否包含特定obj或其中某个字段 。

关于判断K线更新的说明： 当生成新K线时，其所有字段都算作有更新，若此时执行 api.is_changing(klines.iloc[-1]) 则一定返回True。

Args:

obj (any): 任意业务对象, 包括 get_quote 返回的 quote, get_kline_serial 返回的 k_serial, get_account 返回的 account 等

key (str/list of str): [可选]需要判断的字段，默认不指定

  • 不指定: 当该obj下的任意字段有更新时返回True, 否则返回 False.

  • str: 当该obj下的指定字段有更新时返回True, 否则返回 False.

  • list of str: 当该obj下的指定字段中的任何一个字段有更新时返回True, 否则返回 False.

Returns:

bool: 如果本次业务数据更新包含了待判定的数据则返回 True, 否则返回 False.

Example:

# 追踪 SHFE.cu1812 的最新价更新
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu1812")
print(quote.last_price)
while True:
    api.wait_update()
    if api.is_changing(quote, "last_price"):
        print(quote.last_price)

# 以上代码运行后的输出是这样的:
51800.0
51810.0
51800.0
...
is_serial_ready(obj: DataFrame) → bool

判断是否已经从服务器收到了所有订阅的数据

Args:

obj (pandas.Dataframe): K线数据

Returns:

bool: 返回 True 表示已经从服务器收到了所有订阅的数据

Example:

# 判断是否已经从服务器收到了最后 3000 根 SHFE.cu1812 的分钟线数据
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("SHFE.cu1812", 60, data_length=3000)
while True:
    api.wait_update()
    print(api.is_serial_ready(klines))

# 预计的输出是这样的:
False
False
True
True
...
create_task(coro: Coroutine, _caller_api: bool = False) → Task

创建一个task

一个task就是一个协程，task的调度是在 wait_update 函数中完成的，如果代码从来没有调用 wait_update，则task也得不到执行

Args:

coro (coroutine): 需要创建的协程

Example:

# 一个简单的task
import asyncio
from tqsdk import TqApi, TqAuth

async def hello():
    await asyncio.sleep(3)
    print("hello world")

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
api.create_task(hello())
while True:
    api.wait_update()

#以上代码将在3秒后输出
hello world
register_update_notify(obj: Any | None = None, chan: TqChan | None = None) → TqChan

注册一个channel以便接受业务数据更新通知

调用此函数将返回一个channel, 当obj更新时会通知该channel

推荐使用 async with api.register_update_notify() as update_chan 来注册更新通知

如果直接调用 update_chan = api.register_update_notify() 则使用完成后需要调用 await update_chan.close() 避免资源泄漏

Args:

obj (any/list of any): [可选]任意业务对象, 包括 get_quote 返回的 quote, get_kline_serial 返回的 k_serial, get_account 返回的 account 等。默认不指定，监控所有业务对象

chan (TqChan): [可选]指定需要注册的channel。默认不指定，由本函数创建

Example:

# 获取 SHFE.cu1812 合约的报价
from tqsdk import TqApi, TqAuth

async def demo():
    quote = api.get_quote("SHFE.cu1812")
    async with api.register_update_notify(quote) as update_chan:
        async for _ in update_chan:
            print(quote.last_price)

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
api.create_task(demo())
while True:
    api.wait_update()

#以上代码将输出
nan
51850.0
51850.0
51690.0
...
query_graphql(query: str, variables: dict, query_id: str | None = None) → Entity

发送基于 GraphQL 的合约服务请求查询，在同步代码中返回查询结果；异步代码中返回查询结果的引用地址。

Args:

query (str): [必填] 查询语句

variables (dict): [必填] 查询语句对应的参数取值

query_id (str): [可选] 查询请求 id

Returns:
Entity: 返回查询结果的对象引用。

其的结构为 {query: "", variables: {}, result: {}} query 和 variables 为发送请求时传入的参数，result 为查询结果

Example:

# 查询 "SHFE.au2012" 对应的全部期权
from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
variables = {
    "derivative_class": ["OPTION"],
    "underlying_symbol": ["SHFE.au2012"]
}
query = '''
        query($derivative_class:[Class], $underlying_symbol:[String]){
            multi_symbol_info(instrument_id:$underlying_symbol){
                ... on basic { instrument_id
                    derivatives (class: $derivative_class) {
                        edges { node { ... on basic{ instrument_id}} }
                    }
                }
            }
        }
        '''
res = api.query_graphql(query, variables)
print(res["result"])
query_symbol_settlement(symbol: str | List[str], days: int = 1, start_dt: date | None = None) → TqMdSettlementDataFrame

查询交易所合约每日结算价

该函数返回的对象不会更新，不建议在循环内调用该方法。

Args:

symbol (str / list of str): [必填] 合约代码

days (int): [可选] 交易日数，默认为 1

start_dt (date): [可选] 开始日期，默认为 None

Returns:

pandas.DataFrame: 本函数返回 pandas.DataFrame 实例。行数为 days * 合约数，每行是一条合约结算价信息。包含以下列:

  • datetime (查询日期)

  • symbol (交易所内合约代码)

  • settlement (结算价)

注意: 1. 每日结算价产生时间: 每天的 18:30 ~ 19:00：

  • 如果想查询交易日 20241011 的结算价，需要在 20241011 的 19:00 之后查询，否则无法获取 20241011 的数据

  1. 如果没有指定 start_dt 参数，则返回当前日期前，已经产生的 days 个交易日的结算价数据：

    • 此处的 days 指的是交易日数，会自动跳过节假日、周末等非交易日

    • 假设当前日期是 20241011，days=7：

      • 在 19:00 前查询，返回 20240925 20240926 20240927 20240930 20241008 20241009 20241010 的结算价信息

      • 在 19:00 后查询，返回 20240926 20240927 20240930 20241008 20241009 20241010 20241011 的结算价信息

  2. 如果指定了 start_dt 参数，则返回从 start_dt 日期起，已经产生的 days 个交易日的结算价数据：
    • 假设开始日期为 20241008，当前日期是 20241011：

      • 假设 days=3，返回 20241008 20241009 20241010 三天的结算价信息

      • 假设 days=4，如果在 19:00 之前查询，返回 20241008 20241009 20241010 三天的结算价信息

      • 假设 days=4，如果在 19:00 之后查询，返回 20241008 20241009 20241010 20241011 四天的结算价信息

  3. 数据支持范围：
    • 期货数据：

      • 中金所、上期所、上能所、大商所、郑商所：20200102 起

      • 广期所：20221226 起

    • 期权数据：

      • 中金所、上期所、大商所、郑商所：20200102 起

      • 上能所：20210621 起

      • 广期所：20221226 起

Example:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))

df = api.query_symbol_settlement("INE.nr2408", days=3)
print(df.to_string())  # 最近 3 天结算价信息
api.close()
query_symbol_ranking(symbol: str, ranking_type: str, days: int = 1, start_dt: date | None = None, broker: str | None = None) → TqSymbolRankingDataFrame

查询合约成交排名/持仓排名

该函数返回的对象不会更新，不建议在循环内调用该方法。

Args:

symbol (str): [必填] 合约代码

ranking_type (str)：[必填] 表示返回结果以哪一项为排名基准，VOLUME 成交量排名，LONG 多头持仓排名, SHORT 空头持仓排名

days (int): [必填] 返回结果中包含的天数，默认为 1

start_dt (date): [可选] 查询时间段开始日期，默认为 None

  • 如果开始日期为 date 类型，则返回从开始日期之后 days 个交易日的有效数据

  • 如果开始日期为 None，则返回最近 days 个交易日的持仓排名情况

broker (str): [可选] 指定期货公司，以各家交易所列出的期货公司名称为准来进行查询，各家交易所可能期货公司名称不一致，如果对应这一天这家交易所没数据则返回对应数值为nan

Returns:

pandas.DataFrame: 本函数返回 pandas.DataFrame 实例。行数为 days * 20，每行为一条成交量/多头持仓量/空头持仓量的排名信息。返回值不会再更新。包含以下列:

  • datetime (查询日期)

  • symbol (合约代码，以交易所列出的期货公司名称为准)

  • exchange_id (交易所)

  • instrument_id (交易所内合约代码)

  • broker (期货公司)

  • volume (成交量)

  • volume_change (成交量变化)

  • volume_ranking (成交量排名)

  • long_oi (多头持仓量)

  • long_change (多头持仓增减量)

  • long_ranking (多头持仓量排名)

  • short_oi (空头持仓量)

  • short_change (空头持仓增减量)

  • short_ranking (空头持仓量排名)

注意: 1. 返回值中 datetime、symbol、exchange_id、instrument_id、broker 这几列一定为有效值。其他列会根据不同的 ranking_type 参数值，可能返回 nan：

  • 例如：当 ranking_type 参数值为 volume_ranking 时，volume、volume_change、volume_ranking 这三列为有效值；

    如果该期货公司的 long_ranking 在前 20 名内，long_oi、long_change、long_ranking 这三列为有效值，否则为 nan。 如果该期货公司的 short_ranking 在前 20 名内，short_oi、short_change、short_ranking 这三列为有效值，否则为 nan。

  1. 数据更新时间: 18:30~19:00。 用户在交易日 19:00 之前可以查询当前交易日之前的所有数据，19:00 之后可以查询包括当前交易日的数据。

  2. 数据支持范围：从 20200720 开始的期货数据。

Example:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
df = api.query_symbol_ranking("SHFE.cu2109", ranking_type='VOLUME')
print(df.to_string())  # 最近 1 天持仓排名信息，以成交量排序

df = api.query_symbol_ranking("SHFE.cu2109", ranking_type='LONG', days=3)
print(df.to_string())  # 最近 3 天持仓排名信息，以多头持仓量排序
api.close()
query_quotes(ins_class: str | List[str] | None = None, exchange_id: str | List[str] | None = None, product_id: str | List[str] | None = None, expired: bool | None = None, has_night: bool | None = None) → SymbolList

根据相应的参数发送合约服务请求查询，并返回查询结果

Args:
ins_class (str / list of str): [可选] 合约类型

  • FUTURE: 期货

  • CONT: 主连

  • COMBINE: 组合

  • INDEX: 指数

  • OPTION: 期权

  • STOCK: 股票

exchange_id (str / list of str): [可选] 交易所

  • CFFEX: 中金所

  • SHFE: 上期所

  • DCE: 大商所

  • CZCE: 郑商所

  • INE: 能源交易所(原油)

  • GFEX: 广州期货交易所

  • SSE: 上交所

  • SZSE: 深交所

  • KQD: 外盘主连

product_id (str / list of str): [可选] 品种（股票、期权不能通过 product_id 筛选查询）

expired (bool): [可选] 是否已下市

has_night (bool): [可选] 是否有夜盘，默认为 None。

  • None 表示筛选结果既包括有夜盘品种也包括无夜盘品种

  • True 表示筛选结果只包括有夜盘品种

  • False 表示筛选结果只包括无夜盘品种

Returns:

list: 符合筛选条件的合约代码的列表，例如: ["SHFE.cu2012", "SHFE.au2012", "SHFE.wr2012"]

Example:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))

# 不推荐使用以下方式获取符合某种条件的合约列表，推荐使用接口来完成此功能。
# ls = [k for k,v in api._data["quotes"].items() if k.startswith("KQ.m")]
# print(ls)

ls = api.query_quotes(ins_class="FUTURE", product_id="au")
print(ls)  # au 品种的全部合约，包括已下市以及未下市合约

ls = api.query_quotes(ins_class=["FUTURE"], product_id=["au", "cu"], expired=False)
print(ls)  # au、cu 品种的全部未下市合约合约

ls = api.query_quotes(ins_class="INDEX", product_id="au")
print(ls)  # au 品种指数合约

ls = api.query_quotes(ins_class="CONT")
print(ls)  # 全部主连合约

ls = api.query_quotes(ins_class="CONT", product_id="au")
print(ls)  # au 品种主连合约

ls = api.query_quotes(ins_class="FUTURE", exchange_id="SHFE", has_night=True)
print(ls)  # 上期所带夜盘的期货合约列表

ls = api.query_quotes(product_id="au", expired=False)
print(ls)  # au 品种的全部未下市合约、指数、主连

ls = api.query_quotes(ins_class="STOCK", exchange_id="SSE", expired=False)
print(ls)  # 上海交易所股票代码列表

ls = api.query_quotes(ins_class="FUND", exchange_id="SSE", expired=False)
print(ls)  # 上海交易所基金代码列表
query_cont_quotes(exchange_id: str | None = None, product_id: str | None = None, has_night: bool | None = None) → SymbolList

根据填写的参数筛选，返回主力连续合约对应的标的合约列表

Args:
exchange_id (str): [可选] 交易所

  • CFFEX: 中金所

  • SHFE: 上期所

  • DCE: 大商所

  • CZCE: 郑商所

  • INE: 能源交易所(原油)

  • GFEX: 广州期货交易所

product_id (str): [可选] 品种

has_night (bool / None): [可选] 是否有夜盘，默认为 None。

  • None 表示筛选结果既包括有夜盘品种也包括无夜盘品种

  • True 表示筛选结果只包括有夜盘品种

  • False 表示筛选结果只包括无夜盘品种

Returns:

list: 符合筛选条件的合约代码的列表，例如: ["SHFE.cu2012", "SHFE.au2012", "SHFE.wr2012"]

Example1:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))

ls = api.query_cont_quotes()
print(ls)  # 全部主连合约对应的标的合约

ls = api.query_cont_quotes(exchange_id="DCE")
print(ls)  # 大商所主连合约对应的标的合约

ls = api.query_cont_quotes(product_id="jd")
print(ls)  # jd 品种主连合约对应的标的合约

Example2:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))

print(api.query_cont_quotes(exchange_id="DCE", has_night=True))
print(api.query_cont_quotes(exchange_id="DCE", has_night=False))
print(api.query_cont_quotes(exchange_id="DCE"))
api.close()

# 输出应该如下所示
['DCE.c2105', 'DCE.m2105', 'DCE.rr2105', 'DCE.b2105', 'DCE.jm2105', 'DCE.pp2105', 'DCE.i2105', 'DCE.cs2105', 'DCE.eb2105', 'DCE.l2105', 'DCE.v2105', 'DCE.pg2104', 'DCE.eg2105', 'DCE.p2105', 'DCE.a2105', 'DCE.y2105', 'DCE.j2105']
['DCE.bb2105', 'DCE.jd2105', 'DCE.fb2105', 'DCE.lh2109']
['DCE.y2105', 'DCE.j2105', 'DCE.jd2105', 'DCE.c2105', 'DCE.m2105', 'DCE.rr2105', 'DCE.b2105', 'DCE.jm2105', 'DCE.fb2105', 'DCE.pp2105', 'DCE.lh2109', 'DCE.i2105', 'DCE.cs2105', 'DCE.eb2105', 'DCE.l2105', 'DCE.v2105', 'DCE.pg2104', 'DCE.eg2105', 'DCE.p2105', 'DCE.bb2105', 'DCE.a2105']
query_options(underlying_symbol: str, option_class: str | None = None, exercise_year: int | None = None, exercise_month: int | None = None, strike_price: float | None = None, expired: bool | None = None, has_A: bool | None = None, **kwargs) → SymbolList

发送合约服务请求查询，查询符合条件的期权列表，并返回查询结果

Args:

underlying_symbol (str): 标的合约

option_class (str): [可选] 期权类型

  • CALL: 看涨期权

  • PUT: 看跌期权

exercise_year (int): [可选] 最后行权日年份

exercise_month (int): [可选] 最后行权日月份

strike_price (float): [可选] 行权价格

expired (bool): [可选] 是否下市

has_A (bool): [可选] 是否含有A，输入True代表只含A的期权，输入False代表不含A的期权，默认为None不做区分

Returns:

list: 符合筛选条件的合约代码的列表，例如: ["SHFE.cu2012C24000", "SHFE.cu2012P24000"]

Example:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))

ls = api.query_options("SHFE.au2012")
print(ls)  # 标的为 "SHFE.au2012" 的所有期权

ls = api.query_options("SHFE.au2012", option_class="PUT")
print(ls)  # 标的为 "SHFE.au2012" 的看跌期权

ls = api.query_options("SHFE.au2012", option_class="PUT", expired=False)
print(ls)  # 标的为 "SHFE.au2012" 的看跌期权, 未下市的

ls = api.query_options("SHFE.au2012", strike_price=340)
print(ls)  # 标的为 "SHFE.au2012" 、行权价为 340 的期权

ls = api.query_options("SSE.000300")
print(ls)  # 中金所沪深300股指期权

ls = api.query_options("SSE.510300")
print(ls)  # 上交所沪深300etf期权

ls = api.query_options("SSE.510300", exercise_year=2020, exercise_month=12)
print(ls)  # 上交所沪深300etf期权, 限制条件 2020 年 12 月份行权
query_atm_options(underlying_symbol, underlying_price, price_level, option_class, exercise_year: int | None = None, exercise_month: int | None = None, has_A: bool | None = None) → SymbolList
Args:

underlying_symbol (str): [必填] 标的合约 （目前每个标的只对应一个交易所的期权）

underlying_price (float): [必填] 标的价格，该价格用户输入可以是任意值，例如合约最新价，最高价，开盘价等然后以该值去对比实值/虚值/平值期权

price_level (int / list[int]): [必填] 实值/平值/虚值档位，支持 -100 ~ 100 之间的整数，其中 3,2,1,0,-1,-2,-3，分别代表实值3档，实值2档，实值1档，平值期权，虚值1档，虚值2档，虚值3档，以此类推。

  • 如果没有用户指定档位的期权（比如 -100 档），则返回的列表该位置上为 None。例如当 price_level = [-100, 0]，则会返回 [None, "平值期权合约代码"]

option_class (str): [必填] 期权类型

  • CALL: 看涨期权

  • PUT: 看跌期权

exercise_year (str): [ETF 期权、股指期权必填] 期权最后行权日年份

exercise_month (str): [ETF 期权、股指期权必填] 期权最后行权日月份

has_A (bool): [可选] 是否含有 A，输入True代表只含A的期权，输入False代表不含A的期权，默认为None不做区分

注：当选择平值期权时，会按以下逻辑进行选择：

  1. 根据用户传入参数来生成一个期权列表，在这个期权列表中来选择是否有和传入价格相比的平值期权并返回

  2. 如果没有符合的平值期权，则取行权价距离传入价格绝对值相差最小的期权作为平值期权

  3. 如果存在最近的两个期权的行权价到传入价格的绝对值最小且相等，则取虚值的那个期权作为平值期权，其他档位期权依次展开

return:

返回一个列表类型对象

Example1:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
ls = api.query_atm_options("SHFE.au2012", quote.last_price, 0, "CALL")
# 预计输出的为以au2012现在最新价来比对的认购的平值期权，当没有符合的平值期权时返回为空
["SHFE.au2012C30000"]

Example2:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
ls = api.query_atm_options("SHFE.au2012", quote.open, [3,2,1], "CALL")
# 预计输出的为au2012，以开盘价来比对的认购的实值3档，实值2档，实值1档期权，如果没有符合要求的期权则对应栏返回为None，如果有则返回格式例如
[None,None,"SHFE.au2012C30000"]

Example3:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
ls = api.query_atm_options("SHFE.au2012", quote.open, [1,0,-1], "CALL")
# 预计输出的为au2012，以开盘价来比对的认购的实值1档，平值期权，虚值1档，如果没有符合要求的期权则对应栏返回为None，如果有则返回格式例如
["SHFE.au2012C20000","SHFE.au2012C25000","SHFE.au2012C30000"]

Example4:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
ls = api.query_atm_options("SHFE.au2012", quote.last_price, -1, "CALL")
# 预计输出的为au2012，以现在最新价来比对的认购的虚值1档期权

Example5:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
ls = api.query_atm_options("SSE.000300", quote.last_price, -1, "CALL", exercise_year=2020, exercise_month=12)
# 预计输出沪深300股指期权,2020年12月的虚值1档期权

Example6:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
ls = api.query_atm_options("SSE.510300", quote.last_price, -1, "CALL", exercise_year=2020, exercise_month=12)
# 预计输出 上交所 沪深300股指ETF期权,2020年12月的虚值1档期权
query_symbol_info(symbol: str | List[str]) → TqSymbolDataFrame

查询合约信息

Args:
symbol (str/list of str): 指定合约代码或合约代码列表.

  • str: 一个合约代码

  • list of str: 合约代码列表

Returns:

pandas.DataFrame: 本函数返回 pandas.DataFrame 实例。每行为一个合约的合约信息。返回值不会再更新。包含以下列:

  • ins_class: 合约类型，可能的值有

    • FUTURE: 期货

    • CONT: 主连

    • COMBINE: 组合

    • INDEX: 指数

    • OPTION: 期权

    • STOCK: 股票

  • instrument_id: 合约代码，参考 合约, 行情和历史数据

  • instrument_name: 合约中文名

  • exchange_id: 交易所代码，参考 合约, 行情和历史数据

  • product_id: 品种代码

  • price_tick: 合约价格变动单位

  • volume_multiple: 合约乘数

  • max_limit_order_volume: 最大限价单手数

  • max_market_order_volume: 最大市价单手数

  • underlying_symbol: 标的合约 （CONT OPTION 类型的合约此字段有效）

  • strike_price: 期权行权价

  • expired: 合约是否已下市

  • expire_datetime: 到期具体日，以秒为单位的 timestamp 值

  • expire_rest_days: 距离到期日的剩余天数（自然日天数）

  • delivery_year: 期货交割日年份，只对期货品种有效。期权推荐使用最后行权日年份

  • delivery_month: 期货交割日月份，只对期货品种有效。期权推荐使用最后行权日月份

  • last_exercise_datetime: 期权最后行权日，以秒为单位的 timestamp 值

  • exercise_year: 期权最后行权日年份，只对期权品种有效。

  • exercise_month: 期权最后行权日月份，只对期权品种有效。

  • option_class: 期权方向

  • upper_limit: 涨停价

  • lower_limit: 跌停价

  • pre_settlement: 昨结算

  • pre_open_interest: 昨持仓

  • pre_close: 昨收盘

  • trading_time_day: 白盘交易时间段，pandas.Series 类型

  • trading_time_night: 夜盘交易时间段，pandas.Series 类型

注意:

  1. 回测时，以下字段值为 nan: "upper_limit", "lower_limit", "pre_settlement", "pre_open_interest", "pre_close"

  2. 中金所合约未提供涨停价、跌停价

Example1:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))

ls = api.query_options("SSE.510050", option_class="CALL", expired=False)  # 所有未下市上交所上证50etf期权
df = api.query_symbol_info(ls)
print(df.to_string())
api.close()

Example2:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))

ls = api.query_options("SSE.510050", option_class="CALL", expired=False)

# 在异步代码中使用
async def show_symbols_info(symbols):
    df = await api.query_symbol_info(symbols)
    print(df.to_string())

api.create_task(show_symbols_info(ls))
while True:
    api.wait_update()

api.close()
query_all_level_options(underlying_symbol, underlying_price, option_class, exercise_year: int | None = None, exercise_month: int | None = None, has_A: bool | None = None) → SymbolList

发送合约服务请求查询，查询符合条件的期权列表，返回全部的实值、平值、虚值期权

Args:

underlying_symbol (str): [必填] 标的合约 （目前每个标的只对应一个交易所的期权）

underlying_price (float): [必填] 标的价格，该价格用户输入可以是任意值，例如合约最新价，最高价，开盘价等然后以该值去对比实值/虚值/平值期权

option_class (str): [必填] 期权类型

  • CALL: 看涨期权

  • PUT: 看跌期权

exercise_year (str): [ETF 期权、股指期权必填] 期权最后行权日年份

exercise_month (str): [ETF 期权、股指期权必填] 期权最后行权日月份

has_A (bool): [可选] 是否含有 A，输入True代表只含A的期权，输入False代表不含A的期权，默认为None不做区分

return:

返回三个列表，分别为实值期权列表、平值期权列表、虚值期权列表。其中，平值期权列表只包含一个元素。

对于看涨期权，返回的实值期权列表、平值期权列表、虚值期权列表其期权行权价依此递增；

对于看跌期权，返回的实值期权列表、平值期权列表、虚值期权列表其期权行权价依此递减。

注：当选择平值期权时，会按以下逻辑进行选择：

  1. 根据用户传入参数来生成一个期权列表，在这个期权列表中来选择是否有和传入价格相比的平值期权并返回

  2. 如果没有符合的平值期权，则取行权价距离传入价格绝对值相差最小的期权作为平值期权

  3. 如果存在最近的两个期权的行权价到传入价格的绝对值最小且相等，则取虚值的那个期权作为平值期权，其他档位期权依次展开

Example1:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.au2112")
in_money_options, at_money_options, out_of_money_options = api.query_all_level_options("SHFE.au2112", quote.last_price, "CALL")
print(in_money_options)  # 实值期权列表
print(at_money_options)  # 平值期权列表
print(out_of_money_options)  # 虚值期权列表
query_all_level_finance_options(underlying_symbol, underlying_price, option_class, nearbys: int | List[int], has_A: bool | None = None) → SymbolList

发送合约服务请求查询，针对 ETF 期权和股指期权，只查询未下市合约，可以按照距离最后行权日的距离的远近，查询符合条件的期权列表，返回全部的实值、平值、虚值期权

Args:
underlying_symbol (str): [必填] 标的合约 （针对 ETF 期权和股指期权，只支持以下几个合约）

  • "SSE.000300" 为中金所沪深 300 股指期权(IO)标的

  • "SSE.000852" 为中金所中证 1000 股指期权(MO)标的

  • "SSE.000016" 为中金所上证 50 股指期权(HO)标的

  • "SSE.510050" 为上交所华夏上证 50 ETF 期权标的

  • "SSE.510300" 为上交所华泰柏瑞沪深 300 ETF 期权标的

  • "SZSE.159919" 为深交所嘉实沪深 300 ETF 期权标的

  • "SZSE.159915" 为深交所易方达创业板 ETF 期权标的

  • "SZSE.159922" 为深交所嘉实中证 500 ETF 期权标的

  • "SSE.510500" 为上交所南方中证 500 ETF 期权标的

underlying_price (float): [必填] 标的价格，该价格用户输入可以是任意值，例如合约最新价，最高价，开盘价等然后以该值去对比实值/虚值/平值期权

option_class (str): [必填] 期权类型

  • CALL: 看涨期权

  • PUT: 看跌期权

nearbys (int / list of int): [必填] 将所有未下市期权按照最后行权日由近到远排序，参数 0 代表的是当前月/最接近当前月份的未下市期权, 1 代表下一个到期的期权，依此类推。

  • 对于 ETF 期权来说 1 代表在参数 0 后的下月，2 代表随后的第一个一个季月，3 代表随后的第二个季月

  • 对于股指期权来说 1 代表在参数 0 后的下月，2 代表下下月，3 代表随后第一个季月，4 代表随后第二个季月，5 代表随后第三个季月

has_A (bool): [可选] 是否含有 A，输入 True 代表只含 A 的期权，输入 False 代表不含 A 的期权，默认为 None 不做区分

return:

返回三个列表，分别为实值期权列表、平值期权列表、虚值期权列表。其中，平值期权列表只包含一个元素。

对于看涨期权，返回的实值期权列表、平值期权列表、虚值期权列表其期权行权价依此递增；

对于看跌期权，返回的实值期权列表、平值期权列表、虚值期权列表其期权行权价依此递减。

注：当选择平值期权时，会按以下逻辑进行选择：

  1. 根据用户传入参数来生成一个期权列表，按照到期时间和行权价排序（看涨期权升序排列，看跌期权降序排列，使得实值期权在前、虚值期权在后）。

  2. 将所有的行权价去重排序（看涨期权升序排列，看跌期权降序排列，实值期权在前、虚值期权在后）

  3. 找到与 underlying_price 差值最小的价格为平值期权行权价格，如果有两个行权价与 underlying_price 的差相等，则选取下标大价格的为平值期权行权价格（即两个期权与标的价格距离相等，选取虚值的那个期权作为平值期权）。

  4. 如果有多个行权月份的期权，选取距离行权日期最近的那个作为平值期权（保证平值期权列表只包含一个元素）。

  5. 下标比平值期权小的为实值期权，下标比平值期权大的为虚值期权。

Example1:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SSE.510300")
in_money_options, at_money_options, out_of_money_options = api.query_all_level_finance_options("SSE.510300", quote.last_price, "CALL", nearbys = 1)
print(in_money_options)  # 实值期权列表
print(at_money_options)  # 平值期权列表
print(out_of_money_options)  # 虚值期权列表

Example2:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SSE.510050")
in_money_options, at_money_options, out_of_money_options = api.query_all_level_finance_options("SSE.510050", quote.last_price, "CALL", nearbys=[0,1,2])
print(in_money_options)  # 实值期权列表
print(at_money_options)  # 平值期权列表
print(out_of_money_options)  # 虚值期权列表
query_option_greeks(symbol: str | List[str], v: float | List[float] | None = None, r=0.025) → TqOptionGreeksDataFrame

返回指定期权的希腊指标

Args:
symbol (str / list of str): 指定合约代码或合约代码列表

  • str: 一个合约代码

  • list of str: 合约代码列表

v (float / list of float): 合约对应的波动率

  • float: 一个波动率值，symbol 为 str 类型时，可以只传入一个波动率值

  • list of float: 波动率序列，symbol 为 list 类型时，必须传入与 symbol 数量相同，顺序一一对应的波动率序列

  • None: 默认使用隐含波动率计算

r (float): [可选] 无风险利率

Returns:

pandas.DataFrame: 行数与参数 symbol 的合约数量相同，包含以下列：

  • instrument_id: 合约代码

  • instrument_name: 合约中文名

  • option_class: 期权方向

  • expire_rest_days: 距离到期日的剩余天数

  • expire_datetime: 到期具体日，以秒为单位的 timestamp 值

  • underlying_symbol: 标的合约

  • strike_price: 期权行权价

  • delta: 期权希腊指标 detla 值

  • gamma: 期权希腊指标 gamma 值

  • theta: 期权希腊指标 theta 值

  • vega: 期权希腊指标 vega 值

  • rho: 期权希腊指标 rho 值

Example:

from tqsdk import TqApi, TqAuth
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SSE.510300")
in_money_options, at_money_options, out_of_money_options = api.query_all_level_finance_options("SSE.510300", quote.last_price, "CALL", nearbys = 1)
ls = in_money_options + at_money_options + out_of_money_options  # 期权列表
df = api.query_option_greeks(ls)
print(df.to_string())  # 显示期权希腊指标
api.close()
draw_text(base_k_dataframe: DataFrame, text: str, x: int | None = None, y: float | None = None, id: str | None = None, board: str = 'MAIN', color: str | int = 'red') → None

配合天勤使用时, 在天勤的行情图上绘制一个字符串

Args:

base_k_dataframe (pandas.DataFrame): 基础K线数据序列, 要绘制的K线将出现在这个K线图上. 需要画图的数据以附加列的形式存在

text (str): 要显示的字符串

x (int): X 坐标, 以K线的序列号表示. 可选, 缺省为对齐最后一根K线,

y (float): Y 坐标. 可选, 缺省为最后一根K线收盘价

id (str): 字符串ID, 可选. 以相同ID多次调用本函数, 后一次调用将覆盖前一次调用的效果

board (str): 选择图板, 可选, 缺省为 "MAIN" 表示绘制在主图

color (str/int): 文本颜色, 可选, 缺省为 "red"

  • str : 符合 CSS Color 命名规则的字符串, 例如: "red", "#FF0000", "#FF0000FF", "rgb(255, 0, 0)", "rgba(255, 0, 0, .5)"

  • int : 十六进制整数表示颜色, ARGB, 例如: 0xffff0000

Example:

# 在主图最近K线的最低处标一个"最低"文字
klines = api.get_kline_serial("SHFE.cu1905", 86400)
indic = np.where(klines.low == klines.low.min())[0]
value = klines.low.min()
api.draw_text(klines, "测试413423", x=indic, y=value, color=0xFF00FF00)
draw_line(base_k_dataframe: DataFrame, x1: int, y1: float, x2: int, y2: float, id: str | None = None, board: str = 'MAIN', line_type: str = 'LINE', color: str | int = 'red', width: int = 1) → None

配合天勤使用时, 在天勤的行情图上绘制一个直线/线段/射线

Args:

base_k_dataframe (pandas.DataFrame): 基础K线数据序列, 要绘制的K线将出现在这个K线图上. 需要画图的数据以附加列的形式存在

x1 (int): 第一个点的 X 坐标, 以K线的序列号表示

y1 (float): 第一个点的 Y 坐标

x2 (int): 第二个点的 X 坐标, 以K线的序列号表示

y2 (float): 第二个点的 Y 坐标

id (str): 字符串ID, 可选. 以相同ID多次调用本函数, 后一次调用将覆盖前一次调用的效果

board (str): 选择图板, 可选, 缺省为 "MAIN" 表示绘制在主图

line_type (str): 画线类型, 目前只支持 "SEG" 线段

color (str/int): 线颜色, 可选, 缺省为 "red"

  • str : 符合 CSS Color 命名规则的字符串, 例如: "red", "#FF0000", "#FF0000FF", "rgb(255, 0, 0)", "rgba(255, 0, 0, .5)"

  • int : 十六进制整数表示颜色, ARGB, 例如: 0xffff0000

width (int): 线宽度, 可选, 缺省为 1

draw_box(base_k_dataframe: DataFrame, x1: int, y1: float, x2: int, y2: float, id: str | None = None, board: str = 'MAIN', bg_color: str | int = 'black', color: str | int = 'red', width: int = 1) → None

配合天勤使用时, 在天勤的行情图上绘制一个矩形

Args:

base_k_dataframe (pandas.DataFrame): 基础K线数据序列, 要绘制的K线将出现在这个K线图上. 需要画图的数据以附加列的形式存在

x1 (int): 矩形左上角的 X 坐标, 以K线的序列号表示

y1 (float): 矩形左上角的 Y 坐标

x2 (int): 矩形右下角的 X 坐标, 以K线的序列号表示

y2 (float): 矩形右下角的 Y 坐标

id (str): ID, 可选. 以相同ID多次调用本函数, 后一次调用将覆盖前一次调用的效果

board (str): 选择图板, 可选, 缺省为 "MAIN" 表示绘制在主图

bg_color (str/int): 填充颜色, 可选, 缺省为 "black"

  • str : 符合 CSS Color 命名规则的字符串, 例如: "red", "#FF0000", "#FF0000FF", "rgb(255, 0, 0)", "rgba(255, 0, 0, .5)"

  • int : 十六进制整数表示颜色, ARGB, 例如: 0xffff0000

color (str/int): 边框颜色, 可选, 缺省为 "red"

  • str : 符合 CSS Color 命名规则的字符串, 例如: "red", "#FF0000", "#FF0000FF", "rgb(255, 0, 0)", "rgba(255, 0, 0, .5)"

  • int : 十六进制整数表示颜色, ARGB, 例如: 0xffff0000

width (int): 边框宽度, 可选, 缺省为 1

Example:

# 给主图最后5根K线加一个方框
klines = api.get_kline_serial("SHFE.cu1905", 86400)
api.draw_box(klines, x1=-5, y1=klines.iloc[-5].close, x2=-1,             y2=klines.iloc[-1].close, width=1, color=0xFF0000FF, bg_color=0x8000FF00)
draw_report(report_datas)

配合 web_gui 使用时, 在天勤的回测报告中绘制成交统计的图表