基本使用

t10 - 获取实时行情

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

from tqsdk import TqApi, TqAuth

# 创建API实例,传入自己的快期账户
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
# 获得上期所 ni2206 的行情引用，当行情有变化时 quote 中的字段会对应更新
quote = api.get_quote("SHFE.ni2206")

# 输出 ni2206 的最新行情时间和最新价
print(quote.datetime, quote.last_price)

# 关闭api,释放资源
api.close()

t20 - 识别行情更新

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

from tqsdk import TqApi, TqAuth

# 可以指定debug选项将调试信息写入指定的文件中
api = TqApi(debug="debug.log", auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("CZCE.FG209")
print(quote.datetime, quote.last_price, quote.ask_price1, quote.ask_price2)

while True:
    # 调用 wait_update 等待业务信息发生变化，例如: 行情发生变化, 委托单状态变化, 发生成交等等
    # 注意：其他合约的行情的更新也会触发业务信息变化，因此下面使用 is_changing 判断 FG209 的行情是否有变化
    api.wait_update()
    # 如果 FG209 的任何字段有变化，is_changing就会返回 True
    if api.is_changing(quote):
        print("行情变化", quote)
    # 只有当 FG209 的最新价有变化，is_changing才会返回 True
    if api.is_changing(quote, "last_price"):
        print("最新价变化", quote.last_price)
    # 当 FG209 的买1价/买1量/卖1价/卖1量中任何一个有变化，is_changing都会返回 True
    if api.is_changing(quote, ["ask_price1", "ask_volume1", "bid_price1", "bid_volume1"]):
        print("盘口变化", quote.ask_price1, quote.ask_volume1, quote.bid_price1, quote.bid_volume1)

t30 - 使用K线/Tick数据

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

from tqsdk import TqApi, TqAuth
import datetime

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
# 获得 i2209 tick序列的引用
ticks = api.get_tick_serial("DCE.i2209")
# 获得 i2209 10秒K线的引用
klines = api.get_kline_serial("DCE.i2209", 10)
print(datetime.datetime.fromtimestamp(klines.iloc[-1]["datetime"] / 1e9))

while True:
    api.wait_update()
    # 判断整个tick序列是否有变化
    if api.is_changing(ticks):
        # ticks.iloc[-1]返回序列中最后一个tick
        print("tick变化", ticks.iloc[-1])
    # 判断最后一根K线的时间是否有变化，如果发生变化则表示新产生了一根K线
    if api.is_changing(klines.iloc[-1], "datetime"):
        # datetime: 自unix epoch(1970-01-01 00:00:00 GMT)以来的纳秒数
        print("新K线", datetime.datetime.fromtimestamp(klines.iloc[-1]["datetime"] / 1e9))
    # 判断最后一根K线的收盘价是否有变化
    if api.is_changing(klines.iloc[-1], "close"):
        # klines.close返回收盘价序列
        print("K线变化", datetime.datetime.fromtimestamp(klines.iloc[-1]["datetime"] / 1e9), klines.close.iloc[-1])

t40 - 下单/撤单

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
# 获得 m2105 的持仓引用，当持仓有变化时 position 中的字段会对应更新
position = api.get_position("DCE.m2105")
# 获得资金账户引用，当账户有变化时 account 中的字段会对应更新
account = api.get_account()
# 下单并返回委托单的引用，当该委托单有变化时 order 中的字段会对应更新
order = api.insert_order(symbol="DCE.m2105", direction="BUY", offset="OPEN", volume=5, limit_price=2750)

while True:
    api.wait_update()
    if api.is_changing(order, ["status", "volume_orign", "volume_left"]):
        print("单状态: %s, 已成交: %d 手" % (order.status, order.volume_orign - order.volume_left))
    if api.is_changing(position, "pos_long_today"):
        print("今多头: %d 手" % (position.pos_long_today))
    if api.is_changing(account, "available"):
        print("可用资金: %.2f" % (account.available))

t41 - 开仓/平仓

#!/usr/bin/env python
#  -*- coding: utf-8 -*-

from tqsdk import TqApi, TqAuth

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.ni2206")
# 开仓两手并等待完成
order = api.insert_order(symbol="SHFE.ni2206", direction="BUY", offset="OPEN", limit_price=quote.ask_price1, volume=2)
while order.status != "FINISHED":
    api.wait_update()
print("已开仓")
# 平今两手并等待完成
order = api.insert_order(symbol="SHFE.ni2206", direction="SELL", offset="CLOSETODAY", limit_price=quote.bid_price1,
                         volume=2)
while order.status != "FINISHED":
    api.wait_update()
print("已平今")
# 关闭api,释放相应资源
api.close()

t60 - 单均线策略

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

from tqsdk import TqApi, TqAuth

'''
如果当前价格大于10秒K线的MA15则开多仓 (使用 insert_order() 函数)
如果小于则平仓
'''
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
# 获得 m2207 10秒K线的引用
klines = api.get_kline_serial("DCE.m2207", 10)

# 判断开仓条件
while True:
    api.wait_update()
    if api.is_changing(klines):
        ma = sum(klines.close.iloc[-15:]) / 15
        print("最新价", klines.close.iloc[-1], "MA", ma)
        if klines.close.iloc[-1] > ma:
            print("最新价大于MA: 市价开仓")
            api.insert_order(symbol="DCE.m2207", direction="BUY", offset="OPEN", volume=5)
            break
# 判断平仓条件
while True:
    api.wait_update()
    if api.is_changing(klines):
        ma = sum(klines.close.iloc[-15:]) / 15
        print("最新价", klines.close.iloc[-1], "MA", ma)
        if klines.close.iloc[-1] < ma:
            print("最新价小于MA: 市价平仓")
            api.insert_order(symbol="DCE.m2207", direction="SELL", offset="CLOSE", volume=5)
            break
# 关闭api,释放相应资源
api.close()

t70 - 简单均线策略(目标持仓模型)

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

from tqsdk import TqApi, TqAuth, TargetPosTask

'''
如果当前价格大于10秒K线的MA15则开多仓 (使用 TargetPosTask 调仓工具)
如果小于则平仓
'''
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
# 获得 m2207 10秒K线的引用
klines = api.get_kline_serial("DCE.m2207", 10)
# 创建 m2207 的目标持仓 task，该 task 负责调整 m2207 的仓位到指定的目标仓位
target_pos = TargetPosTask(api, "DCE.m2207")

while True:
    api.wait_update()
    if api.is_changing(klines):
        ma = sum(klines.close.iloc[-15:]) / 15
        print("最新价", klines.close.iloc[-1], "MA", ma)
        if klines.close.iloc[-1] > ma:
            print("最新价大于MA: 目标多头5手")
            # 设置目标持仓为多头5手
            target_pos.set_target_volume(5)
        elif klines.close.iloc[-1] < ma:
            print("最新价小于MA: 目标空仓")
            # 设置目标持仓为空仓
            target_pos.set_target_volume(0)

t71 - 简单趋势策略

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'yanqiong'

from tqsdk import TqApi, TqAuth, TargetPosTask

'''
连续3根阴线就做空，连续3根阳线就做多，否则空仓
'''

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
# 设定连续多少根阳线/阴线
length = 3
# 获得 ni2205 10秒K线的引用, 长度为 length+1
klines = api.get_kline_serial("SHFE.ni2205", 10, data_length=length + 1)
# 创建 ni2205 的目标持仓 task，该 task 负责调整 ni2105 的仓位到指定的目标仓位, offset_priority的用法详见文档
target_pos = TargetPosTask(api, "SHFE.ni2205", offset_priority="今昨开")

while True:
    api.wait_update()
    # 只有在新创建出K线时才判断开平仓条件
    if api.is_changing(klines.iloc[-1], "datetime"):
        # 跳过最后一根刚生成的K线
        df = klines.iloc[:-1]
        # 比较收盘价和开盘价，判断是阳线还是阴线
        # df.close 为收盘价序列, df.open 为开盘价序列, ">"(pandas.Series.gt) 返回收盘价是否大于开盘价的一个新序列
        up = df.close > df.open
        down = df.close < df.open
        if all(up):
            print("连续阳线: 目标持仓 多头1手")
            # 设置目标持仓为正数表示多头，负数表示空头，0表示空仓
            target_pos.set_target_volume(1)
        elif all(down):
            print("连续阴线: 目标持仓 空头1手")
            target_pos.set_target_volume(-1)
        else:
            print("目标持仓: 空仓")
            target_pos.set_target_volume(0)

t72 - 隔夜开盘抢单

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'ringo'

from tqsdk import TqApi, TqAuth
from tqsdk.tafunc import time_to_datetime

'''
使用get_trading_status来判断合约是否进入交易状态来进行下单，该接口需要有天勤量化专业版资格才可使用
'''

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()

t80 - 价差回归策略

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

from tqsdk import TqApi, TqAuth, TargetPosTask

'''
价差回归
当近月-远月的价差大于250时做空近月，做多远月
当价差小于200时平仓
'''
api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote_near = api.get_quote("SHFE.rb2104")
quote_deferred = api.get_quote("SHFE.rb2105")
# 创建 rb2104 的目标持仓 task，该 task 负责调整 rb2104 的仓位到指定的目标仓位
target_pos_near = TargetPosTask(api, "SHFE.rb2104")
# 创建 rb2105 的目标持仓 task，该 task 负责调整 rb2105 的仓位到指定的目标仓位
target_pos_deferred = TargetPosTask(api, "SHFE.rb2105")

while True:
    api.wait_update()
    if api.is_changing(quote_near) or api.is_changing(quote_deferred):
        spread = quote_near.last_price - quote_deferred.last_price
        print("当前价差:", spread)
        if spread > 250:
            print("目标持仓: 空近月，多远月")
            # 设置目标持仓为正数表示多头，负数表示空头，0表示空仓
            target_pos_near.set_target_volume(-1)
            target_pos_deferred.set_target_volume(1)
        elif spread < 200:
            print("目标持仓: 空仓")
            target_pos_near.set_target_volume(0)
            target_pos_deferred.set_target_volume(0)

t90 - 在主图中画指标线

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'limin'

from tqsdk import TqApi, TqAuth
from tqsdk.ta import MA

'''
画图示例: 在主图中画指标线
注意: 画图示例中用到的数据不含有实际意义，请根据自己的实际策略情况进行修改
'''

api = TqApi(web_gui=True, auth=TqAuth("快期账户", "账户密码"))  # web_gui=True, 开启使用 web 界面查看绘图结果的功能
klines = api.get_kline_serial("SHFE.rb2105", 5)

# 画一次指标线
ma = MA(klines, 30)  # 使用 tqsdk 自带指标函数计算均线
klines["ma_MAIN"] = ma.ma  # 在主图中画一根默认颜色（红色）的 ma 指标线

# 由于需要在浏览器中查看绘图结果，因此程序不能退出
while True:
    api.wait_update()

t91 - 在附图中画指标线

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'limin'

from tqsdk import TqApi, TqAuth
from tqsdk.ta import MA

'''
画图示例: 在附图中画指标线
(将画图代码放在循环中即可使图像随着行情推进而更新)
注意: 画图示例中用到的数据不含有实际意义，请根据自己的实际策略情况进行修改
'''

api = TqApi(web_gui=":9878", auth=TqAuth("快期账户", "账户密码"))  # web_gui="[ip]:port", 指定 web 界面地址的 ip 和 port
klines = api.get_kline_serial("SHFE.rb2105", 24 * 60 * 60)

while True:
    # 将画图代码放在循环中即可使图像随着行情推进而更新
    ma = MA(klines, 30)  # 使用tqsdk自带指标函数计算均线

    # 示例1: 在附图中画一根绿色的ma指标线
    klines["ma_B2"] = ma.ma
    klines["ma_B2.board"] = "B2"  # 设置附图: 可以设置任意字符串,同一字符串表示同一副图
    klines["ma_B2.color"] = "green"  # 设置为绿色. 以下设置颜色方式都可行: "green", "#00FF00", "rgb(0,255,0)", "rgba(0,125,0,0.5)"

    # 示例2: 在另一个附图画一根比ma小4的宽度为4的紫色指标线
    klines["ma_4"] = ma.ma - 4
    klines["ma_4.board"] = "MA4"  # 设置为另一个附图
    klines["ma_4.color"] = 0xFF9933CC  # 设置为紫色, 或者 "#9933FF"
    klines["ma_4.width"] = 4  # 设置宽度为4，默认为1

    api.wait_update()

t92 - 主图中画信号线及文字标注

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'limin'

from tqsdk import TqApi, TqAuth

'''
画图示例: 在主图中画信号线及文字标注
注意: 画图示例中用到的数据不含有实际意义，请根据自己的实际策略情况进行修改
'''

api = TqApi(web_gui=True, auth=TqAuth("快期账户", "账户密码"))  # web_gui=True, 开启使用 web 界面查看绘图结果的功能
klines = api.get_kline_serial("SHFE.rb2105", 300)

# 示例1: 在主图中最后一根K线上画射线以标注需要的信号
api.draw_line(klines, -1, klines.iloc[-1].close, -1, klines.iloc[-1].high, line_type="SEG", color=0xFFFF9900, width=3)

# 示例2: 绘制字符串
api.draw_text(klines, "信号1", x=-1, y=klines.iloc[-1].high + 5, color=0xFFFF3333)

# 示例3: 给主图最后5根K线加一个方框
api.draw_box(klines, x1=-5, y1=klines.iloc[-5]["high"], x2=-1, y2=klines.iloc[-1]["low"], width=1, color=0xFF0000FF,
             bg_color=0x7000FF00)

# 由于需要在浏览器中查看绘图结果，因此程序不能退出
while True:
    api.wait_update()

t93 - 在主图中画线和方框

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'limin'

from tqsdk import TqApi, TqAuth

'''
画图示例: 在主图中画线和方框
注意: 画图示例中用到的数据不含有实际意义，请根据自己的实际策略情况进行修改
'''

api = TqApi(web_gui=True, auth=TqAuth("快期账户", "账户密码")) # web_gui=True, 开启使用 web 界面查看绘图结果的功能
klines = api.get_kline_serial("SHFE.rb2105", 60)

# 由于需要在浏览器中查看绘图结果，因此程序不能退出
while True:
    api.wait_update() # 当有业务信息发生变化时执行
    # 当最后 1 根柱子最大最小值价差大于 0.05 时，在主图绘制信号
    high = klines.iloc[-1].high
    low = klines.iloc[-1].low
    if high - low > 0.05:
        # 绘制直线, 每一个 id 对应同一条直线
        api.draw_line(klines, -1, high, -1, low, id="box%.0f" % (klines.iloc[-1].id), color=0xaa662244, width=4)
        # 绘制字符串
        api.draw_text(klines, "信号1", x=-1, y=low, id="text%.0f" % (klines.iloc[-1].id), color=0xFFFF3333)

t94 - 在附图中画K线

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'limin'

from tqsdk import TqApi, TqAuth

'''
画图示例: 在附图中画K线
注意: 画图示例中用到的数据不含有实际意义，请根据自己的实际策略情况进行修改
'''

api = TqApi(web_gui=True, auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("SHFE.rb2104", 86400)
klines2 = api.get_kline_serial("SHFE.rb2105", 86400)

while True:
    # 将画图代码放在循环中即可使图像随着行情推进而更新
    # 在附图画出 rb2105 的K线: 需要将open、high、log、close的数据都设置正确
    klines["rb2105.open"] = klines2["open"]
    klines["rb2105.high"] = klines2["high"]
    klines["rb2105.low"] = klines2["low"]
    klines["rb2105.close"] = klines2["close"]
    klines["rb2105.board"] = "B2"
    api.wait_update()

t95 - 附图中画K线、线段和方框

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'limin'

from tqsdk import TqApi, TqAuth
from tqsdk.ta import MA

'''
画图示例: 在同一附图中画K线、线段和方框
注意: 画图示例中用到的数据不含有实际意义，请根据自己的实际策略情况进行修改
'''

api = TqApi(web_gui=True, auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.T2103", 10)
klines2 = api.get_kline_serial("CFFEX.T2012", 10)

# 示例1 : 在附图画出 T2012 的K线: 需要将open、high、log、close的数据都设置正确
klines["T2012.open"] = klines2["open"]
klines["T2012.high"] = klines2["high"]
klines["T2012.low"] = klines2["low"]
klines["T2012.close"] = klines2["close"]
klines["T2012.board"] = "B2"
ma = MA(klines, 30)
klines["ma_MAIN"] = ma.ma

# 示例2: 在附图中画线段(默认为红色)
api.draw_line(klines, -10, klines2.iloc[-10].low, -3, klines2.iloc[-3].high, id="my_line", board="B2", line_type="SEG",
              color=0xFFFF00FF, width=3)

# 示例3: 在附图K线上画黄色的方框: 需要设置画在附图时, 将board参数选择到对应的图板即可
api.draw_box(klines, x1=-5, y1=klines2.iloc[-5]["high"], x2=-1, y2=klines2.iloc[-1]["low"], id="my_box", board="B2",
             width=1, color=0xFF0000FF, bg_color=0x70FFFF00)

# 由于需要在浏览器中查看绘图结果，因此程序不能退出
while True:
    api.wait_update()

t96 - 附图中画MACD

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'yanqiong'

from tqsdk import TqApi, TqAuth
from tqsdk.ta import MACD

'''
画图示例: 在附图中画 macd 指标示例
注意: 画图示例中用到的数据不含有实际意义，请根据自己的实际策略情况进行修改
'''

def calc_macd_klines(klines):
    # 计算 macd 指标
    macd = MACD(klines, 12, 26, 9)
    # 用 K 线图模拟 MACD 指标柱状图
    klines["MACD.open"] = 0.0
    klines["MACD.close"] = macd["bar"]
    klines["MACD.high"] = klines["MACD.close"].where(klines["MACD.close"] > 0, 0)
    klines["MACD.low"] = klines["MACD.close"].where(klines["MACD.close"] < 0, 0)
    klines["MACD.board"] = "MACD"
    # 在 board=MACD 上添加 diff、dea 线
    klines["diff"] = macd["diff"]
    klines["diff.board"] = "MACD"
    klines["diff.color"] = "gray"
    klines["dea"] = macd["dea"]
    klines["dea.board"] = "MACD"
    klines["dea.color"] = "rgb(255,128,0)"


api = TqApi(auth=TqAuth("快期账户", "账户密码"), web_gui=True)
klines = api.get_kline_serial("SHFE.rb2105", 5*60, 200)
while True:
    calc_macd_klines(klines)
    api.wait_update()

underlying_symbol - 获取主连映射主力合约

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = "Ringo"

from tqsdk import TqApi, TqAuth

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

# 订阅螺纹钢主连
quote = api.get_quote("KQ.m@SHFE.rb")
# 打印现在螺纹钢主连的标的合约
print(quote.underlying_symbol)

api.close()

backtest - 回测

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

from datetime import date
from tqsdk import TqApi, TqAuth, TqBacktest, TargetPosTask

'''
如果当前价格大于5分钟K线的MA15则开多仓
如果小于则平仓
回测从 2018-05-01 到 2018-10-01
'''
# 在创建 api 实例时传入 TqBacktest 就会进入回测模式
api = TqApi(backtest=TqBacktest(start_dt=date(2018, 5, 1), end_dt=date(2018, 10, 1)), auth=TqAuth("快期账户", "账户密码"))
# 获得 m1901 5分钟K线的引用
klines = api.get_kline_serial("DCE.m1901", 5 * 60, data_length=15)
# 创建 m1901 的目标持仓 task，该 task 负责调整 m1901 的仓位到指定的目标仓位
target_pos = TargetPosTask(api, "DCE.m1901")

while True:
    api.wait_update()
    if api.is_changing(klines):
        ma = sum(klines.close.iloc[-15:]) / 15
        print("最新价", klines.close.iloc[-1], "MA", ma)
        if klines.close.iloc[-1] > ma:
            print("最新价大于MA: 目标多头5手")
            # 设置目标持仓为多头5手
            target_pos.set_target_volume(5)
        elif klines.close.iloc[-1] < ma:
            print("最新价小于MA: 目标空仓")
            # 设置目标持仓为空仓
            target_pos.set_target_volume(0)

downloader - 下载数据

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

from datetime import datetime
from contextlib import closing
from tqsdk import TqApi, TqAuth
from tqsdk.tools import DataDownloader

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
# 下载从 2018-01-01凌晨6点 到 2018-06-01下午4点 的 cu1805 分钟线数据
kd = DataDownloader(api, symbol_list="SHFE.cu1805", dur_sec=60,
                    start_dt=datetime(2018, 1, 1, 6, 0 ,0), end_dt=datetime(2018, 6, 1, 16, 0, 0), csv_file_name="kline.csv")
# 下载从 2018-05-01凌晨0点 到 2018-07-01凌晨0点 的 T1809 盘口Tick数据
td = DataDownloader(api, symbol_list="CFFEX.T1809", dur_sec=0,
                    start_dt=datetime(2018, 5, 1), end_dt=datetime(2018, 7, 1), csv_file_name="tick.csv")
# 使用with closing机制确保下载完成后释放对应的资源
with closing(api):
    while not kd.is_finished() or not td.is_finished():
        api.wait_update()
        print("progress: kline: %.2f%% tick:%.2f%%" % (kd.get_progress(), td.get_progress()))

downloader_orders - 下载委托单和成交记录

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'yanqiong'

import csv
import os
from datetime import datetime

from tqsdk import TqApi, TqAuth, TqKq


"""
本示例用于下载账户当前交易日到目前位置的全部委托单、成交记录分别到 orders.csv、trades.csv 文件。

如果文件已经存在，会将记录追加到文件末尾。

用户可以在交易日结束之后，运行本示例，可以将当日的委托单、成交记录保存到本地。
"""


order_cols = ["order_id", "exchange_order_id", "exchange_id", "instrument_id", "direction", "offset", "status", "volume_orign", "volume_left", "limit_price", "price_type", "volume_condition", "time_condition", "insert_date_time", "last_msg"]
trade_cols = ["trade_id", "order_id", "exchange_trade_id", "exchange_id", "instrument_id", "direction", "offset", "price", "volume", "trade_date_time"]


def write_csv(file_name, cols, datas):
    file_exists = os.path.exists(file_name) and os.path.getsize(file_name) > 0
    with open(file_name, 'a', newline='') as csvfile:
        csv_writer = csv.writer(csvfile, dialect='excel')
        if not file_exists:
            csv_writer.writerow(['datetime'] + cols)
        for item in datas.values():
            if 'insert_date_time' in cols:
                dt = datetime.fromtimestamp(item['insert_date_time'] / 1e9).strftime('%Y-%m-%d %H:%M:%S.%f')
            elif 'trade_date_time' in cols:
                dt = datetime.fromtimestamp(item['trade_date_time'] / 1e9).strftime('%Y-%m-%d %H:%M:%S.%f')
            else:
                dt = None
            row = [dt] + [item[k] for k in cols]
            csv_writer.writerow(row)


with TqApi(TqKq(), auth=TqAuth("快期账户", "账户密码")) as api:
    # 将当前账户下全部委托单、成交信息写入 csv 文件中
    write_csv("orders.csv", order_cols, api.get_order())
    write_csv("trades.csv", trade_cols, api.get_trade())

ta - 指标计算

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'chengzhi'

import datetime
from tqsdk import TqApi, TqAuth
from tqsdk.ta import *

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
# 获得 cu1909 10秒K线的引用
klines = api.get_kline_serial("SHFE.cu1910", 10, data_length=3000)

print("K线时间", datetime.datetime.fromtimestamp(klines.iloc[-1]["datetime"] / 1e9))
print(klines)

print("ATR", ATR(klines, 26))
print("BIAS", BIAS(klines, 6))
print("BOLL", BOLL(klines, 3, 5))
print("DMI", DMI(klines, 14, 6))
print("KDJ", KDJ(klines, 9, 3, 3))
print("MA", MA(klines, 3))
print("MACD", MACD(klines, 20, 35, 10))
print("SAR", SAR(klines, 4, 0.02, 0.2))

api.close()

ta_option - 期权指标计算

#!usr/bin/env python3
#-*- coding:utf-8 -*-

from tqsdk import TqApi, TqAuth, tafunc
from tqsdk.ta import *

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

underlying_quote = api.get_quote("SHFE.cu2009")
klines = api.get_kline_serial('SHFE.cu2009', 24 * 60 * 60, 20)
v = tafunc.get_his_volatility(klines, underlying_quote)
print("历史波动率:", v)

quote = api.get_quote("SHFE.cu2009C44000")
bs_serise = BS_VALUE(klines, quote, 0.025)
print("理论价:", list(round(bs_serise['bs_price'], 2)))


klines2 = api.get_kline_serial(["SHFE.cu2009C44000", "SHFE.cu2009"], 24 * 60 * 60, 20)

values = OPTION_VALUE(klines2, quote)
print("内在价值:", list(values["intrins"]))
print("时间价值:", list(values["time"]))

impv = OPTION_IMPV(klines2, quote, 0.025)
print("隐含波动率:", list(round(impv['impv'] * 100, 2)))

greeks = OPTION_GREEKS(klines2, quote, 0.025, impv['impv'])
print("delta:", list(greeks["delta"]))
print("theta:", list(greeks["theta"]))
print("gamma:", list(greeks["gamma"]))
print("vega:", list(greeks["vega"]))
print("rho:", list(greeks["rho"]))

api.close()

multiaccount - 多账户

#!/usr/bin/env python
#  -*- coding: utf-8 -*-
__author__ = 'hongyan'

from tqsdk import TqApi, TqAuth, TqAccount, TqKq, TqSim, TqMultiAccount
# 多账户模式下, 同时操作实盘、模拟交易和快期模拟账户交易
tqact = TqAccount("H海通期货", "123456", "123456")
sim = TqSim()
kq = TqKq()

with TqApi(TqMultiAccount([tqact, sim, kq]), auth=TqAuth("快期账户", "账户密码")) as api:
    order1 = api.insert_order(symbol="DCE.m2101", direction="BUY", offset="OPEN", volume=5, account=tqact)
    order2 = api.insert_order(symbol="SHFE.au2012C308", direction="BUY", offset="OPEN", volume=5, limit_price=78.1, account=sim)
    order3 = api.insert_order(symbol="SHFE.cu2101", direction="Sell", offset="OPEN", volume=10, limit_price=51610, account=kq)
    api.cancel_order(order3, kq)
    while order1.status != "FINISHED" or order2.status != "FINISHED":
        api.wait_update()
    # 分别获取账户资金信息
    account_info1 = tqact.get_account()
    account_info2 = sim.get_account()
    account_info3 = kq.get_account()
    # 分别获取账户持仓信息
    position1 = tqact.get_position("DCE.m2101", )
    position2 = sim.get_position()
    position3 = kq.get_position()
    # 分别获取账户委托数据
    orders1 = tqact.get_order(order_id=order1.order_id, )
    orders2 = sim.get_position()
    orders3 = kq.get_position()
    # 分别获取账户成交数据
    trades1 = tqact.get_trade()
    trades2 = sim.get_trade()
    trades3 = kq.get_trade()