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): [必填]用户快期账户:
TqAuth
: 添加快期账户类,例如:TqAuth("tianqin@qq.com", "123456")str: 用户权限认证对象为天勤用户论坛的邮箱和密码,中间以英文逗号分隔,例如: "tianqin@qq.com,123456" 快期账户注册链接 https://www.shinnytech.com/register-intro/
- 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 [默认]: 根据账户情况不同,默认值的行为不同。
True: 调试信息会输出到指定文件夹 ~/.tqsdk/logs。
False: 不输出调试信息。
str: 指定一个日志文件名, 调试信息输出到指定文件。
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("快期账户", "账户密码"))
- 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
获取指定合约的交易状态. 此接口为 TqSdk 专业版提供,便于实现开盘抢单功能。
如果想使用此功能,可以点击 天勤量化专业版 申请试用或购买
- 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线的说明:
主合约的字段名为原始K线数据字段,从第一个副合约开始,字段名在原始字段后加数字,如第一个副合约的开盘价为 "open1" , 第二个副合约的收盘价为 "close2"。
每条K线都包含了订阅的所有合约数据,即:如果任意一个合约(无论主、副)在某个时刻没有数据(即使其他合约在此时有数据), 则不能对齐,此多合约K线在该时刻那条数据被跳过,现象表现为K线不连续(如主合约有夜盘,而副合约无夜盘,则生成的多合约K线无夜盘时间的数据)。
若设置了较大的序列长度参数,而所有可对齐的数据并没有这么多,则序列前面部分数据为NaN(这与获取单合约K线且数据不足序列长度时情况相似)。
若主合约与副合约的交易时间在所有合约数据中最晚一根K线时间开始往回的 10000*周期 时间段内完全不重合,则无法生成多合约K线,程序会报出获取数据超时异常。
datetime、duration是所有合约公用的字段,则未单独为每个副合约增加一份副本,这两个字段使用原始字段名(即没有数字后缀)。
暂不支持复权 获取多合约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_professional/。
该函数返回的对象不会更新,不建议在循环内调用该方法。
- 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_professional/。
该函数返回的对象不会更新,不建议在循环内调用该方法。
- 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
获取一段时间内的交易日历信息,交易日历可以处理的范围为 2003-01-01 ~ 2024-12-31。
- 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 天的标的,可以处理的范围为 2003-01-01 ~ 2022-12-31。
- 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
添加一项风控规则实例,此接口为 TqSdk 专业版提供。
如需使用此功能,可以点击 天勤量化专业版 申请试用或购买
- Args:
rule (TqRiskRule): 风控规则实例,必须是 TqRiskRule 的子类型
- delete_risk_rule(rule: TqRiskRule) None
删除一项风控规则实例,此接口为 TqSdk 专业版提供。
如需使用此功能,可以点击 天勤量化专业版 申请试用或购买
- 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_ranking(symbol: str, ranking_type: str, days: int = 1, start_dt: date | None = None, broker: str | None = None) TqSymbolRankingDataFrame
查询合约成交排名/持仓排名
本接口仅限专业版用户使用,如需购买专业版或者申请试用,请访问 https://www.shinnytech.com/tqsdk_professional/。
该函数返回的对象不会更新,不建议在循环内调用该方法。
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。
数据更新时间: 18:30~19:00。 用户在交易日 19:00 之前可以查询当前交易日之前的所有数据,19:00 之后可以查询包括当前交易日的数据。
数据支持范围:从 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不做区分
注:当选择平值期权时,会按以下逻辑进行选择:
根据用户传入参数来生成一个期权列表,在这个期权列表中来选择是否有和传入价格相比的平值期权并返回
如果没有符合的平值期权,则取行权价距离传入价格绝对值相差最小的期权作为平值期权
如果存在最近的两个期权的行权价到传入价格的绝对值最小且相等,则取虚值的那个期权作为平值期权,其他档位期权依次展开
- 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 类型
注意:
回测时,以下字段值为 nan: "upper_limit", "lower_limit", "pre_settlement", "pre_open_interest", "pre_close"
中金所合约未提供涨停价、跌停价
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:
返回三个列表,分别为实值期权列表、平值期权列表、虚值期权列表。其中,平值期权列表只包含一个元素。
对于看涨期权,返回的实值期权列表、平值期权列表、虚值期权列表其期权行权价依此递增;
对于看跌期权,返回的实值期权列表、平值期权列表、虚值期权列表其期权行权价依此递减。
注:当选择平值期权时,会按以下逻辑进行选择:
根据用户传入参数来生成一个期权列表,在这个期权列表中来选择是否有和传入价格相比的平值期权并返回
如果没有符合的平值期权,则取行权价距离传入价格绝对值相差最小的期权作为平值期权
如果存在最近的两个期权的行权价到传入价格的绝对值最小且相等,则取虚值的那个期权作为平值期权,其他档位期权依次展开
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:
返回三个列表,分别为实值期权列表、平值期权列表、虚值期权列表。其中,平值期权列表只包含一个元素。
对于看涨期权,返回的实值期权列表、平值期权列表、虚值期权列表其期权行权价依此递增;
对于看跌期权,返回的实值期权列表、平值期权列表、虚值期权列表其期权行权价依此递减。
注:当选择平值期权时,会按以下逻辑进行选择:
根据用户传入参数来生成一个期权列表,按照到期时间和行权价排序(看涨期权升序排列,看跌期权降序排列,使得实值期权在前、虚值期权在后)。
将所有的行权价去重排序(看涨期权升序排列,看跌期权降序排列,实值期权在前、虚值期权在后)
找到与 underlying_price 差值最小的价格为平值期权行权价格,如果有两个行权价与 underlying_price 的差相等,则选取下标大价格的为平值期权行权价格(即两个期权与标的价格距离相等,选取虚值的那个期权作为平值期权)。
如果有多个行权月份的期权,选取距离行权日期最近的那个作为平值期权(保证平值期权列表只包含一个元素)。
下标比平值期权小的为实值期权,下标比平值期权大的为虚值期权。
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 使用时, 在天勤的回测报告中绘制成交统计的图表