迅投QMT开发上手指南
基于官方知识库，写给股民朋友们的迅投内置Python开发入门指南
【腾讯文档】迅投QMT开发上手指南 https://docs.qq.com/doc/DR1dTc2d6T3hUUGFz
# 0） 安装软件
本文档由 智能交易*姚 个人维护 vx: 21523544，欢迎加入QQ群：861129742 基于 迅投官方知识库（https://dict.thinktrader.net/?id=PN4WZC）
迅投QMT 是一款国产的量化交易工具。类似于通达信、同花顺、大智慧、文华财经等，是国内A股、期货市场上，投资者电脑（PC）上应用的一套软件，目前（2024年）还没有手机端的应用App。目前已经 覆盖了绝大部分的券商和期货公司。支持 Python 语言编程，同时兼容 VBA 公式的运用。
安装迅投QMT最低配置只需要 Windows 7 x 32 位操作系统即可，但强烈建议还是用 Win10 x 64位以上的操作系统吧，别怀旧了。内存建议 8G - 16G，硬盘至少 1T以上了吧，现在硬件真的不贵了。何必为难自己呢。
获取迅投QMT最简单的方式就是直接找你的客户经理，从券商那里获得一个安装文件比较可靠，同时也能获取一个或多个仿真帐户，用于之后的练习操作，简单方便。（然后你会发现客户经理一问三不知，牛头不对马嘴。还是得靠自己啊。）
我看看，都4202年了，还有谁不知道 迅投的投研版是可以直接下载试用的？同时还可以申请A股和期货的仿真帐号，24小时都可以模拟交易。链接如下： https://xuntou.net/#/download?id=PN4WZC 普通券商版的，也可以通过网页，全程自助下载，申请仿真帐号。通常24小时之内就可以用上了。
一，需要先申请一个 迅投 的帐号，以便登入 迅投 的软件，通常是 手机号。（不用挣扎了，天朝之下谈什么隐私嘛。）并且，要求开通 程序化交易 的权限，才有用。
二，需要至少一个仿真帐号，就是一个可以交易股票的模拟帐号。并且这个帐号也需要开通 程序化交易 的权限，并且这个程序化交易特指是 来自迅投QMT的程序化交易指令，用别的程序化还不行！
到目前为止 ，国信证券的 iQuant （就是迅投QMT换了个名）仍然是 0 门坎，完全免费。网页上直接申请，一步到位。
国信证券的 iQuant 可访问下面的链接直接下载： https://www.guosen.com.cn/gs/iquant/index.html
下载后可得到一个安装文件包，解压安装即可。以上操作如果有疑问，可参考视频内容，更加流畅直观。或在线寻求帮助。
如前所述，迅投QMT目前流行的版本，主要为 券商提供的普通版，和官方推行的投研版（高级版）。2者都包含 miniQMT 库，有经验的 Python 开发者可以作为一个第三方库导入使用。
本文档主要介绍 迅投QMT 中 内置 的 Python 语言调用的方法。暂不涉及 miniQMT ，VBA 等内容。其中 迅投QMT投研版 中用到的高级函数和功能，也会在文档中标注，敬请留意。
相关文档、视频也可通过以下链接观看： B站视频 https://www.bilibili.com/video/BV1rh4y1z7e3/?spm_id_from=333.337.search-card.all.click 迅投视频中心的课程 https://www.xuntou.net/plugin.php?id=keke_video_base&ac=list&cid=1&scid=5&user_code=PN4WZC
如果你是一名初学者，希望本文档能成为你的入门指引。从上手安装软件 到 运行你的第一个量化程序。通过实例建立起基本概念，从而打开你的思路，进入量化交易的世界，进而成为你终身事业版图中的一块拼图，即是本文档的意义所在。
如果你是一名有经验 Python 开发人员，那么本文档对你而言就是一个简明参考手册。在开发过程中，调用需要的函数即可。在目录大纲中，我已尽可能的按功能需求做了编号。希望能帮助到你快速的找到需求对应的方法。同时欢迎你随时提出宝贵意见，不胜感谢。
如果你完全不了解量化交易，更没有 Python语言的基础。就是要硬啃本文档，那......劝退吧！（我就是这么傲骄！咋的！！）建议从本人写的另一个文档开始，即 Python 语言基础，链接如下： Python 基础文档 https://zilchyao.github.io/python/
如果你还对其它量化工具感兴趣，也可以参考本人创建的其它文档。同样欢迎各种高手、大神们的不吝赐教。 MQL5中文手册线上精校版 https://zilchyao.github.io/mql5yao 新手小白 功夫量化上手指南 https://zilchyao.github.io/kungfu
安装过程。一路点击 next 即可，此过程就不再赘述。 安装完成，成功登录之后，请先检查以下3点：
# 0.1 下载 Python 库
如果用 Python 语言做为开发语言，请先下载 Python库。 请参考下图操作（如图片显示太小，不清晰。可用鼠标右键点击图片，然后在菜单中点击 “在新标签页中打开图像”，即可看到高清大图 ）：
点击界面顶部的“设置”铵钮，然后在弹出的 系统设置 窗口中，点击 “交易设置” 最下面的 “模型设置” ，然后点击 Python库下载。下载过程中，请不要断网。如果很卡慢，也可以直接找券商技术支持部门要一个压缩包。
迅投QMT自带的 Python 环境
| 名称 | 说明 |
|---|---|
| NumPy | NumPy (Numeric Python) 提供了许多高级的数值编程工具。 |
| Pandas | Python Data Analysis Library 或 Pandas 是基于 NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 |
| Patsy | 一个线性模型分析和构建工具库。 |
| SciPy | SciPy 函数库在 NumPy 库的基础上增加了众多的数学、科学以及工程计算中常用的库函数。例如线性代数、常微分方程数值求解、信号处理、图像处理、稀疏矩阵等等。 |
| Statsmodels | Python 的统计建模和计量经济学工具包，包括一些描述统计、统计模型估计和推断。 |
| TA_Lib | 技术分析库，是一种广泛用在程序化交易中进行金融市场数据的技术分析的函数库。 |
TIP
迅投自带 Python 版本 3.6 版。因此无需再安装 Python 相关的软件。
新手用户无需过多关注，直接使用就可以了。有Python基础的朋友可以通过下面的操作来查看一下这些库的版本号：
第一步，在主界面中点击 “新建策略”按钮，选择“Python 策略”，打开代码编辑窗口；
第二步，把下列代码粘帖到文本窗口中；
# coding:gbk
import sys,numpy,pandas,patsy,scipy,statsmodels,talib
print()
print("Python的版本是：",sys.version)
print("模块 NumPy 的版本是：",numpy.__version__)
print("模块 Pandas 的版本是：",pandas.__version__)
print("模块 Patsy 的版本是：",patsy.__version__)
print("模块 SciPy 的版本是：",scipy.__version__)
print("模块 statsmodels 的版本是：",statsmodels.__version__)
print("模块 TA-Lib 的版本是：",talib.__version__)
"""
运行结果:
Python的版本是： 3.6.8 (default, Dec 19 2022, 22:05:09) [MSC v.1900 64 bit (AMD64)]
模块 NumPy 的版本是： 1.19.1
模块 Pandas 的版本是： 0.22.0
模块 Patsy 的版本是： 0.5.0
模块 SciPy 的版本是： 1.5.2
模块 statsmodels 的版本是： 0.12.0
模块 TA-Lib 的版本是： 0.4.17
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
第三步，点击策略代码编辑器顶部的“编译”按钮；
第四步，点击“运行”按钮，即可 在日志窗口中看到相关信息。
# 0.2 补充历史数据
1） 点击界面顶部的 “操作” 铵钮；
2） 然后在出现的下拉菜单中点击选择 “数据管理”；
3） 然后在弹出的 数据管理 窗口中点击 “补充数据” ；
4） 在左侧，可以勾选交易所，选择数据类型；通常勾选上海和深圳交易所，K线数据；也可以根据自己的需要选择；
5） 在右侧，可以选择数据范围；如最近1月，1分钟数据；
6） 决定之后记得点击 开始。
即会开始下载数据，视数据量大小，所需的时间不同。
TIP
建议在休盘时间下载数据，速度较快。请尽可能下载好 1分钟的 K线数据以备用。另 投研版 与 普通券商版 提供的数据 有所差别。但基本的 K线数据、财务数据等，都是与交易所保持一致的。
# 0.3 绑定模拟帐户
确认模拟帐户是否已绑定到讯投的终端中。国信的iQuant自带仿真帐户，可以略过此步骤。如果没有看到模拟帐号，需手动添加，请按下图所示操作：
点击界面顶部的 “当前帐号” ，然后在弹出的 系统设置 窗口中，点击 “帐号管理”。如果已看到自己的帐号即表示已成功绑定；如果没有，则需要手动添加，点击 “添加”按钮，输入帐号信息即可。
# 0.4 测试程序下单指令
绑定了股票交易帐号后，需要先检证一下，是否可以通过程序指令下单。
第一步，在主界面中点击 “新建策略”按钮，选择“Python 策略”，打开代码编辑窗口；
第二步，把下列代码粘帖到文本窗口中。注意其中的帐号要替换成你自己的帐号，并提前登录成功；
#coding:gbk
import time # 导入 time 模块
def myHandlebar(ContextInfo): # 自定义函数
print('Hello world') # 在日志中打印输出 Hello world
# 下单指令 在帐户 368920 中买入股票 000004.SZ 以对手价买入 100 股，即时下单。
passorder(23, 1101, '00368920', '000004.SZ', 5, 0, 100,"1",1,"1", ContextInfo)
def init(ContextInfo):
ContextInfo.set_account('00368920') # 设置交易帐号为 00368920 注意此处替换成你自己的帐号
stocklist = ['000004.SZ']
# 每5秒执行一次自定义函数 myHandlebar
ContextInfo.run_time("myHandlebar","5nSecond","1970-01-01 00:00:00","SH")
2
3
4
5
6
7
8
9
10
11
12
13
14
TIP
本文档中的示例代码都可以按此操作步骤进行测试运行。
第三步，给这段代码起外名称，如“TESTACC”，然后先点击“编译”，再点击“运行”。然后在下面的“日志输出”窗口中，应该可以看到每5秒有一行文字“ Hello world ” 输出。即表示这段代码运行成功了，此时可以点击停止按钮，以结束运行。然后关闭代码编写窗口。
第四步，请点击主界面上的“模型交易”按钮，以切换到模型交易界面。在此界面左侧，可以找到刚刚创建的策略代码“TESTACC”，
点击之后会弹出“新建策略交易”
在此窗口中，请选择指定你的帐号类型、资金帐号、主图代码、运行周期。最后记得点击 “确定”。
第五步，点击了 “新建策略交易”窗口中的“确定”之后，即可在中间的策略列表部分看到刚刚选择的策略，其中策略名称就是上一步中选择的策略名称，主图标的、策略周期都是在“新建策略交易”窗口中的设定值，请仔细核对一下。
此时请点击“运行模式”下面的按钮，以切换到“实盘”模式，在弹出的“提示”窗口中，点击“确定”
然后，请点击 “操作”下面的 三角符号，即可开始运行该策略。在下面的“成交”标签页中，如果看到了实际成交的股票，即表示该帐号已经通畅可用。
如果下单失败，可能需要 管理端 开放权限，这需要与券商联系。
# 小结：
到此，安装 迅投软件 的全部操作步骤，包含下载 Python 环境、补充历史数据，绑定模拟帐户，并用一段代码测试模拟帐户是否已开通交易权限的全过程即全部完成。之后即可顺利开始使用 迅投软件，来进行量化交易的程序开发、历史测试、模拟测试等工作。
# 1）模型研究
本文档主要描述 量化程序交易 的功能。因此 迅投QMT 的基本操作教程，并未涉及。如果对 QMT 基础操作还不熟悉的朋友，建议先熟悉一下界面风格、基本操作。
# 1.1 策略列表
成功登录 迅投QMT之后，在主页界面中间部分即可看到 “策略列表”，其中应该包含的是 “我的策略”。如果点击 “返回”按钮，可以看到全部的（更多的）策略列表，如下图所示：
其中在“类型”一栏中标明了该策略运用的语言，vba/python。在 PYTHON 模型指标 中，有一个 《PY简单示例》，请点击它后面的“编辑”按钮，即可打开策略编辑器，看到源代码，如下图所示：
从这个简单示例中，可以看到。在 迅投QMT中，编写 Python 程序，第一行声明了字符集是 #coding:gbk 。其中最重要的两个自定义函数就是 init() 和 handlebar()
init() —— 是初始化函数，即策略程序一启动，首先执行此函数。通常在这个函数中，书写获取股票池、验证帐号、声明全局变量等语句；
handlebar() —— 表示每一根 K 线收盘后，即执行一次此函数。策略的核心逻辑都是写在该函数中的，比如，需要获取什么数据，获取后如何计算，得出结果后是否下单交易等等。通常用户还可以通过 paint() 方法将需要绘图输出的结果展示出来。
其中 ContextInfo 是整个 Python 框架中的核心对象。它包含了各种与 Python 底层框架交互的 API 方法，也是一个全局的关联上下文的对象（object），可以在 init 以及 handlebar 这两个函数中自由地传递用户创建的各种自定义数据。
现在我们来创建第一个策略程序吧。如之前在安装步骤中的操作，请点击中间上侧的 “新建策略”按钮，然后选择 “Python” 策略，然后把下列代码复制到窗口中。
#coding:gbk
def init(ContextInfo):
print('这是初始化函数 init() 中的 Hello World')
def handlebar(ContextInfo):
print('这是 handlebar 中的 say hi~~~')
2
3
4
5
6
7
8
然后点击“运行”按钮，在下面的“日志输出”窗口中能看到输出的文字即表示成功。
# 1.2 参数设置
在“策略编辑器”的右侧，基本信息面板的底部，中间的标签是“参数设置”，用鼠标点击一下该标签，即可在这里可以设置策略程序中的外部参数。通常用于策略程序源码必须加密，但同时又要允许用户可以自己修改参数的需求；或者用历史数据回测时，优化参数时使用。最多允许设置20个外部参数。在对应的栏位中填上“参数名”、“最新（值）”、“最小（值）”、“最大（值）”、“步长”、“初始（值）”，填完之后回车即可。
在“参数设置”面板中填写的参数，可以理解为就是在策略程序中声明的全局变量，在策略中的各个方法（函数）中都是可见的，包括用户自定义的函数中，也是可见的。因此在程序中可以直接使用，赋值、参与运算都可以。如上图中的示例，在参数设置中，填写了3个变量，xyz,abc,message，并且填写了各自的值。回车之后，在策略程序中，就可以直接打印出这些变量的值。并不需要提前声明或赋值操作。
WARNING
参数在最外层的代码中是 不可见 的。意即，顶格书写的代码是看不到这些外部设置的参数的。在 方法（函数）中都是可见的。
但在代码最外层是不可见的，即：顶格书写的代码是找不到这些变量的!
如上图中的示例，在参数设置中，填写了3个变量，xyz,abc,message，并且填写了各自的值。回车之后，在策略程序中，就可以直接打印出这些变量的值。并不需要提前声明或赋值操作。
在“策略交易”中运行某一个策略时，在“编辑策略交易”的窗口，对应的变量如下图所示：
另，如果想要在 “模型/策略交易”界面，让策略程序给出如下的参数设置面板：
可以在迅投QMT的安装文件夹中，具体路径为：
X:\QMT\python\formulaLayout
找到 .xml 类型的文件，用文本编辑器打开，即可发现，其中就是扩展的参数。对应的参数名称（name），参数提示（note），默认值（value），输入类型（type），绑定的变量名称（bind），（学过前端的朋友应该秒懂了。）都可以由用户根据需求自已定制。
<?xml version="1.0" encoding="utf-8"?>
<TCStageLayout>
<control note="控件">
<variable note="控件">
<item position="" bind="xyz" value="10000" note="变量xyz" name="xyz" type="intput"/>
<item position="" bind="abc" value="3.4" note="变量abc" name="abc" type="intput"/>
<item position="" bind="message" value="面板设置参数" note="变量message" name="message" type="intput"/>
</variable>
</control>
</TCStageLayout>
2
3
4
5
6
7
8
9
10
建议复制其中一个文件，然后修改成与你的模型程序文件同名，后缀为 .xml 即可。如 “TEST01.xml” ，对应的策略模型名称为 “TEST01.py”。
#encoding:gbk
# TEST01.py 即可接收到来自面板设置的参数
def init(ContextInfo):
print("从模型交易面板获取的变量 xyz：",xyz)
print("从模型交易面板获取的变量 abc：",abc)
print("从模型交易面板获取的变量 message：",message)
"""
运行结果：
从模型交易面板获取的变量 xyz： 10000
从模型交易面板获取的变量 abc： 3.4
从模型交易面板获取的变量 message： 面板设置参数
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1.3 历史数据回测
在 迅投 的主界面中，“我的” --> “模型研究” 中，有一个 “PY模型回测示例” ，如下图所示：
点击其后的编辑按钮，即可看到源代码。其策略大致为：
WARNING
此模型文件已是老旧版本，建议参考本文档附录中的案例
策略说明描述大致如下：
观察“上证50”成份股中的全部股票，关注 5日均线 和 20日均线。
如果发现某只股票 5日均线 在 20日均线之下，并且持有该股票，即卖出。
如果发现某只股票 5日均线 在 20日均线之上，并且没有持有该股票，即买入。
该示例中，导入了 time, datetime 和 numpy 模块，分别用来计算日期时间和平均值（均线）。同时还用到自定义函数来获取持仓股票列表。调取历史数据（如果之前没有补齐历史数据，会导致失败和错误）等功能，具体代码的解析，在阅读理解了 api 手册之后会有更详细的讨论。
第一步，点击右侧面板底部的“回测参数”按钮，以切换到 回测参数 面板。在此处可以选择回测的时间段，前提条件是下载过历史数据。其它参数可按需填写，如：初始资金、保证金比例、印花税等......（如图片显示太小，不清晰。可用鼠标右键点击图片，然后在菜单中点击 “在新标签页中打开图像”，即可看到高清大图 ）
第二步，点击“策略编辑器”顶部的
在 “模型研究” 窗口中，分为左右两个部分。 左边是K线图表，右边是 操作明细 和 日志输出。
左边的K线图表，可以用键盘上的 上下箭头键放大和缩小。左右箭头键可以前进或后退到某一根K线对应的日期时间，同时，右边的数据会显示对应的K线时间的操作。右侧底部有四个按钮，分别是：持仓明细、持仓分析、历史汇总和日志输出。
- 持仓明细 是随着左边的K线图联动的，当十字光标停留在某一根K线上时，在右侧即可看到对应的时间上，当时的操作记录。本例是日线图上的策略，因此每根K线对应一天，在右侧上半部分可以看到 “当日买入” 和 “当日卖出”，在下半部分可以看到“当日持仓明细”。
- 持仓分析 标签页中可以看到当时持有的股票的权重。有饼形图 和 直方图表示，一目了然。这些数据也是和 十字光标对应的K线，对应的时间联动的。可以按左右键移动光标，观察数据的变化。
- 历史汇总 面板，其中包括了历史回测时间段内的全部交易结果。可以看到合计交易次数、盈亏、交易量等信息。
- 日志输出 面板中的内容和 “策略编辑器”窗口下面的 日志输出 是一致的，用于显示程序运行过程中的各种文本输出信息，如： print()的输出，错误消息等......
TIP
一般约定 在 迅投 中编写一个 Python 策略时，第一行我们写上
# coding:gbk
这表示程序的编码格式统一是GBK
# 2） 重要方法（函数）和对象
在 迅投 中编写 Python 策略时，实际上是已经继承了一个来自底层的 基类（class） 。我们需要且仅能够在这个 类（class） 的框架之内，编写我们自己的程序来描述策略需求。其中有2个重要的 方法，就是 init() 和 handlebar() 和一个重要的 对象（Object）， ContextInfo。
# 2.1 初始化函数 init()
init() —— 初始化方法（函数），只执行一次。一般在程序开始启动时，在这个方法的代码中，把交易佣金、滑点、基准，订阅品种、帐户等信息设置好。这些只需要设置一次的操作，就放在初始化方法 init() 中；
功能： 初始化函数，只在整个策略开始时调用运行一次
语法：def init(ContextInfo)
参数： ContextInfo——继承自底层 基类 的策略运行环境对象，可以绑定自定义的属性、全局可见。
返回： 无
示例：
def init(ContextInfo):
ContextInfo.initProfit = 0 # 这个 initProfit 绑定到 ContextInfo 上，即是一个全局可见的属性（变量）
2
# 2.2 行情事件函数 handlebar()
handlebar() —— 行情处理函数。当点击 “运行” 时，此方法会在每根K线上执行一次此函数。如果不点击“停止”，并且没有休市，实时行情仍在跳动，则会在每一次价格跳动时，即每一个 tick 都会执行一次此函数。因此在这个方法中，书写整个策略的执行代码。
功能： 此函数会在每根 K 线上运行一次；在实时联网，获取行情的状态下，会先每根据附着的主图上的K 线数量，每根K线运行一次；然后每接收到一次 tick 数据，即运行一次。
语法：def handlebar(ContextInfo)
参数： ContextInfo —— 继承自底层 基类 的策略运行环境对象，可以绑定自定义的属性、全局可见。
返回： 无
示例：
def handlebar(ContextInfo):
# 打印输出当前运行到的 K 线的索引编号（位置序号）
print(ContextInfo.barpos)
2
3
在 迅投 中，编写 Python 策略必须包含以上这两个基本方法，否则策略将运行不起来。
# 2.3 最重要的对象 ContextInfo
ContextInfo 是 迅投QMT 中策略程序运行环境中最重要的对象，没有之一！前述的 init() 和 handlebar() 这两个基本方法运行时必须要传入这个参数。
ContextInfo 里面已经封装了多达 100+ 个属性 和 方法。因版本变化，此数量仍在变化中。当然，ContextInfo 这个对象（Object）也可以随时绑定 自定义 的 属性 和 方法，如同使用一般 对象（Object） 的方式一模一样，并无二致。
接下来介绍一些常用的 ContextInfo 自带的 属性和方法。更详细的信息，请参考附录和官方发布的文档为准。
# 2.3.01 设置帐户
ContextInfo.set_account()
功能： 设定交易账号。在参数中传入的账号用于之后的交易操作。
语法： ContextInfo.set_account(account)
*注：
一、可多次调用以设置多个账号，应在 init() 中设置完毕，init() 执行之后再设置将无效；
二、调用 passorder 交易指令时，如果传入的账号为空，将会使用最后一次设置的账号作为交易下单账号。
参数： 字符串（string）
返回： 无
示例：
# coding:gbk
def init(ContextInfo):
account = '6000000223' # 假设这是一个 股票帐号
ContextInfo.set_account(account) #
2
3
4
设定交易帐号是最常用、也是必须用的第一个方法（函数），连帐号都没设置好，那程序咋交易呢？往哪儿下单呢？因此在 init() 这个方法（函数）中，第一个要用到的，就是这个设置帐号的方法（函数），也必须写在 init() 这个方法（函数）中。
TIP
如果在代码中没有声明变量 account ，那么在 “策略交易”中，会自动读出策略选择的帐号。
实际运用中，更多情况是结合以下方法（函数）来设置关注的股票池：
获取指数成份股；ContextInfo.get_sector()
获取行业成份股；ContextInfo.get_industry()
获取板块成份股；ContextInfo.get_stock_list_in_sector()
可以一次设置多个品种，简单方便。
def init(ContextInfo):
# 设置股票池为 沪深300指数 000300.SH 中的全部品种
stock_list = ContextInfo.get_sector('000300.SH')
ContextInfo.set_universe(stock_list)
2
3
4
在实际运用中，通常是先获取一个板块中的全部品种，保存到一个列表中。然后再经过筛选，最终传给订阅品种的方法 ContextInfo.set_universe()，完成设置股票池的动作。
def init(ContextInfo):
# 设置股票池为 沪深转债 中的全部品种
stock_list = ContextInfo.get_stock_list_in_sector('沪深转债')
ContextInfo.set_universe(stock_list)
2
3
4
另一种常见的操作就是文件单，意即从文件中读取想要订阅的品种，会用到 ContextInfo.load_stk_list() 和 ContextInfo.load_stk_vol_list()方法，后面会有更详细的讨论。
# 2.3.02 将毫秒时间转换成日期时间
timetag_to_datetime()
功能： 将毫秒时间戳格式 转换为 日期时间格式参数：
语法： timetag_to_datetime(timetag, format)
参数：
- timetag——时间戳：毫秒，如：1512748800000
- Format——日期时间格式字符串，如：'%Y-%m-%d %H:%M:%S'
返回： str，日期时间
示例：
# coding:gbk
def handlebar(ContextInfo):
print('把时间戳 1512748860000 转换为 日期时间格式：\n')
print(timetag_to_datetime(1512748860000, '%Y%m%d %H:%M:%S'))
"""
运行结果：
把时间戳 1512748860000 转换为 日期时间格式：
20171209 00:01:00
"""
2
3
4
5
6
7
8
9
10
11
12
# 2.3.03 设置定时运行
ContextInfo.run_time()
功能： 设置定时器
语法： run_time(funcName,period,startTime,market)
WARNING
*注：模型回测时无效，定时器没有结束方法，会随着策略的结束而结束。另外定时器函数在第一次运行前 会先等待一个 时间周期（period）
参数：
funcName——想要复重执行的函数名称，通常是一个 自定义 函数的名称
period——重复调用的时间间隔。
'5nSecond'表示每5秒运行1次,
'5nDay'表示每5天运行一次,
'500nMilliSecond'表示每500毫秒运行1次startTime——表示定时器第一次启动的时间。如果想立刻启动,可以设置为已过去的历史时间
回调函数参数： ContextInfo
示例：
# coding:gbk
def init(ContextInfo):
# 从 2019-10-14 13:20:00 之后开始 每5s 运行一次 myHandlebar 函数
ContextInfo.run_time("myHandlebar","5nSecond","2019-10-14 13:20:00","SH")
def myHandlebar(ContextInfo): # 此函数必须带一个参数 ContextInfo
print('每5秒打印输出一次 hello world')
2
3
4
5
6
7
8
9
# 2.3.04 程序停止
stop()
功能： 停止处理。Python策略模型中用来关闭停止之前运行的函数。在一个复杂的策略模型程序中，如果其中有发起多线程时，可通过此函数实现停止线程的操作。
WARNING
*注：Python策略程序基本不用此函数
语法： stop(ContextInfo)
参数： ContextInfo：策略模型全局对象
示例：
# coding:gbk
def init(ContextInfo):
pass
def handlebar(ContextInfo):
pass
def stop(ContextInfo):
print( 'strategy is stop !')
2
3
4
5
6
7
8
9
10
11
12
# 小结：
以上只是简单的介绍了在 迅投QMT 中开始自动交易程序时的基本要素，包括：
两个重要的方法（函数）init() 和 handlebar() ；
关联上下文的重要 对象（Object）ContextInfo，它自带很多属性和方法（函数）。
更多的信息，请继续阅读以下内容，或参考附录和官方手册为准。
# =====品种相关=====
# 2.3.05 根据代码获取股票中文名称
ContextInfo.get_stock_name()
功能： 根据品种代码获取品种的中文名称
语法： ContextInfo.get_stock_name('stockcode')
参数： stockcode——字符串型，代表一个股票代码，如'000001.SZ'，如果缺省，则默认为当前图表上的品种代码。一次只能传入一个字符串。如果传入的字符串没有对应的名称，则返回 空。
返回： 返回字符串；（GBK编码）
示例：
# coding:gbk
def init(ContextInfo):
print(ContextInfo.get_stock_name('000001.SZ'))
# 返回字符串，“平安银行”
2
3
4
5
# 2.3.06 根据代码获取该股票的上市时间
get_open_date()
功能： 根据代码返回对应股票的上市时间
语法： get_open_date('stockcode')
参数： stockcode——股票代码，如'000001.SZ'，缺省值 ' ' 默认为当前图代码
返回： int 整数
示例：
# coding:gbk
def init(ContextInfo):
print(ContextInfo.get_open_date('000001.SZ'))
"""
返回值是一个 int 如：
20050523
即表示该品种是 2005年5月23日上市的
"""
2
3
4
5
6
7
8
9
10
# 2.3.07 判断股票是否停牌
ContextInfo.is_suspended_stock()
功能： 判断一支股票是否停牌
语法： ContextInfo.is_suspended_stock(stockcode.market)
参数： 字符串（string），指定品种代码；
返回： 返回一个 布尔值，True 表示 停牌， False 表示 未停牌；
示例：
# coding:gbk
def init(ContextInfo):
print("600004.SH 是否停牌： ",ContextInfo.is_suspended_stock('600004.SH'))
""" 运行结果
600004.SH 是否停牌： False
"""
2
3
4
5
6
7
8
# 2.3.8 获取板块目录信息
get_sector_list()
功能： 获取板块目录信息
语法： get_sector_list(node)
参数：node——str，板块节点名。如果传入空字符串 '' ，即表示 顶层目录 返回： info_list：[[s1,s2,...],[f1,f2,...]]s为板块名，f为目录节点名，例如[['我的自选'],['新建分类1']]
示例：
#coding:gbk
def init(ContextInfo):
print('\n')
# 显示顶层目录 中的板块名称
print(get_sector_list(''))
print("----------------------------------")
# 显示 沪市板块 中的板块名称
print(get_sector_list('沪市板块'))
"""
运行结果：
[[], ['我的', '沪深板块', '沪市板块', '深市板块', '期货板块', '期权板块', '指数板块', '持仓板块', '全球市场', '扩展数据', 'WIND数据库', '过期合约']]
----------------------------------
[['沪深A股', '沪深B股', '沪深指数', '沪深基金', '沪深ETF', '沪深债券', '沪深CDR', '沪深转债', '沪深回购'], []]
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
此方法中的板块目录，与 QMT 界面中的 “行情” --> “板块” 中的标签文件夹名称相对应，如下图：
TIP
如果想获取板块中所包含的具体品种代码，需要用以下方法：
ContextInfo.get_stock_list_in_sector('沪深转债')
# 2.3.9 判定给定股票代码是否在指定的板块中
is_sector_stock()
功能： 判定给定股票代码是否在指定的板块中
语法： is_sector_stock(sectorname, market, stockcode)
参数：
- sectorname——string，板块名
- market——string，市场
- stockcode——string，股票代码
返回： bool，返回值含义：True：在板块中 False：不在板块中
示例：
def handlebar(ContextInfo):
print(is_sector_stock('沪深300','SH','600000'))
2
# 2.3.10 判定给定股票是否属于某个类别
is_typed_stock()
功能： 判定给定股票是否属于某个类别
语法： is_typed_stock(stocktypenum, market, stockcode)
参数：
- stocktypenum——number，类别标号，如股票类别标号为100003，详细见 附录 http://docs.thinktrader.net/pages/b5fc7f/
- market——string，市场
- stockcode——string，股票代码
返回： number，返回值含义：1：True 0：False
示例：
def handlebar(ContextInfo):
print(is_typed_stock(100003,'SH','600000'))
2
# 2.3.11 判定给定股票代码是否在指定的行业分类中
get_industry_name_of_stock()
语法： get_industry_name_of_stock(industryType, stockcode)
功能： 判定给定股票代码是否在指定的行业分类中
参数：
- industryType——string，行业类别，有 'CSRC' 和 'SW' 两种
- stockcode——string，形式如 'stockcode.market'，如 '600000.SH'
返回： string：对应行业名，找不到则返回空 string
示例：
def handlebar(ContextInfo):
print(get_industry_name_of_stock('SW','600000.SH'))
2
# 2.3.12 创建板块
create_sector()
功能： 创建板块
语法： create_sector(parent_node,sector_name,overwrite)
参数：
- parent_node——str，父节点，''为'我的'（默认目录）
- sector_name——str，要创建的板块名
- overwrite——bool，是否覆盖。如果目标节点已存在，为True时跳过，为False时在sector_name后增加数字编号，编号为从1开始自增的第一个不重复的值。
返回： sector_name2：实际创建的板块名
示例：
sector=create_sector('我的','新建板块',False)
TIP
通常用户都是手动去创建一个“我的自选”，然后将自己所关心的品种，添加到这个板块文件夹中。用程序代码来操作板块在日常工作中几乎很少用到。
# 2.3.13 创建板块目录节点
create_sector_folder()
功能： 创建板块目录节点
语法： create_sector_folder(parent_node,folder_name,overwrite)
参数：
- parent_node——str，父节点，''为'我的'（默认目录）
- sector_name——str，要创建的节点名
- overwrite——bool，是否覆盖。如果目标节点已存在，为True时跳过，为False时在folder_name后增加数字编号，编号为从1开始自增的第一个不重复的值。
返回： sector_name2：实际创建的节点名
示例：
folder=create_sector_folder('我的','新建分类',False)
# 2.3.14 设置板块成分股
reset_sector_stock_list()
功能： 设置板块成分股
语法： reset_sector_stock_list(sector,stock_list)
参数：
- sector——板块名
- stock_list——list，品种代码列表，例如['000001.SZ','600000.SH']
返回： bool值，操作成功为True，失败为False
示例：
reset_sector_stock_list('我的自选',['000001.SZ','600000.SH'])
# 2.3.15 移除板块成分股
remove_stock_from_sector()
功能： 移除板块成分股
语法： remove_stock_from_sector(sector,stock_code)
参数：
- sector——板块名
- stock_code——品种代码，例如'000001.SZ'
返回： bool值。操作成功为True，失败为False
示例：
remove_stock_from_sector('我的自选','000001.SZ')
# 2.3.16 添加板块成分股
add_stock_to_sector()
功能： 添加板块成分股
语法： add_stock_to_sector(sector,stock_code)
参数：
- sector——板块名
- stock_code——品种代码，例如'000001.SZ'
返回： bool值。操作成功为True，失败为False
示例：
add_stock_to_sector('我的自选','000001.SZ')
# =====图表K线相关=====
前面介绍过，在 迅投QMT 中， 策略程序必须是附着在一个 K 线图表上，才能运行的。如果想要知道当前的程序附着在哪个品种的K线图上，就可以打印输出对应的属性（变量）值就可以了。
# 2.3.17 获取当前主图市场
ContextInfo.market
这是一个属性（变量），获取当前主图市场，只读。其值为一个字符串（string），对应主图市场的代码，"SH" 表示 上海沪市，"SZ" 表示 深市。
示例：
#coding:gbk
def init(ContextInfo):
print("当前主图的市场代码是：",ContextInfo.market)
#当前主图的市场代码是： SH
2
3
4
5
# 2.3.18 获取当前图表的品种代码
ContextInfo.stockcode
这是一个属性（变量）， 获取当前图代码，只读。其值为一个字符串（string），对应主图品种的代码。
示例：
# coding:gbk
def init(ContextInfo):
print("当前程序附着的K线图品种是：",ContextInfo.stockcode)
# 当前程序附着的K线图品种是： 000300
2
3
4
5
# 2.3.19 获取当前图表的复权方式
ContextInfo.dividend_type
这是一个属性（变量）， 获取当前主图复权处理方式，只读。其值为一个字符串（string）。
'none'：不复权
'front'：向前复权
'back'：向后复权
'front_ratio'：等比向前复权
'back_ratio'：等比向后复权
示例：
# coding:gbk
def init(ContextInfo):
print("当前图表的复权方法是：",ContextInfo.dividend_type)
# 当前图表的复权方法是： front_ratio
2
3
4
5
# 2.3.20 获取当前周期
ContextInfo.period
这是一个属性（变量）， 获取当前图表的时间框架周期，只读。其值为一个字符串（string）。 '1d' 日线、'1m' 1分钟线、'3m' 3分钟线、'5m' 5分钟线、'15m' 15分钟线、'30m' 30分钟线、'1h' 小时线、'1w' 周线、'1mon' 月线、'1q' 季线、'1hy' 半年线、'1y' 年线。
示例：
# coding:gbk
def init(ContextInfo):
print("当前图表的时间周期是：",ContextInfo.period)
# 当前图表的时间周期是： 1d
2
3
4
5
# 2.3.21 获取当前图表上K线的数量
ContextInfo.time_tick_size
这是一个属性（变量）， 获取当前图表上 K 线的总数量，只读。其值为一个整数（int）。
*注：只有 handlebar()方法启动后才会去计算图表上的K线。init() 只是初始化，还没有开始读取图表。
示例：
# coding:gbk
def handlebar(ContextInfo):
print("当前图表上包含的K线数量为：",ContextInfo.time_tick_size)
# 当前图表上包含的K线数量为：4858
2
3
4
5
6
# 2.3.22 获取当前运行到 K 线索引号
ContextInfo.barpos
这是一个属性（变量）， 获取当前运行到 K 线索引号，只读。其值为一个整数（int）， 只读，索引号从0开始。
*注： K线的序号是从左向右排序的，最早的K线是图表最左边的第 0 根，最新的K线是图表最右边的，索引号最大的那一根。
示例：
def handlebar(ContextInfo):
print(ContextInfo.barpos)
2
# 2.3.23 判定是否为最后一根 K 线
ContextInfo.is_last_bar()
功能： 判定是否为最后一根 K 线
语法： ContextInfo.is_last_bar()
参数： 无
返回： bool，返回值含义：True：是 False：否
示例：
def handlebar(ContextInfo):
print(ContextInfo.is_last_bar())
2
# 2.3.24 判定是否为新的 K 线
ContextInfo.is_new_bar()
功能： 某根 K 线的第一个 tick 数据到来时，判定该 K 线为新的 K 线。
语法： ContextInfo.is_new_bar()
参数： 无
返回： bool，返回值含义：True：是 False：否
示例：
def handlebar(ContextInfo):
print(ContextInfo.is_new_bar())
2
# =====回测相关=====
以下属性和方法与 策略编辑器 右侧的面板中的设置参数相对应，可相互参考。
WARNING
一、只支持回测模式；
二、仅在 init() 中设置生效；
三、如果在 init() 中未设置，则以 策略编辑器 界面右侧设定的回测时间范围为准；
四、如果同时在 策略编辑器 右侧参数面板中也设置了回测时间范围，则以 init() 中的设置为准；
五、如果设置的结束时间 小于等于 开始时间 ，则回测时计算范围为空。
# 2.3.25 设定回测起止时间
ContextInfo.start / ContextInfo.end
功能： 设定回测起止时间，标准格式如"2009-07-14 01:13:30"。这2个属性值可以修改。
示例：
def init(ContextInfo):
ContextInfo.start = '2012-06-06 10:00:00'
ContextInfo.end = '2013-08-08 14:30:00'
2
3
# 2.3.26 获取回测基准品种
ContextInfo.benchmark
这是一个属性（变量）， 获取回测基准，只读。其值为一个字符串（string）。
示例：
def handlebar(ContextInfo):
print(ContextInfo.benchmark)
2
# 2.3.27 设定回测初始资金
ContextInfo.capital
这是一个属性（变量）， 用于设定回测初始资金，默认为 1000000。
示例：
def init(ContextInfo):
ContextInfo.capital = 10000000
def handlebar(ContextInfo):
print(ContextInfo.capital)
2
3
4
5
# 2.3.28 获取策略回测的净值
ContextInfo.get_net_value()
功能：获取策略回测的净值 语法：ContextInfo.get_net_value() 参数：index 任意整数即可。 返回：number
示例：
#coding:gbk
def init(ContextInfo):
# 设置手续费
print(ContextInfo.get_net_value(0))
2
3
4
5
6
# 2.3.29 设定回测滑点
ContextInfo.set_slippage()
功能： 设定策略回测滑点，默认值 0.00
语法： ContextInfo.set_slippage(slippageType, slippage)
参数：
- slippageType——滑点类型，可选值：
0 —— tick跳数设置滑点
1 —— 按照固定值（价格）设置滑点
2 ——价格比例设置滑点 - slippage：滑点值
返回： 无
示例：
def init(ContextInfo):
# 按照固定值（价格）设置滑点值为 0.01
ContextInfo.set_slippage(1, 0.01)
2
3
# 2.3.30 获取策略设定的滑点
ContextInfo.get_slippage()
功能：获取策略设定的滑点，对应设置 set 滑点的方法。用来检验 get 设定是否生效。 语法： ContextInfo.get_slippage() 参数： 无 返回： 一个字典 dict
示例：
#coding:gbk
def init(ContextInfo):
# 设置滑点值
ContextInfo.set_slippage(0.003)
print("设置的滑点为：\n",ContextInfo.get_slippage())
"""
运行结果：
设置的滑点为：
{'slippage_type': 0, 'slippage': 0.003}
"""
2
3
4
5
6
7
8
9
10
11
12
# 2.3.31 设定回测手续费率
ContextInfo.set_commission()
功能： 设定策略回测时的各种手续费率，默认类型值 0 按比例，默认值 0.000
语法： ContextInfo.set_commission(commissionType, commissionList)
参数：
commissionType——整数型，可选值：0 表示 按比例 1表示 按每手（股）
commissionList——列表型。包含如下六个值
commissionList = [open_tax, # 买入印花税
close_tax, # 卖出印花税
open_commission, # 开仓手续费
close_commission, # 平仓（平昨）手续费
close_tdaycommission, # 平今手续费
min_commission # 最少手续费
]
2
3
4
5
6
7
TIP
如果只填写一个参数则代表输入的参数值同时 赋值给
open_commission = close_commission = close_today_commission
而其他的值均为 0，这时 commissionType 亦为 0
返回： 无
示例1：
def init(ContextInfo):
# 万三
commission = 0.0003
# 设定开仓手续费和平仓手续费以及平今手续费均为 0.0003，其余为 0
ContextInfo.set_commission(commission)
2
3
4
5
6
示例2：
def init(ContextInfo):
commissionList = [0,0.0001, 0.0003, 0.0003, 0, 5]
# 设定买入印花税为 0，卖出印花税为 0.0001，开仓手续费和平仓（平昨）手续费均为万三，平今手续费为 0，最小手续费为 5
ContextInfo.set_commission(0, commissionList)
2
3
4
5
# 2.3.32 获取策略设定的各种手续费率
ContextInfo.get_commission()
功能： 获取策略设定的各种手续费率。对应设置 set 手续费的方法。用来检验 get 设定是否生效。
参数： 无
返回：一个字典 dict，其中包含的信息请见示例中的注释。
示例：
#coding:gbk
def init(ContextInfo):
# 设置手续费
ContextInfo.set_commission(0.0003)
print("设置的手续费为：\n",ContextInfo.get_commission())
"""
设置的手续费为：
{'commission_type': 0, # 手续费类型
'open_tax': 0.0, # 开仓印花税
'close_tax': 0.0, # 平仓印花税
'open_commission': 0.0003, # 开仓手续费
'close_commission': 0.0003, # 平仓手续费
'close_tdaycommission': 0.0003, # 平今手续费
'min_commission': 0.0, # 最小手续费
'margin_ratio': 0.05 # 保证金比例
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 2.3.33 表示当前是否开启回测模式
ContextInfo.do_back_test
这是一个属性（变量）， 用于判断是否开启回测模式，只读，默认值为 False。此属性常用于在一个策略中同时包含回测和实时运行的代码时，用于区分执行哪部分的代码。
TIP
强烈建议，回测模型程序和实时运行程序，代码分开编写。
# 2.3.34 获取某个记录类型对应的某个时刻的记录情况
get_result_records()
功能： 官网的文档语文真心不及格。此方法的用法是根据指定的时刻（参数 index），记录类型（参数 Recordtype），获取对应的历史回测记录。如：“电脑，告诉我运行到第 84根K线的时候，持仓的品种有哪些？交易明细列出来，我看看。”
语法： get_result_records (recordtype, index, ContextInfo)
参数：
- Recordtype——字符串，记录类型：
'buys'：买入持仓
'sells'：卖出持仓
'holdings'：当前持仓
'historysums'：历史汇总
'dealdetails'：交易明细
index——number，当前主图对应 K 线索引，即第几根K线。从最左边开始，索引编号是： 0
ContextInfo——这里必须是ContextInfo
返回值： list。其中可能包含 0 个或多个 Python 对象，对象的属性值及表达意义如下：
| 属性名称 | 数据类型 | 表达意义 | 备注 |
|---|---|---|---|
| market | string | 市场代码 | |
| stockcode | string | 合约品种代码 | |
| open_close | number | 期货：1 开 0 平 股票： 1 买 0 卖 | |
| direction | number | 方向：1 多 -1 空 回购：1 逆回购 -1 正回购 | |
| trade_price | number | 持仓成本 | |
| current_price | number | 最新价，持仓中用这个价 | |
| profit | number | 持仓盈亏 | |
| position | number | 仓位数量 | |
| current_weight | number | 仓位权重 | [暂无有效数据] |
| benefit_weight | number | 盈利占比权重 | 记录类型是 'historysums' 时有效 |
| holding_periods | number | 累计持仓天数 | 记录类型是 'historysums' 时有效 |
| buy_sell_times | number | 交易次数 | 记录类型是 'historysums' 时有效 |
| commission | number | 手续费 | |
| trade_balance | number | 成交额或市值 | |
| operate_type | number | 操作类型 | 记录类型是 'dealdetails' 时有效 |
| trade_date | number | 交易日期，毫秒标记 | 记录类型是 'dealdetails' 时有效 |
示例：（这个例子写得真是和没写一样）
def handlebar(ContextInfo):
index = ContextInfo.barpos
print(get_result_records('buys', index, ContextInfo))
2
3
WARNING
一、此方法只支持回测模式；
二、获取的是回测面板中的记录结果；
# 3） 获取数据
通过前面的学习，已经认识了 迅投QMT 中基本的方法（函数）和 重要的对象 ContextInfo 了。接下来，就要按策略的要求，开始写自动交易的程序了。
其实开发自动交易程序，和写其它程序其实都一样，就三步：
一、获取数据；
二、计算数据；
三、展示数据；
没别的了。
一个自动交易的程序更具体的一些基本动作，大致如下：
（1）首先要检查一下帐户、登录的状态是否正常，看看帐户里的资金是否充足，帐户里有没有持仓......等等；
股票帐户里可能会有三种订单：
持有单（Position） —— 已买入还未卖出的单子；
挂单/委托单（Order） —— 已委托交易，但还没成交的单子 ；
成交单（Trade/deal） —— 以及今天已成交的单子；
因此，获取这 3 个列表（委托单、成交单、持有单）的数据，是很重要、必不可少的一个步骤；
（2）当然要看看时间、和市场对对时间；尤其现在都要玩高频交易的，时间更显得尤为重要；
（3）获取市场上的报价行情；股票市场通常是 快照行情，也就是 3秒一跳的报价；更快的还有 逐笔（成交）行情 和 逐笔委托；当然有时还要参考历史行情，比如、分钟级、小时级、或日线级别的历史数据；
（4）根据获取到的行情数据、经过计算，比如比较最高价、最低价、均价或者交易量等，这就是指标了。设置指标达到了某个条件，也就是什么时候买入，什么时候卖出，满足了，就下单交易；无非 两种可能，买入一个品种 或者 把已持有一个品种 卖出。注意这时下的单，是一个委托单，应该会有一个委托单号，如果没有，那就是出错了，要有处理出错的后续操作；关于交易相关的方法（函数）会在下一章讨论；
（5）如果委托成功了，有了委托单号。接下来就可以决定是 等待成交 或 是撤消这个委托；如果委托单已经成交了，那当然就无法撤消了，那么会就生成对应的 成交单号，意即 成交单 里会出现对应的单子；
（6）既然成交了，那肯定 持有单 会有一些变化 ，要么添加了一条买入的记录，或者是一条卖出的记录。检查下，然后再回到第（1）步；
有买入、有卖出，就形成了一个完整的交易。这个过程交给电脑程序自动完成，这就是自动交易，也没什么神秘吧？
必须要吐槽两句：迅投的官方文档，就是把一堆方法（函数），堆在一起。意思就是：你自己看着办。潜台词儿就是：我就给这么一堆，你自己用，不会用？用不好？那是你没水平，怨不得我。你要真一看就懂，一用就会，那岂不是显得我不牛逼了？
我真是......服了，厉害厉害，牛逼牛逼，66666
吐槽结束，还得说正事儿吧。下面的内容，是来源于个人心得，期望从那一堆方法（函数）当中，先选出那些主要用于A股交易的，常用的、简单的、容易理解的，让大家先容易上手嘛。上手之后，再根据自己的需要、深入研究、灵活运用，方成大器嘛。如果你必须要对自己下手狠一点、非要硬核一点，还请参考官方文档。顺祝一切都好。
本章所讨论的，主要是一些 获取数据 的方法（函数），有关更多 指标 的数据以及参数的动用，可以参考 TA_lib 这个库中的信息。
接下来按个人经验，把官方文档中的那一堆方法（函数）简单分了几个类别，目的就是希望让新手思路更清晰，更容易上手。
最常用的、行情相关、品种相关、期货相关、几乎不用。
# =====最常用的方法=====
# 3.01 获取帐户交易数据
get_trade_detail_data()
第一个必须要用的、当然也是最常用的，就是检查帐户的方法（函数）。但官方文档却把这个放在“交易函数”中，哎...... 因为它是每一个策略程序中肯定要用上的方法（函数），所以我们先来学习它的语法：
功能： 这个方法（函数）十分强大，可以用来获取：帐户、持仓单、委托单、成交单 的信息。是必须、也是最常用的方法（函数）之一。
TIP
这是重点！这个方法（函数）没学好，后面就不用看了！
语法：
get_trade_detail_data(
accountID, # 帐号
strAccountType, # 帐号类型，如 STOCK表示股票帐号
strDatatype, # 数据类型，如 POSITION 表示持仓单，ORDER 表示委托单
strategyName # 策略名称
)
2
3
4
5
6
参数：
- accountID —— 字符串型（String），表达 资金账号；
- strAccountType —— 字符串型（String），表达 账号类型。
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 'FUTURE' | 期货 | |
| 'STOCK' | 股票 | |
| 'CREDIT' | 信用 | |
| 'HUGANGTONG' | 沪港通 | |
| 'SHENGANGTONG' | 深港通 | |
| 'STOCK_OPTION' | 期权 |
- strDatatype —— 字符串型（String），
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 'POSITION' | 持仓 | |
| 'ORDER' | 委托 | |
| 'DEAL' | 成交 | |
| 'ACCOUNT' | 账号 | |
| 'TASK' | 任务 |
- strategyName —— 字符串（String）策略名，对应 passorder 下单函数中的参数 strategyName 的值，只对 委托 'ORDER' 和 成交 'DEAL' 有效。
返回：列表（Llist），在列表（List） 中保存的是一个对象，通过 dir() 可返回对象的属性列表。有五种交易相关信息：
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| POSITION | 持仓 | |
| ORDER | 委托 | |
| DEAL | 成交 | |
| ACCOUNT | 账号 | |
| TASK | 任务 |
我们来看几个例子，就更直观了。
先查询一个股票帐户的信息：
#coding:gbk
def init(ContextInfo):
# 获取股票 stock 帐户信息。注意提前登录该帐户，否则无结果返回
account_list = get_trade_detail_data('2000515','stock','account')
print("===========Account 帐户对象===============================")
print("帐户 2000515 的相关信息 ：")
for acc in account_list: # 遍历这个 列表（List），取出其中的 对象（Object）打印输出属性值
print("帐号ID " , acc.m_strAccountID)
print("帐号类型 " , acc.m_nBrokerType)
print("保证金比率 " , acc.m_dMaxMarginRate)
print("冻结保证金 " , acc.m_dFrozenMargin)
print("冻结金额 " , acc.m_dFrozenCash)
print("冻结手续费 " , acc.m_dFrozenCommission)
print("风险度 " , acc.m_dRisk)
print("单位净值 " , acc.m_dNav)
print("期初权益 " , acc.m_dPreBalance)
print("总资产 " , acc.m_dBalance)
print("可用金额 " , acc.m_dAvailable)
print("手续费 " , acc.m_dCommission)
print("持仓盈亏 " , acc.m_dPositionProfit)
print("平仓盈亏 " , acc.m_dCloseProfit)
print("出入金净值 " , acc.m_dCashIn)
print("当前使用的保证金 " , acc.m_dCurrMargin)
print("初始权益 " , acc.m_dInitBalance)
print("帐户状态 " , acc.m_strStatus)
print("期初平仓盈亏 " , acc.m_dInitCloseMoney)
print("总市值 " , acc.m_dInstrumentValue)
print("入金 " , acc.m_dDeposit)
print("出金 " , acc.m_dWithdraw)
print("上次信用额度 " , acc.m_dPreCredit)
print("上次质押 " , acc.m_dPreMortgage)
print("质押 " , acc.m_dMortgage)
print("信用额度 " , acc.m_dCredit)
print("证券初始资金 " , acc.m_dAssetBalance)
print("起始日期 " , acc.m_strOpenDate)
print("可取金额 " , acc.m_dFetchBalance)
print("交易日 " , acc.m_strTradingDate)
print("股票总市值 " , acc.m_dStockValue)
print("债券总市值 " , acc.m_dLoanValue)
print("基金总市值 " , acc.m_dFundValue)
print("回购总市值 " , acc.m_dRepurchaseValue)
print("多单总市值 " , acc.m_dLongValue)
print("空单总市值 " , acc.m_dShortValue)
print("净持仓总市值 " , acc.m_dNetValue)
print("总负债 " , acc.m_dTotalDebit)
print("可信资产 " , acc.m_dEntrustAsset)
print("总市值（人民币） " , acc.m_dInstrumentValueRMB)
print("申购费 " , acc.m_dSubscribeFee)
print("库存市值 " , acc.m_dGoldValue)
print("现货冻结 " , acc.m_dGoldFrozen)
print("占用保证金 " , acc.m_dMargin)
print("币种 " , acc.m_strMoneyType)
print("购买力 " , acc.m_dPurchasingPower)
print("原始保证金 " , acc.m_dRawMargin)
print("买入待交收金额（元） " , acc.m_dBuyWaitMoney)
print("卖出待交收金额（元） " , acc.m_dSellWaitMoney)
print("本期间应计利息 " , acc.m_dReceiveInterestTotal)
print("权利金收支 " , acc.m_dRoyalty)
print("冻结权利金 " , acc.m_dFrozenRoyalty)
print("实时占用保证金 " , acc.m_dRealUsedMargin)
print("实时风险度 " , acc.m_dRealRiskDegree)
print("-----------------------------------------------------")
# -------------------------------------------------------------------------------
""" 运行结果
start trading mode
===========Account 帐户对象===============================
帐户 2000515 的相关信息 ：
帐号ID 2000515
帐号类型 2 （1-期货账号,2-股票账号,3-信用账号,5-期货期权账号,6-股票期权账）
保证金比率 0.0
冻结保证金 4195596.793568001
冻结金额 708883.2000000001
冻结手续费 0.0
风险度 0.0
单位净值 0.0
期初权益 4195596.793568001
总资产 10093132.85904
可用金额 4195596.793568001
手续费 0.0
持仓盈亏 23470.272214303957
平仓盈亏 0.0
出入金净值 0.0
当前使用的保证金 0.0
初始权益 0.0
帐户状态 登录成功
期初平仓盈亏 2374.9999999999927
总市值 5129332.0
入金 0.0
出金 0.0
上次信用额度 0.0
上次质押 0.0
质押 0.0
信用额度 0.0
证券初始资金 10093132.85904
起始日期
可取金额 4904628.8590400005
交易日 20231123
股票总市值 5129332.0
债券总市值 0.0
基金总市值 0.0
回购总市值 0.0
多单总市值 0.0
空单总市值 0.0
净持仓总市值 0.0
总负债 0.0
可信资产 0.0
总市值（人民币） 0.0
申购费 0.0
库存市值 0.0
现货冻结 0.0
占用保证金 0.0
币种
购买力 0.0
原始保证金 0.0
买入待交收金额（元） 0.0
卖出待交收金额（元） 0.0
本期间应计利息 0.0
权利金收支 0.0
冻结权利金 0.0
实时占用保证金 0.0
实时风险度 0.0
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
查询一个股票帐户中持有的交易品种：
#coding:gbk
def init(ContextInfo):
# 获取股票 stock 帐户的现有持仓。注意提前登录该帐户，否则无结果返回
pos_list = get_trade_detail_data('2000515','stock','position')
print("帐户 2000515 的持仓信息，共有多少条记录 ：",len(pos_list))
for pos in pos_list:
print("账号ID " ,pos.m_strAccountID)
print("市场ID " ,pos.m_strExchangeID)
print("市场名称 " ,pos.m_strExchangeName)
print("品种代码 " ,pos.m_strProductID)
print("品种名称 " ,pos.m_strProductName)
print("证券代码 " ,pos.m_strInstrumentID)
print("证券名称 " ,pos.m_strInstrumentName)
print("投保类型 " ,pos.m_nHedgeFlag)
print("买卖方向 " ,pos.m_nDirection)
print("成交日期 " ,pos.m_strOpenDate)
print("成交ID " ,pos.m_strTradeID)
print("当前拥股 " ,pos.m_nVolume)
print("开仓价格 " ,pos.m_dOpenPrice)
print("交易日 " ,pos.m_strTradingDay)
print("保证金 " ,pos.m_dMargin)
print("持仓成本 " ,pos.m_dOpenCost)
print("结算价 " ,pos.m_dSettlementPrice)
print("平仓量 " ,pos.m_nCloseVolume)
print("平仓额 " ,pos.m_dCloseAmount)
print("浮动盈亏 " ,pos.m_dFloatProfit)
print("平仓盈亏 " ,pos.m_dCloseProfit)
print("市值 " ,pos.m_dMarketValue)
print("持有成本 " ,pos.m_dPositionCost)
print("持仓盈亏 " ,pos.m_dPositionProfit)
print("最新结算价 " ,pos.m_dLastSettlementPrice)
print("合约价值 " ,pos.m_dInstrumentValue)
print("是否今仓 " ,pos.m_bIsToday)
print("股东帐号 " ,pos.m_strStockHolder)
print("冻结数量 " ,pos.m_nFrozenVolume) # 期货不用这个字段，只用于股票品种
print("可用数量 " ,pos.m_nCanUseVolume) # 期货不用这个字段，只用于股票品种
print("在途股份 " ,pos.m_nOnRoadVolume) # 期货不用这个字段，只用于股票品种
print("昨仓数量 " ,pos.m_nYesterdayVolume) # 期货不用这个字段，只用于股票品种
print("最新价 " ,pos.m_dLastPrice)
print("开仓均价 " ,pos.m_dAvgOpenPrice)
print("盈亏比例 " ,pos.m_dProfitRate)
print("成交类型 " ,pos.m_eFutureTradeType)
print("到期日 " ,pos.m_strExpireDate)
print("组合成交号 " ,pos.m_strComTradeID)
print("组合序号 " ,pos.m_nLegId)
print("累计成本 " ,pos.m_dTotalCost)
print("单股成本 " ,pos.m_dSingleCost)
print("备兑数量 " ,pos.m_nCoveredVolume)
print("持仓类型 " ,pos.m_eSideFlag)
print("汇率 " ,pos.m_dReferenceRate)
print("基金拆合数量 " ,pos.m_dStructFundVol)
print("基金可赎回量 " ,pos.m_dRedemptionVolume)
print("申赎可用量 " ,pos.m_nPREnableVolume)
print("实时占用保证金 " ,pos.m_dRealUsedMargin)
print("权利金 " ,pos.m_dRoyalty)
print("标的证券最新价 " ,pos.m_dStockLastPrice)
print("静态持仓保证金 " ,pos.m_dStaticHoldMargin)
print("期权组合占用量 " ,pos.m_nOptCombUsedVolume)
print("可行权数量 " ,pos.m_nEnableExerciseVolume)
print("账号key " ,pos.m_strAccountKey)
print("++++++++++++++++++++++++++++++++++++++++++++++++++++")
"""运行结果
start trading mode
帐户 2000515 的持仓信息，共有多少条记录 ： 8
账号ID 2000515
市场ID SH
市场名称 上证所
品种代码
品种名称
证券代码 600027
证券名称 华电国际
投保类型 49
买卖方向 48
成交日期
成交ID
当前拥股 0
开仓价格 0.0
交易日 20231123
保证金 0.0
持仓成本 0.0
结算价 5.07
平仓量 0
平仓额 0.0
浮动盈亏 0.0
平仓盈亏 0.0
市值 0.0
持有成本 0.0
持仓盈亏 0.0
最新结算价 0.0
合约价值 0.0
是否今仓 True
股东帐号
冻结数量 0
可用数量 0
在途股份 0
昨仓数量 0
最新价 5.07
开仓均价 0.0
盈亏比例 0.0
成交类型 48 （48：普通成交 49：期权成交 50：OTC 成交 51：期转现衍生成交 52：组合衍生成交）
到期日
组合成交号
组合序号 0
累计成本 0.0
单股成本 0.0
备兑数量 0
持仓类型 48
汇率 0.0
基金拆合数量 0
基金可赎回量 0
申赎可用量 0
实时占用保证金 0.0
权利金 0.0
标的证券最新价 1.7976931348623157e+308
静态持仓保证金 1.7976931348623157e+308
期权组合占用数量 0
可行权数量 -1
账号key 2____11194____114911____49____2000515____
++++++++++++++++++++++++++++++++++++++++++++++++++++
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
看了上例之后，你是不是马上就想到了，这可以设置 止盈止损了嘛。因为这已经获取到了持仓单的品种、浮动盈亏的金额、甚至还有盈亏比例。这设置一个条件，比较一下大小，就立即卖出，这不就是 止盈止损 嘛。
接下来，我们再来看看 委托单 的例子：
#coding:gbk
def init(ContextInfo):
ord_list = get_trade_detail_data('2000515','stock','order')
print("===========Order 委托对象===============================")
print("帐户 2000515 的委托单信息，共有多少条记录 ：",len(ord_list))
for ord in ord_list:
print("账号ID " ,ord.m_strAccountID)
print("市场ID " ,ord.m_strExchangeID)
print("市场名称 " ,ord.m_strExchangeName)
print("品种代码 " ,ord.m_strProductID)
print("品种名称 " ,ord.m_strProductName)
print("证券代码 " ,ord.m_strInstrumentID)
print("证券名称 " ,ord.m_strInstrumentName)
print("内部委托号 " ,ord.m_strOrderRef)
print("委托价格类型 " ,ord.m_nOrderPriceType)
print("委托操作方向 " ,ord.m_nDirection)
print("买卖/开平标志 " ,ord.m_nOffsetFlag)
print("投保标志 " ,ord.m_nHedgeFlag)
print("委托价格 " ,ord.m_dLimitPrice)
print("最初委托量 " ,ord.m_nVolumeTotalOriginal)
print("委托状态 " ,ord.m_nOrderStatus)
print("已成交量 " ,ord.m_nVolumeTraded)
print("委托剩余量 " ,ord.m_nVolumeTotal)
print("错误代码 " ,ord.m_nErrorID)
print("错误消息 " ,ord.m_strErrorMsg)
print("任务号 " ,ord.m_nTaskId)
print("冻结保证金 " ,ord.m_dFrozenMargin)
print("冻结手续费 " ,ord.m_dFrozenCommission)
print("委托日期 " ,ord.m_strInsertDate)
print("委托时间 " ,ord.m_strInsertTime)
print("成交均价 " ,ord.m_dTradedPrice)
print("已撤数量 " ,ord.m_dCancelAmount)
print("买卖中文标记 " ,ord.m_strOptName)
print("成交金额 " ,ord.m_dTradeAmount)
print("委托类型 " ,ord.m_eEntrustType)
print("废单原因" ,ord.m_strCancelInfo)
print("标的证券代码" ,ord.m_strUnderCode)
print("备兑标记" ,ord.m_eCoveredFlag)
print("委托价格（人民币）" ,ord.m_dOrderPriceRMB)
print("成交金额（人民币）" ,ord.m_dTradeAmountRMB)
print("汇率" ,ord.m_dReferenceRate)
print("合约编号" ,ord.m_strCompactNo)
print("头寸来源" ,ord.m_eCashgroupProp)
print("预估在途占用保证金" ,ord.m_dShortOccupedMargin)
print("是否是迅投交易" ,ord.m_strXTTrade)
print("账号key" ,ord.m_strAccountKey)
print("投资备注" ,ord.m_strRemark)
print("+++++++++++++++++++++++++++++++++++++++++++++++++++")
"""运行结果
账号ID 2000515
市场ID SZ
市场名称 深交所
品种代码
品种名称
证券代码 300607
证券名称 拓斯达
内部委托号 SZ____895
委托价格类型 50
委托操作方向 48
买卖/开平标志 49
投保标志 49
委托价格 16.5
最初委托量 2400
委托状态 56
已成交量 2400
委托剩余量 0
错误代码 2147483647
错误消息
任务号 -1
冻结保证金 0.0
冻结手续费 0.0
委托日期 20231123
委托时间 100658
成交均价 16.5
已撤数量 0.0
买卖中文标记 限价卖出
成交金额 39600.0
委托类型 48
废单原因
标的证券代码
备兑标记 0
委托价格（人民币） 0.0
成交金额（人民币） 0.0
汇率 0.0
合约编号
头寸来源 48
预估在途占用保证金 1.7976931348623157e+308
是否是迅投交易 其他终端
账号key 2____11194____114911____49____2000515____
投资备注
+++++++++++++++++++++++++++++++++++++++++++++++++++
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
通过上例，可以看到获取到的 委托单 的信息。
再来看一个关于 成交单 的示例：
#coding:gbk
def init(ContextInfo):
# 获取股票 stock 帐户的现有持仓。注意提前登录该帐户，否则无结果返回
deal_list = get_trade_detail_data('2000515','stock','DEAL')
print("帐户 2000515 的成交信息，共有多少条记录 ：",len(deal_list))
for deal in deal_list:
print("账号ID " ,deal.m_strAccountID)
print("市场ID " ,deal.m_strExchangeID)
print("市场名称 " ,deal.m_strExchangeName)
print("品种代码 " ,deal.m_strProductID)
print("品种名称 " ,deal.m_strProductName)
print("证券代码 " ,deal.m_strInstrumentID)
print("证券名称 " ,deal.m_strInstrumentName)
print("成交ID " ,deal.m_strTradeID)
print("下单引用 " ,deal.m_strOrderRef)
print("合同编号 " ,deal.m_strOrderSysID)
print("买卖方向 " ,deal.m_nDirection)
print("开平标志 " ,deal.m_nOffsetFlag)
print("投保类型 " ,deal.m_nHedgeFlag)
print("成交均价 " ,deal.m_dPrice)
print("成交量 " ,deal.m_nVolume)
print("成交日期 " ,deal.m_strTradeDate)
print("成交时间 " ,deal.m_strTradeTime)
print("手续费 " ,deal.m_dCommission)
print("成交额 " ,deal.m_dTradeAmount)
print("任务号 " ,deal.m_nTaskId)
print("委托价格类型 " ,deal.m_nOrderPriceType)
print("买卖标记 " ,deal.m_strOptName)
print("委托类别 " ,deal.m_eEntrustType)
print("成交类型 " ,deal.m_eFutureTradeType)
print("实际开平 " ,deal.m_nRealOffsetFlag)
print("备兑标记 " ,deal.m_eCoveredFlag)
print("平今量 " ,deal.m_nCloseTodayVolume)
print("委托价格（人民币） " ,deal.m_dOrderPriceRMB)
print("成交价格（人民币） " ,deal.m_dPriceRMB)
print("成交金额（人民币） " ,deal.m_dTradeAmountRMB)
print("汇率 " ,deal.m_dReferenceRate)
print("是否是迅投交易 " ,deal.m_strXTTrade)
print("合约编号 " ,deal.m_strCompactNo)
print("平仓盈亏 " ,deal.m_dCloseProfit)
print("投资备注 " ,deal.m_strRemark)
print("账号key " ,deal.m_strAccountKey)
print("订单编号 " ,deal.m_nRef)
print("++++++++++++++++++++++++++++++++++++++++++++++++++++")
"""运行结果
账号ID 2000515
市场ID SH
市场名称 上证所
品种代码
品种名称
证券代码 605555
证券名称 德昌股份
成交ID 12
下单引用
合同编号 670
买卖方向 48
开平标志 49
投保类型 49
成交均价 22.89
成交量 600
成交日期 20231123
成交时间 94239
成交额 13734.0
任务号 -1
委托价格类型 50
买卖标记 限价卖出
委托类别 48
成交类型 48
实际开平 -1
备兑标记 48
平今量 0
委托价格（人民币） 0.0
成交价格（人民币） 0.0
成交金额（人民币） 0.0
汇率 0.0
是否是迅投交易 其他终端
合约编号
平仓盈亏 0.0
投资备注
账号key 2____11194____114911____49____2000515____
订单编号 0
++++++++++++++++++++++++++++++++++++++++++++++++++++
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
由此可见，get_trade_detail_data() 是一个强大的方法（函数），通过传入不同的形式参数，它就可以返回帐户信息、持有单、委托单的信息。当然还有其它的参数，在此就不一一举例了，有兴趣的话可以参考官方文档为准。
再来看一个关于 任务 的示例：
#coding:gbk
def init(ContextInfo):
# 获取股票 stock 帐户的现有持仓。注意提前登录该帐户，否则无结果返回
deal_list = get_trade_detail_data('620000123673','stock','TASK')
print("帐户 620000123673 的成交信息，共有多少条记录 ：",len(deal_list))
for deal in deal_list:
print("任务ID号 " ,deal.m_nTaskId)
print("任务状态 " ,deal.m_eStatus) # 2 提交中 3 执行中 7完成 4 暂停
print("任务消息 " ,deal.m_strMsg)
print("任务开始时间 " ,deal.m_startTime) # 时间戳格式
print("任务结束时间 " ,deal.m_endTime)
print("任务取消时间 " ,deal.m_cancelTime)
print("已成交量 " ,deal.m_nBusinessNum)
print("组合Id " ,deal.m_nGroupId)
print("下单品种代码 " ,deal.m_stockCode)
print("下单用户 " ,deal.m_strAccountID)
print("下单操作 " ,deal.m_eOperationType) # 0 开多 3 开空 14 平多 15 平空 18 买入 19卖出
print("交易类型 " ,deal.m_eOrderType) # 0 常规交易 1 算法交易 11 智能VWAP
print("报价方式 " ,deal.m_ePriceType) # 5 最新价 14对手价 11 指定价 18 市价最优价
print("委托价 " ,deal.m_dFixPrice)
print("委托量 " ,deal.m_nNum)
print("投资备注 " ,deal.m_strRemark)
print("++++++++++++++++++++++++++++++++++++++++++++++++++++")
"""
运行结果
任务ID号 1
任务状态 4
任务消息 12.8200全部委托! 报价行情已31秒未更新!
任务开始时间 1734261320
任务结束时间 2147483647
任务取消时间 2147483647
已成交量 0
组合Id 1
下单品种代码 600089.SH
下单用户 620000123673
下单操作 18
交易类型 0
报价方式 5
委托价 12.82
委托量 1000
投资备注 ++++++++++++++++++++++++++++++++++++++++++++++++++++
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 3.02 获取板块成份股
ContextInfo.get_stock_list_in_sector()
语法： ContextInfo.get_stock_list_in_sector(sectorname, realtime)
功能： 获取板块中包含的股票品种代码列表。板块名称即 “行情”界面中，“板块”标签中的板块名称。也支持自定义板块名称。
参数：
string——板块名称，如“沪深转债”，“创业板”、“上证50”、“我的自选”等 realtime——毫秒级时间戳 返回： list：其中包含板块中的全部股票代码，如：['000002.SZ','000257.SZ'] 等。
示例：
#encoding:gbk
def init(ContextInfo):
index = ContextInfo.barpos # 图表中最新一根K线的索引编号
realtime = ContextInfo.get_bar_timetag(index) # 最新一根K线对应的时间戳
print("板块 上证50 中包含哪些股票：\n")
print(ContextInfo.get_stock_list_in_sector('上证50', realtime))
2
3
4
5
6
7
# 3.03 获取市场行情第二版
ContextInfo.get_market_data_ex()
功能：这个方法（函数）功能也很强大，并且这是第二版，可见又添加了一些新的功能。因此要好好理解、熟练掌握！
据说这个 第二版 是为了接收 Level 2 行情的 逐笔行情 和 逐笔委托 的。但是，前提也是需要帐户支持；同时，至今为止（2022年9月），迅投官方也自称，软件的性能仅能够最多支持 20 个品种的 Level 2 逐笔行情数据。最多的数据，软件处理不了，会导致崩溃。这也是 迅投QMT 只能做为一款个人量化工具的原因。用比喻的话就是一辆奥托，也不是不能开。但性能也就那样。
语法：
ContextInfo.get_market_data_ex(
fields=[ ], # 默认为一个空列表（[]），表示获取所有字段
stock_code=[], # 品种代码列表。如：['600027.SZ','000187.SH']
period='follow', # 时间周期，默认为 'follow' 表示当前主图表的时间周期
start_time='', # 开始时间，如果为空字符串，表示取当前主图表上最左边K线的时间
end_time='', # 结束时间，字符串格式为'2020093000'。如果为空，表示此时此刻
count=-1, # 表示从图表右边开始，向左取 多少根 K线。 -1 表示无限制
dividend_type='follow', # 复权类型
fill_data=True, # 如果休市停牌期间，是否自动填充数据
subscribe=True # 订阅数据开关，默认为True
)
2
3
4
5
6
7
8
9
10
11
参数： fields —— 字段列表
| 字符串 | 表达意义 |
|---|---|
| 'time' | 时间 |
| 'open' | 开盘价 |
| 'high' | 最高价 |
| 'low' | 最低 |
| 'close' | 收盘价 |
| 'volume' | 成交量 |
| 'amount' | 成交额 |
| 'settle' | 结算价 |
| 'openInterest' | 持仓量 |
| 'preClose' | 前收盘价 |
| 'suspendFlag' | 1 -停牌 0 - 不停牌 |
对于不同时间周期的数据，其取值范围不同。默认为空列表（List）时，即代表所有字段。
period周期为tick时，field字段可选:
| 字符串 | 数据类型 | 表达意义 |
|---|---|---|
| time | int | 时间 |
| lastPrice | float | 最新价 |
| lastClose float | 前收盘价 | |
| open | float | 开盘价 |
| high | float | 最高价 |
| low | float | 最低价 |
| close | float | 收盘价 |
| volume | float | 成交量 |
| amount | float | 成交额 |
| settle | float | 今结算 |
| openInterest | float | 持仓量 |
| stockStatus | int | 停牌 1停牌，0 不停牌 |
stock_code —— 列表型（List），品种合约的代码列表。如：['600027.SZ','000187.SZ']
period：字符串型（String），表示时间框架周期，默认为'follow'，即表示取当前主图的周期。取值范围如下：
| 参数值 | 表达意义说明 |
|---|---|
| 'tick' | 分笔线 |
| '1d' | 日线 |
| '1m' | 1分钟线 |
| '5m' | 5分钟线 |
| 'l2quote' | Level2行情快照 |
| 'l2quoteaux' | Level2行情快照补充 |
| 'l2order' | Level2逐笔委托 |
| 'l2transaction' | Level2逐笔成交 |
| 'l2transactioncount' | Level2大单统计 |
| 'l2orderqueue' | Level2委买委卖队列 |
注：行情数据字段列表见附录5.5
start_time —— 开始时间，为空表示取当前主图表上最左边K线的时间，时间格式为'20201231'或'20201231093000' end_time —— 结束时间，为空视为此时此刻，时间格式为'20201231'或'20201231093000' count：—— 数据最大个数，-1 表示无限制 dividend_type —— 复权方式，默认为'follow'，为当前主图复权方式，可选值：
| 字符串 | 表达意义 |
|---|---|
| ’none' | 不复权 |
| 'fornt' | 向前复权 |
| 'back' | 向后复权 |
| 'front_ratio' | 等比向前复权 |
| 'back_ratio' | 等比向后复权 |
fill_data —— 停牌填充方式，默认为 True（暂不可用）
subscribe —— 订阅数据开关，默认为 True，设置为 False时不做数据订阅，只读取本地已有数据。订阅模式下，除分笔以外的周期只会自动补充当天数据，分笔周期不自动补充数据。
返回：一个字典（Dict），这个字典的 key（键），当然参数 stock_code 中想要获取的 品种代码 了，想要几个品种，就有几个对应的 key（键）。对应的 value（值），是一个 Pandas 的 数据帧。对 Pandas 不熟悉的同学请自行补课哈。简单说就象一个 excel 表格，表头就是 fields 对应的字段，也就是 列（栏），然后每一行中包含获取到的数据。一共多少行由参数 count 决定。
示例：
# coding:gbk
def init(ContextInfo):
# 获取 000300.SH 这个品种，日线图 1d 的，最近 10 根 K 线的，高开低收 的价格数据。保存到 data 这个变量中。
data=ContextInfo.get_market_data_ex(
['open','high','low','close'], # 获取 高开低收的价格
['000300.SH'], # 获取的品种是 00300.SH
period='1d', # 获取 日K线的 周期
start_time='', # 开始时间 缺省
end_time='', # 结束时间 缺省
count=10, # 从最右边的一根K线开始，获取 10 根K线的数据
dividend_type='follow', # 复权方式以主图表的方式为准
fill_data=True, # 休市停盘时自动填充数据
subscribe=True # 订阅数据
)
print(data) # 输出结果
"""
运行结果如下：
{
'000300.SH':
stime open high low close
20220221 4646.0520 4646.6720 4613.2970 4634.314
20220222 4601.9180 4602.0660 4550.8040 4574.153
20220223 4582.0060 4625.2980 4579.2940 4623.046
20220224 4592.0690 4610.8790 4488.4760 4529.319
20220225 4564.6320 4611.8600 4561.8960 4573.425
20220228 4563.7430 4581.6460 4530.6760 4581.646
20220301 4597.8550 4623.4310 4583.9170 4619.686
20220302 4594.0170 4594.0170 4558.4420 4578.601
20220303 4595.0250 4599.3970 4544.4310 4551.628
20220304 4513.3636 4539.3924 4481.4928 4496.430
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
由例程的运行结果，可以看到，打印输出的结果是一个 字典。只有一个 key（键）， “000300.SH”，对应的 value（值）是一个 Pandas 的 数据帧，字段名是 stime、open、high、low、close，分别表示时间、开盘价、最高价、最低价和收盘价。然后是 10 条记录，从最近的日期开始向前一共 10 天的数据，就已经获取到了。
日线图 1d 有什么意思嘛，必须给我来 Level 2 级的 逐笔成交 数据，我要高频、高速的！行，把参数修改一下即可，请看下例：
#encoding:gbk
def init(ContextInfo):
# 获取 000300.SH 这个品种，最新的报价数据， level 2 逐笔行情，最近 10 次的价格数据。保存到 data 这个变量中。
data=ContextInfo.get_market_data_ex(
[], # 获取 全部字段的数据
['000300.SH'], # 获取的品种是 00300.SH
period='l2transaction', # 获取 Level 2 级 逐笔行情 的数据
start_time='', # 开始时间 缺省
end_time='', # 结束时间 缺省
count=10, # 从最右边的一根K线开始，获取 10 根K线的数据
dividend_type='follow', # 复权方式以主图表的方式为准
fill_data=True, # 休市停盘时自动填充数据
subscribe=True # 订阅数据
)
print(data) # 输出结果
"""
运行结果如下：
请求失败, 没有Level-2增强版权限
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
如示例显示，你会收到错误消息，没有 Level - 2 增强版极限。简单说，要花钱（目前还不见得有效）。
因此，通常在 迅投QMT 中，用此方法（函数），获取到的最快的行情数据，即 3秒一跳 的快照行情了。请参考下例：
#encoding:gbk
def init(ContextInfo):
# 订阅市场行情获取数据
data=ContextInfo.get_market_data_ex(
[], # 获取 高开低收的价格
['000300.SH'], # 获取的品种是 000300.SH
period='tick', # 获取 日K线的 周期
start_time='', # 开始时间 缺省
end_time='', # 结束时间 缺省
count=3, # 从最右边的一根K线开始，获取 10 根K线的数据
dividend_type='follow', # 复权方式以主图表的方式为准
fill_data=True, # 休市停盘时自动填充数据
subscribe=True # 订阅数据
)
print(data) # 输出结果
"""
运行结果如下：
{'000300.SH': amount askPrice askVol \
stime
20220915155954.490 2.543675e+11 [0.0, 0.0, 0.0, 0.0, 0.0] [0, 0, 0, 0, 0]
20220915155954.490 2.543675e+11 [0.0, 0.0, 0.0, 0.0, 0.0] [0, 0, 0, 0, 0]
20220915155954.490 2.543675e+11 [0.0, 0.0, 0.0, 0.0, 0.0] [0, 0, 0, 0, 0]
bidPrice bidVol high \
stime
20220915155954.490 [0.0, 0.0, 0.0, 0.0, 0.0] [0, 0, 0, 0, 0] 4088.81
20220915155954.490 [0.0, 0.0, 0.0, 0.0, 0.0] [0, 0, 0, 0, 0] 4088.81
20220915155954.490 [0.0, 0.0, 0.0, 0.0, 0.0] [0, 0, 0, 0, 0] 4088.81
lastClose lastPrice lastSettlementPrice low \
stime
20220915155954.490 4065.36 4027.12 0.0 3998.86
20220915155954.490 4065.36 4027.12 0.0 3998.86
20220915155954.490 4065.36 4027.12 0.0 3998.86
open openInt pvolume settlementPrice \
stime
20220915155954.490 4078.65 15 12395119616 0.0
20220915155954.490 4078.65 15 12395119616 0.0
20220915155954.490 4078.65 15 12395119616 0.0
stime stockStatus time \
stime
20220915155954.490 20220915155954.490 1 1663228794490
20220915155954.490 20220915155954.490 1 1663228794490
20220915155954.490 20220915155954.490 1 1663228794490
transactionNum volume
stime
20220915155954.490 0 123951200
20220915155954.490 0 123951200
20220915155954.490 0 123951200 }
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
看着有点乱哈，用 Excel 整理下，就明白多了。
现在明白了 Pandas 的功能了吧？没学好的同学自己抓紧补课哈。由此可见，这个带 ex 的第二版方法（函数），主要是想用来获取 Level 2 行情的，但条件是客户的帐户需要购买对应的权限。而其基本功能，还是获取一个 Pandas 的数据帧，用于方便后面的计算，比如取一段时间的最高价/最低价啊、算一个平均值啊、因此结合 Pandas 运用好这个方法（函数），还是十分高效的。
TIP
前一个版本的 获取市场行情数据 的方法（函数） ContextInfo.get_market_data()，可以弃用了。
同时 ContextInfo.get_history_data() 也可以弃用了。
此方法可以 获取快照行情 和 历史行情 。实际运用中，如果只想要实时的市场行情，通常用下面这个方法：
ContextInfo.get_full_tick()
# 3.04 获取分笔数据
ContextInfo.get_full_tick()
大多数股民的日常行为就是 盯盘，所谓 盯盘 其实就是看着屏幕上的数字跳动。其实这是一个毫无意义且消耗精力的行为。做量化自动交易程序，就是要解放这种行为，让电脑程序帮人 盯盘，效率高、准确度高、速度还快。
与上一个方法 ContextInfo.get_market_data_ex() 相比，此方法主要用来接收实时的市场行情，记录每一次的价格变化、再根据需要进行计算，判断是否买卖。量化自动交易程序无非如此，没有什么神奇的秘密。
到今天为止，根据国家政策， Level 2 级的 逐笔成交 行情报价 和 深圳市场才有的 逐笔委托 行情是不允许出券商的机房的；同时 迅投 QMT 自己也承受不了超过20+ 品种的 逐笔报价 的数据流量，软件自身都会崩溃。因此，在 迅投 QMT 中，如果在本地自己的电脑上运行，只可能用上 3秒一跳的 快照行情。市场上各种说法，各种名词，混淆概念，称之为 tick 行情啊、逐笔行情啊、高速行情啊、一口一跳啊，都是指的这种 3秒一跳 的报价行情。
因此，在 迅投QMT 中的 handlebar() 中使用此方法（函数），通常也只能接收到 3秒一跳 的快照行情。
语法： ContextInfo.get_full_tick(stock_code=[])
参数：
stock_code —— 列表型（List）默认参数，品种代码的列表，如 ['600000.SH','600036.SH']。如果此参数缺省，则取当前主图表上的品种合约。
返回：根据参数 stock_code 订阅的品种，返回一个 分笔数据 的字典（Dict）。该字典的 key 对应的就是每一个订阅的品种代码，每个 key 对应的 value 还是一个字典（Dict），在该字典中即存放着对应的 品种代码 的最新报价数据，这个字典的 key 如下所示：
{
'timetag': # 最近一次收到报价的时间
'lastPrice'： # 最新价
'open': # 开盘价
'high': # 最高价
'low': # 最低价
'lastClose': # 昨收盘价
'amount'： # 成交额 今日累积
'volume'： # 成交量（手）今日累积
'pvolumn'： # 成交量（股）今日累积
'stockStatus'： # 股票状态
'openInt'： # 持仓量
'settlementPrice'： # 结算价
'lastSettlementPrice'： # 最新结算价
'askPrice'： # 列表（List)，卖价五档
'bidPrice'： # 列表（List)，买价五档
'askVol'： # 列表（List)，卖量五档
'bidVol'； # 列表（List)，买量五档
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
请参考以下示例：
# coding:gbk
def init(ContextInfo):
ContextInfo.set_universe( ['600000.SH','600036.SH']) # 订阅了两支股票
def handlebar(ContextInfo):
fulltick = ContextInfo.get_full_tick(['600000.SH','600036.SH']) # 获取逐笔报价数据
print("返回的数据是什么类型？：",type(fulltick))
print("返回的字典包括的 KEY 为：",fulltick.keys()) # 打印输出返回的字典（dict）的全部 key
for Asymbol in fulltick.keys(): # 遍历字典（dict）中的每一个品种
print("======================================")
print("品种代码：",Asymbol)
print("最新报价时间：" ,fulltick[Asymbol]['timetag'])
print("最新价：" ,fulltick[Asymbol]['lastPrice'])
print("开盘价：" ,fulltick[Asymbol]['open'])
print("最高价：" ,fulltick[Asymbol]['high'])
print("最低价：" ,fulltick[Asymbol]['low'])
print("昨收盘价：" ,fulltick[Asymbol]['lastClose'])
print("成交额：" ,fulltick[Asymbol]['amount'])
print("成交量（手）：" ,fulltick[Asymbol]['volume'])
print("成交量（股）：" ,fulltick[Asymbol]['pvolume'])
print("股票状态：" ,fulltick[Asymbol]['stockStatus'])
print("结算价：" ,fulltick[Asymbol]['settlementPrice']) # 适用期货
print("最新结算价：" ,fulltick[Asymbol]['lastSettlementPrice']) # 适用期货
print("卖价五档：" ,fulltick[Asymbol]['askPrice'])
print("买价五档：" ,fulltick[Asymbol]['bidPrice'])
print("卖价量：" ,fulltick[Asymbol]['askVol'])
print("买价量：" ,fulltick[Asymbol]['bidVol'])
""" 运行结果如下
返回的数据是什么类型？： <class 'dict'>
返回的字典包括的 KEY 为： dict_keys(['600000.SH', '600036.SH'])
======================================
品种代码： 600000.SH
最新报价时间： 20200902 10:00:04
最新价： 7.21
开盘价： 7.24
最高价： 7.2700000000000005
最低价： 7.2
昨收盘价： 7.23
成交额： 144223110.0
成交量（手）： 199755
成交量（股）： 199755
股票状态： 0
结算价： 0.0
最新结算价： 0.0
卖价五档： [0.0, 0.0, 0.0, 0.0, 0.0]
买价五档： [0.0, 0.0, 0.0, 0.0, 0.0]
卖价量： [0, 0, 0, 0, 0]
买价量： [0, 0, 0, 0, 0]
......
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
通过上例，再看看下图。
是不是感觉就对上了。解放了你的眼睛吧，电脑程序比你的肉眼精准多了，速度也快得多。
# 3.05 获取当日新股新债
get_ipo_data()
功能： 自动打新的最爱。获取当日新股新债信息，返回结果为一个字典,包括新股申购代码,申购名称,最大申购数量,最小申购数量等数据。
语法： get_ipo_data([,type])
参数： type —— 字符串型（String），缺省时返回新股新债信息。 type="STOCK" 表示只返回新股申购信息，type="BOND" 表示只返回新的可转债申购信息。 示例：
# coding:gbk
def init(ContextInfo):
ipoData = get_ipo_data() #返回新股新债信息
print('今天可以申购的新股和新债：',ipoData,'\n')
ipoStock = get_ipo_data("STOCK") #返回新股信息
print('今天可以申购的新股：',ipoStock,'\n')
ipoCB = get_ipo_data("BOND") # 返回新债申购信息
print('今天可以申购的新债：',ipoCB,'\n')
"""
运行结果：
今天可以申购的新股和新债： {'732075.SH': {'name': '热威申购', 'type': 'STOCK', 'maxPurchaseNum': 12000, 'minPurchaseNum': 500, 'purchaseDate': '20200830', 'issuePrice': 23.1}}
今天可以申购的新股： {'732075.SH': {'name': '热威申购', 'type': 'STOCK', 'maxPurchaseNum': 12000, 'minPurchaseNum': 500, 'purchaseDate': '20200830', 'issuePrice': 23.1}}
今天可以申购的新债： {}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 3.06 获取账户新股申购额度
get_new_purchase_limit()
功能： 获取账户允许的新股申购额度
语法： get_new_purchase_limit(accid)
参数： accid —— 资金账号，必须是股票账号或者信用账号
返回：一个字典，包括上海主板,深圳市场,上海科创版的申购额度。
示例：
#coding:gbk
def init(ContextInfo):
purchase_limit = get_new_purchase_limit("410038216969") # 此处是一个 股票帐号
print("帐号 410038216969 的新股申购额度为：",purchase_limit)
2
3
4
5
6
# 3.07 获取指定市场的最新时间
get_market_time()
功能： 根据指定的交易所市场，如沪市/深市，获取来自交易所的最新时间 语法： get_market_time(market) 参数： market —— 市场代码（如"SH"） 返回： 整数型。市场最新时间，最小单位是 秒
示例：
#encoding:gbk
def handlebar(ContextInfo):
print("上海沪市的最新时间是：",get_market_time("SH"))
print("深市的最新时间是：",get_market_time("SZ"))
""" 运行结果
上海沪市的最新时间是： 111530
深市的最新时间是： 111530
休市停盘之后，对应的时间也会停止。
"""
2
3
4
5
6
7
8
9
10
11
迅投QMT 中的这种 6 位整数的时间表达方式，一度让我感到很谜。后面才慢慢想明白，这意味着最小的单位，就到 秒。
111530 对应着 11:15:30 。用 6 位整数，可以直接比较大小，不必转换。一分钟之内的 秒 数，也可以直接用最后两位数直接相减即可。
# 3.08 获取当前K 线对应的时间戳
ContextInfo.get_bar_timetag()
语法： ContextInfo.get_bar_timetag(index)
功能： 获取指定 索引号 K 线对应的时间戳（毫秒），如未指定，则默认为当前K线。
参数： index —— 指定主图表中某一根 K 线的索引序号
返回： 时间戳（毫秒）
# coding:gbk
def handlebar(ContextInfo):
t1 = ContextInfo.get_bar_timetag(1080)
t2 = ContextInfo.get_bar_timetag(580)
print("当前主图表上 索引号为 1080 的K线，对应的时间是：")
print("毫秒时间戳为：",t1)
print("转换后为 ",timetag_to_datetime(t1, '%Y%m%d %H:%M:%S'))
print()
print("当前主图表上 索引号为 580 的K线，对应的时间是：")
print("毫秒时间戳为：",t2)
print("转换后为 ",timetag_to_datetime(t2, '%Y%m%d %H:%M:%S'))
print("=============================")
"""
运行结果
当前主图表上 索引号为 1080 的K线，对应的时间是：
毫秒时间戳为： 1657072800000
转换后为 20220706 10:00:00
当前主图表上 索引号为 580 的K线，对应的时间是：
毫秒时间戳为： 1648704600000
转换后为 20220331 13:30:00
=============================
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 3.09 获取给定日期对应的 K 线索引号
ContextInfo.get_date_location()
此方法与 ContextInfo.get_bar_timetag() 正好互补，根据指定的日期，返回对应的K线索引号。
功能： 根据指定的一个日期时间，返回当前主图表上对应的 K 线索引序号。如果当前主图上的第 0 号K线的日期都在指定的日期之后，则返回 0 表示没找到对应的K线。
语法： ContextInfo.get_date_location(strdate)
参数： string：形式如 'yyyymmdd' ，如 '20170711'
返回： 时间戳（毫秒）
示例：
# coding:gbk
def handlebar(ContextInfo):
print(" 20230120 对应的K线索引编号为：",ContextInfo.get_date_location("20230120"))
print(" 20220720 10:30:00对应的K线索引编号为：",ContextInfo.get_date_location("20220720 10:30:00"))
"""
运行结果
20230120 对应的K线索引编号为： 2159
20220720 10:30:00对应的K线索引编号为： 1159
"""
2
3
4
5
6
7
8
9
10
# 3.10 获取当前主图品种最新分笔报价对应的时间戳
ContextInfo.get_tick_timetag()
语法： ContextInfo.get_tick_timetag()
功能： 获取当前主图品种最新分笔报价对应的时间戳
参数： 无
返回： 时间戳（毫秒）
# coding:gbk
def handlebar(ContextInfo):
t = ContextInfo.get_tick_timetag()
print(t)
print("转换后为 ",timetag_to_datetime(t, '%Y%m%d %H:%M:%S'))
"""
运行结果:
1653265012659
转换后为 20220831 10:30:12
"""
2
3
4
5
6
7
8
9
10
11
# 3.11 获取一篮子证券编码数据
ContextInfo.load_stk_list()
功能： 从指定的文件路径中，获取一篮子 证券代码
语法：ContextInfo.load_stk_list(filePath，fileName)
文件类型可以是 .txt 或 .csv 格式，内容如：
600000.SH,600004.SH,600006.SH,
中间的分隔符为 英文半角逗号（,）。
参数：
filePath —— 文件路径
fileName —— 文件名(比如：a.txt,b.csv)
返回： 一个列表（list），其中包含文档中的品种名称代码。
示例：请提前在 D:/data 文件夹中准备一个 list.txt 的文件。
# coding:gbk
def init(ContextInfo):
df = ContextInfo.load_stk_list('D:/data','list.txt')
print(df)
2
3
4
5
TIP
文件名称和路径中，不要使用中文，否则可能会失败！
如果执行成功，会更改文件名，(在文件末尾以加上调用的时间)
如果不希望策略程序修改文件名称，可在 设置 面板，交易设置中，取消 “允许load_stk_list函数重命名文件”前面的 勾；
# 3.12 获取一篮子证券编码及数量数据
ContextInfo.load_stk_vol_list()
功能： 与上一个方法类似，区别是可以一次读取到品种名称和数量的信息。从指定的文件路径中，获取自选的一篮子 证券代码 和 数量 信息。
语法： ContextInfo.load_stk_vol_list(filePath，fileName)
文件类型可以是 .txt 或 .csv 格式，内容如：
600000.SH,100,600004.SH,500,600006.SH,200,
中间的分隔符为 英文半角逗号（,）。
参数：
filePath —— 文件路径
fileName —— 文件名(比如：a.txt,b.csv)
返回： 一个字典（dict），其中包含文档中的内容。key 为品种名称代码，value 为数量信息。
示例：请提前在 D：/data/ 文件夹中准备一个 list.txt 的文件，其中的内容如：
#encoding:gbk
def init(ContextInfo):
ContextInfo.load_stk_vol_list('D:/data','list.txt')
2
3
4
# =====行情相关=====
# 3.13 订阅行情数据
ContextInfo.subscribe_quote()
一般情况下，handlebar() 基于主图品种的分笔数据，每3秒执行一次。因为 分笔数据 是3秒跳动一次。但有时因品种的交易活跃程度不一，某一个时段内，可能某个品种报价跳动快，次数多；而有的品种报价慢，半天都没有跳动。因此，就可以用上这个方法，单独订阅某一个品种，只要报价跳动了，就立即调用执行一个自定义函数。可以做为 handlebar()的补充。（其实在实际应用中，Level 1 行情，就是 3秒一跳，用 handlebar() 足矣。Level 2 肯定用不着这个方法了。）
功能：订阅某一个品种的行情数据。在实际运行策略时，驱动方法 handlebar() 执行的频次，只与主图品种的分笔报价频繁相关。如果需要同时监控另一个品种代码时，可能出现主图报价与品种报价不同步，一个更新快，一个更新慢的情况。此时，即可通过此 方法来实现，一旦接收到某个品种的报价后立即调用执行一个自定义函数的功能。此方法支持订阅 level-2 行情，需要额外开通 level-2 增强版权限。
语法：ContextInfo.subscribe_quote(stockcode,period,dividend_type,callback)
参数：
stockcode —— 字符串型，代表一个股票代码，如'000001.SZ'，如果缺省，则默认为当前图表上的品种代码
period —— 字符串型（String），指定 K 线图表的时间帧框架周期，取值如：'tick'：表示分笔线，'1d'：表示日K线，'1m'：表示一分钟K线，'5m'：表示5分钟K线
dividend_type —— 默认参数可省略，数值型（number），指定复权类型，默认为 不复权，'follow'：表示用当前图复权方式，'none'：不复权，'front'：向前复权，'back'：向后复权，'front_ratio'：等比向前复权，'back_ratio'：等比向后复权,（分笔周期返回数据均为不复权）
callback —— 推送行情的回调
返回：一个订阅号，整数型（number），取消订阅方法（函数） ContextInfo.unsubscribe_quote() 需要用到这个订阅号。
示例：
#encoding:gbk
def quote_callback(s):
def callback(data):
print(s,data)
return
return callback # 这里返回的是 函数名称。是Python 中高阶函数的用法。
def init(ContextInfo):
T = ContextInfo.subscribe_quote("600000.SH","tick","none",quote_callback('600000.SH'))
print("订阅号为：",T)
2
3
4
5
6
7
8
9
10
11
# 3.14 获取当前所有的行情订阅信息
ContextInfo.get_all_subscription()
功能：如果之前用了多次 ContextInfo.subscribe_quote()方法，订阅了多个品种的行情报价。则可用此方法获取已订阅的品种信息。
语法：ContextInfo.get_all_subscription()
返回： 一个字典（Dict），其 Key 值为：订阅号；对应的 value 中包括，"func" 表示订阅的函数， "stockcode" 表示订阅的品种代码， "period" 表示时间周期，"dividendType" 表示除权方式。
示例：
#encoding:gbk
def quote_callback(s):
def callback(data):
print(s,data)
return
return callback # 这里返回的是 函数名称。是Python 中高阶函数的用法。
def init(ContextInfo):
# 调用了 2 次 subscribe_quote() ，分别订阅了 600027 和 600000 。
ContextInfo.subscribe_quote("600027.SH","tick","none",quote_callback("600027.SH"))
ContextInfo.subscribe_quote("600000.SH","tick","none")
data=ContextInfo.get_all_subscription()
print(data)
"""
运行结果：
{45:{
'func': 'subscribe_quote',
'stock_code': '600027.SH',
'stockCode': '600027.SH',
'period': 'tick',
'dividend_type': 'none',
'dividendType': 'none'
},
46:{
'func': 'subscribe_quote',
'stock_code': '600000.SH',
'stockCode': '600000.SH',
'period': 'tick',
'dividend_type': 'none',
'dividendType': 'none'
}
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 3.15 订阅全推数据
ContextInfo.subscribe_whole_quote()
功能： 订阅全推数据，全推数据只有分笔周期，每次增量推送数据有变化的品种。实际工作中很少用到此方法，不仅产生的负载消耗很大，更因为数据太多，不便提取。更多情况是用 get_full_tick() 方法来获取品种的行情报价数据。
语法： ContextInfo.subscribe_whole_quote(code_list,callback=None)
参数：
- code_list：list([str,str,...])
- 市场代码列表，如['SH','SZ']
- 品种代码列表，如 ['600000.SH', '000001.SZ']
- callback：数据推送回调
返回：int，订阅号，可用unsubscribe_quote做反订阅。此方法传递给调用函数的参数是一个 分笔数据 的字典，与 ContextInfo.get_full_tick()的返回值一样。该字典的 key 对应的就是每一个订阅的品种代码，每个 key 对应的 value 还是一个字典（Dict），在该字典中即存放着对应的 品种代码 的最新报价数据。
示例：
#encoding:gbk
def on_quote(datas):
print(datas)
def init(ContextInfo):
T = ContextInfo.subscribe_whole_quote(['SH', 'SZ'], on_quote)
print("订阅号为：",T)
"""
运行结果
订阅号为： 26
其中 datas 是一个 分笔数据 的字典，其内容大致如下：
{'000170.SH': {
'time': 1693884793805, # 最近一次收到报价的时间
'stime': '20230905113313.805',
'lastPrice': 4850.68, # 最新价
'amount': 19866300416.0, # 成交额 今日累积
'volume': 12083863, # 成交量（手）今日累积
'pvolume': 1208386304, # 成交量（股）今日累积
'openInt': 13, # 持仓量
'stockStatus': 1, # 股票状态
'lastSettlementPrice': 0.0, # 最新结算价（期货用）
'open': 4863.9, # 开盘价
'high': 4865.89, # 最高价
'low': 4839.09, # 最低价
'settlementPrice': 0.0, # 结算价
'lastClose': 4883.29, # 昨收盘价
'transactionNum': 0,
'askPrice': [0.0, 0.0, 0.0, 0.0, 0.0], # 卖价五档
'bidPrice': [0.0, 0.0, 0.0, 0.0, 0.0], # 买价五档
'askVol': [0, 0, 0, 0, 0], # 卖量五档
'bidVol': [0, 0, 0, 0, 0] # 买量五档
},
'000867.SH': {
'time': 1693884793805,
'stime': '20230905113313.805',
'lastPrice': 2054.43,
'amount': 3677979904.0,
'volume': 12047773,
'pvolume': 1204777344,
'openInt': 13,
'stockStatus': 1,
'lastSettlementPrice': 0.0,
'open': 2070.54,
'high': 2071.23,
'low': 2051.09,
'settlementPrice': 0.0,
'lastClose': 2071.52,
'transactionNum': 0,
'askPrice': [0.0, 0.0, 0.0, 0.0, 0.0],
'bidPrice': [0.0, 0.0, 0.0, 0.0, 0.0],
'askVol': [0, 0, 0, 0, 0],
'bidVol': [0, 0, 0, 0, 0]
}
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
# 3.16 反订阅行情数据
ContextInfo.unsubscribe_quote()
功能： 如果之前使用过 ContextInfo.subscribe_quote() 或 ContextInfo.subscribe_whole_quote() 方法来订阅过行情数据，则会自动生成对应的订阅号。此时如果想取消订阅，即可用此方法，传入对应的订阅号即可。
语法： ContextInfo.unsubscribe_quote(subId)
参数：
- subId：行情订阅返回的订阅号
示例：
#encoding:gbk
def init(ContextInfo):
T1 = ContextInfo.subscribe_quote("600027.SH","tick","none")
T2 = ContextInfo.subscribe_quote("600000.SH","tick","none")
T3 = ContextInfo.subscribe_quote("000010.SZ","tick","none")
data=ContextInfo.get_all_subscription()
print()
for k in data:
print("订阅号为：",k,"对应的品种为：",data[k]['stock_code'])
ContextInfo.unsubscribe_quote(T1) # 取消订阅 T1 600027.SH
print("========取消订阅后========================")
data=ContextInfo.get_all_subscription()
for k in data:
print("订阅号为：",k,"对应的品种为：",data[k]['stock_code'])
"""
运行结果：
订阅号为： 63 对应的品种为： 600027.SH
订阅号为： 64 对应的品种为： 600000.SH
订阅号为： 65 对应的品种为： 000010.SZ
========取消订阅后========================
订阅号为： 64 对应的品种为： 600000.SH
订阅号为： 65 对应的品种为： 000010.SZ
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
TIP
以上4个有关 subscribe订阅行情的方法，是旧版的方法，实际中已几乎弃用。
# 3.17 获取筹码分布（分价）完整档位数据
get_chip_distribution()
功能： 获取筹码分布完整档位数据
语法： get_chip_distribution(stock_code, period, time)
参数：
- stock_code——str，合约代码
- period——str，周期，目前仅支持日线 - '1d'
- time——str，时间格式为'20201231'或'20201231093000'
返回： 一个字典：其中的 key 值为 价格，对应的 value 即为该价格的成交量。
{
price1: volume1,
price2: volume2,
...
}
2
3
4
5
示例：
#encoding:gbk
def init(ContextInfo):
data = get_chip_distribution('000001.SZ', '1d', '20210730')
print(data)
"""
运行结果
{1.76: 77057, 1.77: 1036973, 1.78: 4569153, 1.79: 8915689, 1.8: 11812067, 1.81: 12674887, 1.8199999999999998: 15296514, 1.83: 15627174, 1.8399999999999999: 11754403, 1.85: 10958208, 1.8599999999999999: 11655163, 1.87: 11894942, 1.88: 12139527, 1.8900000000000001: 11390879, 1.9: 12490094, 1.9100000000000001: 8650945, 1.92: 9108137, 1.9300000000000002: 8656432, 1.94: 8166178, 1.95: 5054632, 1.96: 5541973, 1.97: 5846457, 1.98: 4916237, 1.99: 4364013, 2.0: 6750606, 2.01: 5593591, 2.02: 5043607, 2.03: 5049569, 2.04: 7002185, 2.05: 9060798, 2.06: 9024885, 2.07: 5687880, 2.08: 4530077, 2.09: 2999774, 2.1: 2683479, 2.11: 2590133, 2.12: 2470753, 2.13: 1977601, 2.14: 2098021, 2.15: 1954859, 2.16: 1763790, 2.17: 1780889, 2.18: 1398368, 2.19: 1416188, 2.2: 1002104, 2.21: 749418, 2.22: 694715, 2.23: 589296, 2.24: 491357, 2.25: 546294, 2.26: 654860, 2.27: 676624, 2.2800000000000002: 618698, 2.29: 524735, 2.3: 376159, 2.31: 258452, 2.32: 206092, 2.33: 206635, 2.34: 246118, 2.35: 278052, 2.36: 481367, 2.37: 739283, 2.38: 878905, 2.39: 852924, 2.4: 735960, 2.41: 658182, 2.42: 586559, 2.43: 593200, 2.44: 555539, 2.45: 500903, 2.46: 445769, 2.4699999999999998: 367416, 2.48: 313680, 2.49: 292696, 2.5: 288422, 2.51: 284148, 2.52: 279874, 2.5300000000000002: 273631, 2.54: 249616, 2.55: 231401, 2.56: 213187, 2.57: 194973, 2.58: 184743, 2.59: 165205, 2.6: 178938, 2.61: 192673, 2.62: 206406, 2.63: 220141, 2.64: 233876, 2.65: 247610, 2.66: 200258, 2.67: 156415, 2.68: 112572, 2.69: 68729, 2.7: 34364, 2.71: 0}
"""
2
3
4
5
6
7
8
9
10
参考下图有助于理解此方法（函数）的功能，右侧即是筹码分布的图形指标，纵轴y为价格，横轴x为交易量。
# 3.18 获取筹码分布中指定价格所在的比例 get_winner_chips()
功能： 获取筹码分布中指定价格所在的比例
语法： get_winner_chips(stock_code, period, time, price)
参数：
- stock_code——str，合约代码
- period——str，周期，目前仅支持日线 - '1d'
- time——str，时间格式为'20201231'或'20201231093000'
- price——float，指定的价格
返回： ratio：float，指定价格所在的比例
示例：
#encoding:gbk
def init(ContextInfo):
data02 = get_winner_chips('000001.SZ', '1d', '20230405', 23.04)
print("\n2022年4月5日，品种 000001.SZ ，当天在价格 23.04 元的成交量占当天成交量的比例为：")
print(data02)
"""
运行结果
2022年4月5日，品种 000001.SZ ，当天在价格 23.04 元的成交量占当天成交量的比例为：0.9859408926072876
"""
2
3
4
5
6
7
8
9
10
11
12
# 3.19 获取筹码分布中指定比例所在的价格档位
get_chips_price"()
功能： 获取筹码分布中指定比例所在的价格档位
语法： get_chips_price(stock_code, period, time, ratio)
参数：
- stock_code：str，合约代码
- period：str，周期，目前仅支持日线 - '1d'
- time：str，时间格式为'20201231'或'20201231093000'
- ratio：float，指定的比例
返回： price：float，指定比例所在的价格档位
示例：
#encoding:gbk
def init(ContextInfo):
data02 = get_chips_price('000001.SZ', '1d', '20220405', 0.8)
print("\n2022年4月5日，品种 000001.SZ ，当天成交量占 0.8 的价位为：")
print(data02)
"""
2022年4月5日，品种 000001.SZ ，当天成交量占 0.8 的价位为：
19.87
"""
2
3
4
5
6
7
8
9
10
TIP
关于筹码分布的这3个方法（函数），其数值与其它软件中的 筹码峰 因计算方式不同，因此结果并不一致。
# =====品种相关=====
# 3.20 根据代码获取合约详细信息
ContextInfo.get_instrumentdetail()
功能： 获取指定代码品种的合约详细信息
语法： ContextInfo.get_instrumentdetail(stockcode)
参数：
- stockcode：string，比如：某支股票代码 '600000.SH'
返回： 根据stockcode返回一个字典（dict），其中包含的数据详见示例中的注释。
示例：
#encoding:gbk
def init(ContextInfo):
print(ContextInfo.get_instrumentdetail('600000.SH'))
"""
运行结果：
{
'ExchangeID': 'SH', # 交易所 ID
'InstrumentID': '600000', # 品种代码
'InstrumentName': '浦发银行', # 品种名称
'ProductID': None, # 产品 ID （期货品种）
'ProductName': None, # 产品名称 （期货品种）
'CreateDate': 19991110, # 创建日期 （期货品种）
'OpenDate': 19991110, # 上市日期
'ExpireDate': 20991231, # 过期日期
'PreClose': 7.04, # 前收盘价
'SettlementPrice': 0.0, # 前结算价（期货品种）
'UpStopPrice': 7.74, # 当日涨停价
'DownStopPrice': 6.34, # 当日跌停价
'FloatVolumn': 29352170000.0, # 流通股本
'TotalVolumn': 29352170000.0, # 总股本
'LongMarginRatio': None, # 多头保证金（期货品种）
'ShortMarginRatio': None, # 空头保证金（期货品种）
'PriceTick': 0.01, # 报价最小跳动单位
'VolumeMultiple': 1, # 合约单位（1手）
'MainContract': None, # 主力合约标记（期货品种）
'LastVolume': 0, # 昨日持仓量
'InstrumentStatus': 0, # 品种状态： 0 表示未停牌；n 表示已停牌n天, -1表示当天复牌
'IsTrading': True, # 是否可交易 True 表示可交易；False 表示不可交易
'IsRecent': None, # 是否近月合约（期货品种用）
'HSGTFlag': 0 # 标的标记： 0: 非标的, 1: 沪港通标的, 2: 沪港通历史标的, 3: 深港通标的, 4:深港通历史标的, 5: 沪深港通标的, 6: 沪港通标的 深港通历史标的, 7: 沪港通历史标的 深港通标的, 8: 沪深港通历史标的
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
如想了解某一个品种的详细合约信息，用此方法足矣。字典中包含的数据已十分详细。
# 3.21 获取最新流通股本
ContextInfo.get_last_volume()
功能： 获取最新流通股本。理论上与 方法 ContextInfo.get_instrumentdetail() 返回的字典中的键 'FloatVolumn'对应的值是一致的。
语法：ContextInfo.get_last_volume(stockcode)
参数： string：必须是 'stock.market' 形式
返回： 整数型（int）
示例：
#encoding:gbk
def init(ContextInfo):
d = ContextInfo.get_instrumentdetail('000002.SZ')
print("\n品种 000002.SZ 的流通股本（取字典中的KEY值 ）为：",d['FloatVolumn'])
print()
print("\n品种 000002.SZ 的流通股本（用方法获取）为：",ContextInfo.get_last_volume('000002.SZ'))
"""
运行结果：
品种 000002.SZ 的流通股本（取字典中的KEY值 ）为： 9716660000.0
品种 000002.SZ 的流通股本（用方法获取）为： 9716660000
"""
2
3
4
5
6
7
8
9
10
11
12
13
# 3.22 获取总股数（本）
ContextInfo.get_total_share()
功能： 获取总股本。理论上与 方法 ContextInfo.get_instrumentdetail() 返回的字典中的键 'TotalVolumn'对应的值是一致的。
语法： ContextInfo.get_total_share(stockcode)
参数： stockcode：string，股票代码，如：'600000.SH'，默认为当前主图品种代码
返回： 整数型（int）
示例：
#encoding:gbk
def init(ContextInfo):
d = ContextInfo.get_instrumentdetail('600089.SH')
print("\n品种 600089.SH 的总股本（取字典中的KEY值 ）为：",d['TotalVolumn'])
print()
print("\n品种 600089.SH 的总股本（用方法获取）为：",ContextInfo.get_total_share('600089.SH'))
"""
品种 600089.SH 的总股本（取字典中的KEY值 ）为： 5052790000.0
品种 600089.SH 的总股本（用方法获取）为： 5052790000
"""
2
3
4
5
6
7
8
9
10
11
12
# 3.23 获取换手率
ContextInfo.get_turnover_rate()
TIP
使用之前需要下载相关数据。如果未下载，将自动使用最新流通股本来计算历史换手率，结果可能不正确。
具体操作如下：
1 点击菜单栏中的“操作”-->“数据管理”，在弹出的 数据管理 窗口中， 点击 数据选项 框右侧的 2 下三角，显示下拦菜单，选中其中相应的数据，然后在右侧选择 数据范围，确定时间段，建议最近1周或最近1月即可，最后点击窗口右下方的 “开始”按钮。
功能： 获取换手率
语法： ContextInfo.get_turnover_rate(stock_list,startTime,endTime)
参数：
- stock_list —— 股票列表，list,如['600000.SH','000001.SZ']
- startTime —— 起始时间，如'20170101'
- endTime —— 结束时间，如'20180101'
返回： Pandas 的数据帧 dataframe
示例：
#encoding:gbk
def init(ContextInfo):
print( ContextInfo.get_turnover_rate(['000002.SZ'],'20200901','20200905'))
"""
运行结果：
000002.SZ
20200901 0.010809
20200904 0.010958
如果未提前下载好，则可能返回空数据，或不准确的数据。
"""
2
3
4
5
6
7
8
9
10
11
# 3.24 根据代码获取对应股票的内盘/外盘成交量
ContextInfo.get_svol()
ContextInfo.get_bvol()
功能： 获取指定品种代码对应股票的内盘/外盘成交量。
语法：
ContextInfo.get_svol(stockcode)
ContextInfo.get_bvol(stockcode)
参数： stockcode —— 股票代码，如 '000001.SZ'，默认为当前图品种代码
返回： int 整数型
示例：
#encoding:gbk
def init(ContextInfo):
print()
print("股票品种 000001.SZ 的内盘成交量为：\n",ContextInfo.get_svol('000001.SZ'))
print("股票品种 000001.SZ 的外盘成交量为：\n",ContextInfo.get_bvol('000001.SZ'))
"""
运行结果：
股票品种 000001.SZ 的内盘成交量为：
0
股票品种 000001.SZ 的外盘成交量为： 0
"""
2
3
4
5
6
7
8
9
10
11
12
13
# 3.25 获取行业成份股
ContextInfo.get_industry()
功能： 类似 ContextInfo.get_stock_list_in_sector()方法。用来获取行业成份股的品种。
语法： ContextInfo.get_industry(industry)
参数： string：如 'CSRC1矿业'
返回： list：内含成份股代码，里面股票代码为 '000002.SZ' 形式
示例：
#encoding:gbk
def init(ContextInfo):
print("CSRC1采矿业 中包含哪些股票：")
print(ContextInfo.get_industry('CSRC1采矿业'))
"""
运行结果：
['600028.SH', '600121.SH', '600123.SH', '600188.SH', '600256.SH', '600259.SH', '600338.SH', '600339.SH', '600348.SH', '600395.SH', '600397.SH', '600403.SH', '600489.SH', '600497.SH', '600508.SH', '600547.SH', '600583.SH', '600711.SH', '600758.SH', '600759.SH', '600777.SH', '600871.SH', '600925.SH', '600938.SH', '600968.SH', '600971.SH', '600985.SH', '600988.SH', '601001.SH', '601020.SH', '601069.SH', '601088.SH', '601101.SH', '601121.SH', '601168.SH', '601225.SH', '601666.SH', '601699.SH', '601808.SH', '601857.SH', '601898.SH', '601899.SH', '601918.SH', '601958.SH', '601969.SH', '603132.SH', '603505.SH', '603619.SH', '603727.SH', '603979.SH', '603993.SH', '605086.SH', '000426.SZ', '000506.SZ', '000552.SZ', '000603.SZ', '000655.SZ', '000688.SZ', '000758.SZ', '000762.SZ', '000923.SZ', '000937.SZ', '000968.SZ', '000975.SZ', '000983.SZ', '001203.SZ', '001337.SZ', '002128.SZ', '002155.SZ', '002192.SZ', '002207.SZ', '002554.SZ', '002629.SZ', '002683.SZ', '002828.SZ', '002978.SZ', '300084.SZ', '300157.SZ', '300164.SZ', '300191.SZ', '300483.SZ']
"""
2
3
4
5
6
7
8
9
# 3.26 获取指数成份股
ContextInfo.get_sector()
功能： 类似 ContextInfo.get_stock_list_in_sector()方法。获取板块成份股，只支持取指数中的成份股品种。
语法： ContextInfo.get_sector(sector, realtime)
参数：
- string：必须是 ‘stock.market’ 形式，如 ‘000300.SH’ ，可取如沪深300（000300.SH）、中证500（000905.SH）、上证50（000016.SH）等指数的历史成份股
- realtime：毫秒级时间戳，如不填则默认取目前最新成份股
返回： list：内含成份股代码，里面股票代码为 ‘000002.SZ’ 形式
示例：
#encoding:gbk
def init(ContextInfo):
print("指数 上证50（000016.SH） 中包含哪些股票：")
print(ContextInfo.get_sector('000016.SH'))
"""
执行结果
指数 上证50（000016.SH） 中包含哪些股票：
['600010.SH', '600028.SH', '600030.SH', '600031.SH', '600036.SH', '600048.SH', '600050.SH', '600089.SH', '600104.SH', '600111.SH', '600196.SH', '600276.SH', '600309.SH', '600406.SH', '600436.SH', '600438.SH', '600519.SH', '600690.SH', '600745.SH', '600809.SH', '600887.SH', '600893.SH', '600900.SH', '600905.SH', '601012.SH', '601066.SH', '601088.SH', '601166.SH', '601225.SH', '601288.SH', '601318.SH', '601390.SH', '601398.SH', '601628.SH', '601633.SH', '601668.SH', '601669.SH', '601728.SH', '601857.SH', '601888.SH', '601899.SH', '601919.SH', '603259.SH', '603260.SH', '603288.SH', '603501.SH', '603799.SH', '603986.SH', '688111.SH', '688599.SH']
"""
2
3
4
5
6
7
8
9
10
11
# 3.27 获取某只股票在某指数中的绝对权重
ContextInfo.get_weight_in_index()
语法： ContextInfo.get_weight_in_index(indexcode, stockcode)
功能： 获取某只股票在某指数中的绝对权重
参数：
- indexcode：string，指数代码，形式如 'stockcode.market'，如 '000300.SH'
- stockcode：string，股票代码，形式如 'stockcode.market'，如 '600004.SH'
返回： number：返回的数值单位是 %，如 1.6134 表示权重是 1.6134%
示例：
#encoding:gbk
def init(ContextInfo):
print("\n股票 000002.SZ 在指数 沪深300 （000300）中所占的权重为：")
print(ContextInfo.get_weight_in_index('000300.SH', '000002.SZ'),' %')
"""
运行结果：
股票 000002.SZ 在指数 沪深300 （000300）中所占的权重为：0.501 %
"""
2
3
4
5
6
7
8
9
10
# 3.28 获取财务数据
ContextInfo.get_financial_data()
WARNING
a .需要提前下载 “财务数据”。
b. 此方法（函数）是一个 重载函数，即拥有2套参数列表。传入不同的参数，返回的结果也不一样。
c. 必须提前导入 Pandas 模块
功能：此方法用于获取财务数据，与界面中按 F10 键功能对应。 语法一： ContextInfo.get_financial_data(fieldList,stockList,startDate,endDate,report_type='announce_time') 语法二： ContextInfo.get_financial_data(tabname,colname,market,code,report_type='report_time',barpos) 参数： fieldList —— 字段列表。对应 财务分析 中的报表；
| 报表名称 | 内置字符串 | 原生字符串 |
|---|---|---|
| 资产负债表 | ASHAREBALANCESHEET | Balance |
| 利润表 | ASHAREINCOME | Income |
| 现金流表 | ASHARECASHFLOW | CashFlow |
| 股本表 | CAPITALSTRUCTURE | Capital |
| 主要指标 | PERSHAREINDEX | PershareIndex |
| 十大股东/十大流通股东 | TOP10HOLDER/TOP10FLOWHOLDER | Top10holder/Top10flowholder |
| 股东数 | SHAREHOLDER | Holdernum |
WARNING
以上表格中分别包括不同的字段，需配合下面的参数来获取具体的值。
stockList —— 列表（List），想要查询的股票代码列表。如：['600000.SH', '000001.SZ'] StartDate,endDate —— 查询时间段的开始时间和结束时间，格式如：“20220301”。 report_type —— 报表时间类型。此参数可省缺 ，默认按公告期区分数据。'report_time' 表示按报告时间，' announce_time' 表示按公告时间
TIP
'report_time' 和 ' announce_time' 的区别： 若某公司当年 4 月 26 日发布上年度年报，如果选择按照公告期取数，则当年 4 月 26 日之后至下个财报发布日期之间的数据都是上年度年报的财务数据。 若选择按照报告期取数，则上年度第 4 季度（上年度 10 月 1 日 - 12 月 31 日）的数据就是上年度报告期的数据。
返回：根据参数不同，返回的结果也不同。有可能是一个 Pandas 的数据帧，也可能是一个数值。具体详情请参考官方文档中的 “财务数据接口”章节。 “https://dict.thinktrader.net/dictionary/stock.html?id=PN4WZC#%E8%B4%A2%E5%8A%A1%E6%95%B0%E6%8D%AE%E5%88%97%E8%A1%A8”
示例：
#encoding:gbk
def init(ContextInfo):
fieldList = ['ASHAREBALANCESHEET.tot_liab']
stockList = ["000001.SZ","600000.SH",]
startDate = '20220920'
endDate = '20220930'
data = ContextInfo.get_financial_data(fieldList, stockList, startDate, endDate, report_type = 'report_time')
print(" 600000.SH 浦发银行 2022年9月底公布的 资产负债表中，负债合计是：")
print(data["600000.SH",'20220930'])
print(" 0000001.SZ 平安银行 2022年9月底公布的 资产负债表中，负债合计是：")
print(data["000001.SZ",'20220930'])
"""运行结果：
600000.SH 浦发银行 2022年9月底公布的 资产负债表中，负债合计是：
tot_liab 8.685534e+12
Name: 20220930, dtype: float64
0000001.SZ 平安银行 2022年9月底公布的 资产负债表中，负债合计是：
tot_liab 5.255519e+12Name: 20220930, dtype: float64
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
其实直接中文汉字也是可以的，如：
#encoding:gbk
def init(ContextInfo):
fieldList = ['资产负债表.负债合计']
stockList = ["000001.SZ","600000.SH",]
startDate = '20220920'
endDate = '20220930'
data = ContextInfo.get_financial_data(fieldList, stockList, startDate, endDate, report_type = 'report_time')
print(" 600000.SH 浦发银行 2022年9月底公布的 资产负债表中，负债合计是：")
print(data["600000.SH",'20220930'])
print(" 0000001.SZ 平安银行 2022年9月底公布的 资产负债表中，负债合计是：")
print(data["000001.SZ",'20220930'])
"""
600000.SH 浦发银行 2022年9月底公布的 资产负债表中，负债合计是：
负债合计 8.685534e+12
Name: 20220930, dtype: float64
0000001.SZ 平安银行 2022年9月底公布的 资产负债表中，负债合计是：
负债合计 5.255519e+12Name: 20220930, dtype: float64
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 3.29 获取原始财务数据
ContextInfo.get_raw_financial_data()
TIP
此方法与 与get_financial_data的区别是，不填充每个交易日的数据
功能：此方法用于获取财务数据，与界面中按 F10 键功能对应。 语法一： ContextInfo.get_raw_financial_data(fieldList,stockList,startDate,endDate,report_type='announce_time') 参数： fieldList —— 字段列表。对应 财务分析 中的报表与 get_financial_data() 相同； stockList —— 列表（List），想要查询的股票代码列表。如：['600000.SH', '000001.SZ'] StartDate,endDate —— 查询时间段的开始时间和结束时间，格式如：“20220301”。 report_type —— 报表时间类型。此参数可省缺 ，默认按公告期区分数据。'report_time' 表示按报告时间，' announce_time' 表示按公告时间
示例：
#encoding:gbk
def init(ContextInfo):
fieldList = ['资产负债表.负债合计']
stockList = ["000001.SZ"]
startDate = '20240920'
endDate = '20240930'
df=ContextInfo.get_raw_financial_data(fieldList,stockList,startDate,endDate,report_type = 'report_time') # 获取原始财务数据
print(df)
"""运行结果：
{'000001.SZ': {'资产负债表.负债合计': {1727625600000: 5255519010816.0}}}
其中 1727625600000 是时间戳
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
# 3.30 获取指定个股 / 合约 / 指数的 K 线（交易日）列表
ContextInfo.get_trading_dates()
WARNING
此方法在 init() 中是无效的，可在 after_init() 中使用。当然也可以在 handlebar() 中使用。但基本没什么用。
功能： 指定某个个股 / 合约 / 指数的 K 线（交易日）列表。
语法： ContextInfo.get_trading_dates(stockcode, start_date, end_date, count, period)
参数：
- stockcode —— string，某一支股票的代码如 '600000.SH'，默认为当前图代码。
- start_date —— string，开始时间，为空时不使用，如 '20170101'，'20170101000000'
- end_date —— string，结束时间，默认为当前bar的时间，如 '20170102'，'20170102000000'
- count —— int，K 线个数，必须大于 0，取包括 end_date 往前的 count 个 K 线，start_date 不为空时不使用
- period —— string，时间周期。如：'1d'：日线、'1m'：1分钟线、'1h'：小时线
返回： 一个列表List，其中包括 交易日，period为日线时返回 ['20170101', '20170102', ...]，其它返回['20170101010000', '20170102020000', ...]。有数据表示对应的时间上有K线数据
示例：
def handlebar(ContextInfo):
print(ContextInfo.get_trading_dates('600000.SH', '20170101', '20170401', 1, '1d'))
2
# 3.31 获取龙虎榜数据
ContextInfo.get_longhubang()
TIP
使用前需要提前下载 “龙虎榜数据”
功能： 获取龙虎榜数据。
语法：ContextInfo.get_longhubang(stock_list, startTime, endTime)
参数：
stock_list——股票列表，list，如 ['600000.SH', '600036.SH']
startTime——起始时间，如 '20170101'
endTime——结束时间，如 '20180101'
返回： Pandas 数据帧 Dataframe，其中包含的信息请见示例：
示例：
#coding:gbk
def init(ContextInfo):
print(ContextInfo.get_longhubang(['600027.SH'],'20190101','20230910'))
"""
运行结果：
stockCode stockName date reason close SpreadRate TurnoverVolume Turnover_Amount buyTraderBooth sellTraderBooth
0 600027.SH 华电国际 2021-09-23 00:00:00 非ST、*ST和S证券连续三个交易日内收盘价格涨幅偏离值累计达到20%的证券 5.44 8.15 76530.1299 388755.6709 traderName buyAmount buyPercent sellAmou... traderName buyAmount buyPerc...
1 600027.SH 华电国际 2021-10-20 00:00:00 有价格涨跌幅限制的日收盘价格涨幅偏离值达到7%的证券 4.48 10.07 11636.7716 50368.3519 traderName buyAmount bu... traderName buyAmount buyPercent ...
2 600027.SH 华电国际 2021-10-27 00:00:00 有价格涨跌幅限制的日价格振幅达到15%的证券 4.68 8.84 27722.0452 125135.0469 traderName buyAmount buyPercent s... traderName buyAmount buyPerce...
3 600027.SH 华电国际 2021-12-07 00:00:00 非ST、*ST和S证券连续三个交易日内收盘价格涨幅偏离值累计达到20%的证券 4.67 7.85 73638.2808 314165.6832 traderName buyAmount buyPer... traderName buyAmount buyPercent ...
4 600027.SH 华电国际 2022-02-25 00:00:00 有价格涨跌幅限制的日收盘价格涨幅偏离值达到7%的证券 4.35 10.13 15628.7642 65477.1779 traderName buyAmount buyPerc... traderName buyAmount buyPercent ...
5 600027.SH 华电国际 2022-09-07 00:00:00 非ST、*ST和S证券连续三个交易日内收盘价格涨幅偏离值累计达到20%的证券 6.94 9.98 40982.4477 256002.9234 traderName buyAmount buyPercent sellAmou... traderName buyAmount buyPercent sellAmoun...
6 600027.SH 华电国际 2022-10-11 00:00:00 有价格涨跌幅限制的日收盘价格涨幅偏离值达到7%的证券 6.47 10.03 7713.4191 48472.8911 traderName buyAmount buyPer... traderName buyAmount buyPercen...
7 600027.SH 华电国际 2022-11-29 00:00:00 有价格涨跌幅限制的日收盘价格跌幅偏离值达到7%的证券 5.94 -6.01 12295.4677 74357.9426 traderName buyAmount buyPercent sellAmount... traderName buyAmount buyPercent sellAmoun...
8 600027.SH 华电国际 2023-01-03 00:00:00 有价格涨跌幅限制的日收盘价格涨幅偏离值达到7%的证券 6.47 10.03 14498.3965 90578.7301 traderName buyAmount buyPerc... traderName buyAmount buyPercent se...9 600027.SH 华电国际 2023-05-29 00:00:00 有价格涨跌幅限制的日收盘价格涨幅偏离值达到7%的证券 7.12 10.05 19955.4837 137691.0019 traderName buyAmount buyPercent ... traderName buyAmount buyPerce...
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
其中字段的表达意义如下：
| 字段名称 | 说明 |
|---|---|
| reason | 上榜原因 |
| close | 收盘价 |
| spreadRate | 涨跌幅 |
| TurnoverVolune | 成交量 |
| Turnover_Amount | 成交金额 |
| buyTraderBooth | 买方席位,datframe |
| sellTraderBooth | 卖方席位,datframe |
buyTraderBooth 或 sellTraderBooth 包含字段：
| 字段名称 | 说明 |
|---|---|
| traderName | 交易营业部名称 |
| buyAmount | 买入金额 |
| buyPercent | 买入金额占总成交占比 |
| sellAmount | 卖出金额 |
| sellPercent | 卖出金额占总成交占比 |
| totalAmount | 该席位总成交金额 |
| rank | 席位排行 |
| direction | 买卖方向 |
# 3.32 获取十大股东数据
ContextInfo.get_top10_share_holder()
功能： 获取十大股东数据。
语法： get_top10_share_holder(self, stock_list, data_name, start_time, end_time)
参数：
- data_name —— flow_holder 或 holder
- stock_list —— 股票列表，list，如['600000.SH', '600036.SH']
- startTime —— 起始时间，如 '20170101'
- endTime —— 结束时间，如 '20180101'
返回：Pandas 数据类型
示例：
#coding:gbk
def init(ContextInfo):
df = ContextInfo.get_top10_share_holder(['600027.SZ'], 'flow_holder', '20230101', '20230101')
print('\n',df)
2
3
4
5
6
| 字段名称 | 说明 |
|---|---|
| holdName | 股东名称 |
| holderType | 持股类型 |
| holdNum | 持股数量 |
| changReason | 变动原因 |
| holdRatio | 持股比例 |
| stockType | 股份性质 |
| rank | 持股排名 |
| status | 持股状态 |
| changNum | 增减数量 |
| changeRatio | 增减比例 |
# 3.33 获取股东数数据
ContextInfo.get_holder_num()
功能： 获取股东数数据。
语法： ContextInfo.get_holder_num(stock_list,start_time,end_time)
参数：
- stock_list —— 股票列表,list,如['600000.SH','600036.SH']
- startTime —— 起始时间,如'20170101'
- endTime —— 结束时间,如'20180101'
返回： pd.DataFrame，字段如下
| 字段名称 | 说明 |
|---|---|
| stockCode | 产品代码 |
| timetag | 日期 |
| holdNum | 股东总数 |
| AHoldNum | A股股东户数 |
| BHoldNum | B股股东户数 |
| HHoldNum | H股股东户数 |
| uncirculatedHoldNum | 已流通股东户数 |
| circulatedHoldNum | 未流通股东户数 |
示例：
#coding:gbk
def init(ContextInfo):
df = ContextInfo.get_holder_num(['000002.SZ'],'20100101','20180101')
print('\n',df)
2
3
4
5
6
# =====用于期货市场=====
在迅投QMT中，国内各期货市场的简称代码，参照表如下：
| 市场 | 市场代码 | 迅投市场代码 |
|---|---|---|
| 上期所 | SHFE | SF |
| 大商所 | DCE | DF |
| 郑商所 | CZCE | ZF |
| 中金所 | CFFEX | IF |
| 能源中心 | INE | INE |
| 广期所 | GFEX | GF |
中金所
| 名称 | 主力连续代码 | 加权合约代码 | 开始时间 | 退市时间 | 备注 |
|---|---|---|---|---|---|
| 沪深 300 合约 | IF00.IF | IFJQ00.IF | 2010-04-16 | ||
| 5 年期国债合约 | TF00.IF | TFJQ00.IF | 2013-09-06 | ||
| 10 年期国债合约 | T00.IF | TJQ00.IF | 2015-03-20 | ||
| 中证 500 合约 | IC00.IF | ICJQ00.IF | 2015-04-16 | ||
| 上证 50 合约 | IH00.IF | IHJQ00.IF | 2015-04-16 | ||
| 2 年期国债合约 | TS00.IF | TSJQ00.IF | 2018-08-17 | ||
| 中证 1000 合约 | IM00.IF | IMJQ00.IF | 2022-07-22 | ||
| 30 年期国债合约 | TL00.IF | TLJQ00.IF | 2023-04-21 |
大商所
| 名称 | 主力连续代码 | 加权合约代码 | 开始时间 | 退市时间 | 备注 |
|---|---|---|---|---|---|
| 豆一合约 | a00.DF | aJQ00.DF | 2005-01-03 | ||
| 豆二合约 | b00.DF | bJQ00.DF | 2005-01-03 | ||
| 豆粕合约 | m00.DF | mJQ00.DF | 2005-01-03 | ||
| 玉米合约 | c00.DF | cJQ00.DF | 2005-01-03 | ||
| 豆油合约 | y00.DF | yJQ00.DF | 2006-01-09 | ||
| 聚乙烯合约 | l00.DF | lJQ00.DF | 2007-07-31 | ||
| 棕榈油合约 | p00.DF | pJQ00.DF | 2007-10-29 | ||
| 聚氯乙烯合约 | v00.DF | vJQ00.DF | 2009-05-25 | ||
| 焦炭合约 | j00.DF | jJQ00.DF | 2011-04-15 | ||
| 焦煤合约 | jm00.DF | jmJQ00.DF | 2013-03-22 | ||
| 铁矿石合约 | i00.DF | iJQ00.DF | 2013-10-18 | ||
| 鸡蛋合约 | jd00.DF | jdJQ00.DF | 2013-11-08 | ||
| 胶合板合约 | bb00.DF | bbJQ00.DF | 2013-12-06 | ||
| 纤维板合约 | fb00.DF | fbJQ00.DF | 2013-12-06 | ||
| 聚丙烯合约 | pp00.DF | ppJQ00.DF | 2014-02-28 | ||
| 玉米淀粉合约 | cs00.DF | csJQ00.DF | 2014-12-19 | ||
| 乙二醇合约 | eg00.DF | egJQ00.DF | 2018-12-10 | ||
| 粳米合约 | rr00.DF | rrJQ00.DF | 2019-08-16 | ||
| 苯乙烯合约 | eb00.DF | ebJQ00.DF | 2019-09-26 | ||
| 液化石油气合约 | pg00.DF | pgJQ00.DF | 2020-03-30 | ||
| 生猪合约 | lh00.DF | lhJQ00.DF | 2021-01-08 |
上海国际能源交易中心
| 名称 | 主力连续代码 | 加权合约代码 | 开始时间 | 退市时间 | 备注 |
|---|---|---|---|---|---|
| 原油合约 | sc00.INE | scJQ00.INE | 2018-03-27 | ||
| 20 号胶合约 | nr00.INE | nrJQ00.INE | 2019-08-12 | ||
| 低硫燃料油合约 | lu00.INE | luJQ00.INE | 2020-06-22 | ||
| 阴极铜合约 | bc00.INE | bcJQ00.INE | 2020-11-19 | ||
| 集运指数（欧线）合约 | ec00.INE | ecJQ00.INE | 2023-08-18 |
广期所
| 名称 | 主力连续代码 | 加权合约代码 | 开始时间 | 退市时间 | 备注 |
|---|---|---|---|---|---|
| 碳酸锂 | lc00.GF | lcJQ00.GF | 2023-07-21 | ||
| 工业硅 | si00.GF | siJQ00.GF | 2022-12-22 |
上期所
| 名称 | 主力连续代码 | 加权合约代码 | 开始时间 | 退市时间 | 备注 |
|---|---|---|---|---|---|
| 铝合约 | al00.SF | alJQ00.SF | 2005-01-03 | ||
| 天然橡胶合约 | ru00.SF | ruJQ00.SF | 2005-01-03 | ||
| 燃料油合约 | fu00.SF | fuJQ00.SF | 2005-01-03 | ||
| 铜合约 | cu00.SF | cuJQ00.SF | 2005-01-03 | ||
| 锌合约 | zn00.SF | znJQ00.SF | 2007-03-26 | ||
| 黄金合约 | au00.SF | auJQ00.SF | 2008-01-09 | ||
| 线材合约 | wr00.SF | wrJQ00.SF | 2009-03-27 | ||
| 螺纹钢合约 | rb00.SF | rbJQ00.SF | 2009-03-27 | ||
| 铅合约 | pb00.SF | pbJQ00.SF | 2011-03-24 | ||
| 白银合约 | ag00.SF | agJQ00.SF | 2012-05-10 | ||
| 石油沥青合约 | bu00.SF | buJQ00.SF | 2013-10-09 | ||
| 热轧卷板合约 | hc00.SF | hcJQ00.SF | 2014-03-21 | ||
| 锡合约 | sn00.SF | snJQ00.SF | 2015-03-27 | ||
| 镍合约 | ni00.SF | niJQ00.SF | 2015-03-27 | ||
| 纸浆合约 | sp00.SF | spJQ00.SF | 2018-11-27 | ||
| 不锈钢合约 | ss00.SF | ssJQ00.SF | 2019-09-25 | ||
| 氧化铝合约 | ao00.SF | aoJQ00.SF | 2023-06-19 | ||
| 丁二烯橡胶合约 | br00.SF | brJQ00.SF | 2023-07-28 |
郑商所
| 名称 | 主力连续代码 | 加权合约代码 | 开始时间 | 退市时间 | 备注 |
|---|---|---|---|---|---|
| 硬白小麦合约 | WT00.ZF | WTJQ00.ZF | 2005-01-03 | 2012-11-22 | |
| 强麦合约 | WS00.ZF | WSJQ00.ZF | 2005-01-03 | 2013-05-23 | WS为旧的强麦合约代码，自WS 1305 停止执行 |
| 绿豆合约 | GN00.ZF | GNJQ00.ZF | 2005-01-03 | 2010-03-23 | |
| 棉花合约 | CF00.ZF | CFJQ00.ZF | 2005-01-03 | ||
| 白糖合约 | SR00.ZF | SRJQ00.ZF | 2006-01-06 | ||
| PTA合约 | TA00.ZF | TAJQ00.ZF | 2006-12-18 | ||
| 菜籽油合约 | RO00.ZF | ROJQ00.ZF | 2007-06-08 | 2013-05-15 | RO为旧的菜籽油合约, 自RO 1305 停止执行 |
| 早籼稻合约 | ER00.ZF | ERJQ00.ZF | 2009-04-20 | 2013-05-23 | ER为旧的早籼稻合约, 自ER 1305 停止执行 |
| 甲醇合约 | MA00.ZF | MAJQ00.ZF | 2011-10-28 | 2015-05-15 | |
| 普麦合约 | PM00.ZF | PMJQ00.ZF | 2012-01-17 | ||
| 菜籽油合约 | OI00.ZF | OIJQ00.ZF | 2012-07-16 | OI为新的菜籽油合约, 自OI 1307 开始执行 | |
| 强麦合约 | WH00.ZF | WHJQ00.ZF | 2012-07-24 | WH为新的强麦合约代码，自WH 1307 开始执行 | |
| 早籼稻合约 | RI00.ZF | RIJQ00.ZF | 2012-07-24 | RI为新的早籼稻合约, 自RI 1307 开始执行 | |
| 玻璃合约 | FG00.ZF | FGJQ00.ZF | 2012-12-03 | ||
| 菜籽粕合约 | RM00.ZF | RMJQ00.ZF | 2012-12-28 | ||
| 油菜籽合约 | RS00.ZF | RSJQ00.ZF | 2012-12-28 | ||
| 动力煤合约 | TC00.ZF | TCJQ00.ZF | 2013-09-26 | 2016-04-08 | TC为旧的动力煤合约，自TC 1605 停止执行 |
| 粳稻谷合约 | JR00.ZF | JRJQ00.ZF | 2013-11-18 | ||
| 甲醇合约 | MA00.ZF | MAJQ00.ZF | 2014-06-17 | MA为新的甲醇合约代码，自MA 1506 开始执行 | |
| 晚籼稻合约 | LR00.ZF | LRJQ00.ZF | 2014-07-08 | ||
| 硅铁合约 | SF00.ZF | SFJQ00.ZF | 2014-08-08 | ||
| 锰硅合约 | SM00.ZF | SMJQ00.ZF | 2014-08-08 | ||
| 动力煤合约 | ZC00.ZF | ZCJQ00.ZF | 2015-05-18 | ZC为新的动力煤合约，自ZC 1605 开始执行 | |
| 棉纱合约 | CY00.ZF | CYJQ00.ZF | 2017-08-18 | ||
| 苹果合约 | AP00.ZF | APJQ00.ZF | 2017-12-22 | ||
| 红枣合约 | CJ00.ZF | CJJQ00.ZF | 2019-04-30 | ||
| 尿素合约 | UR00.ZF | URJQ00.ZF | 2019-08-09 | ||
| 纯碱合约 | SA00.ZF | SAJQ00.ZF | 2019-12-06 | ||
| 短纤合约 | PF00.ZF | PFJQ00.ZF | 2020-10-12 | ||
| 花生合约 | PK00.ZF | PKJQ00.ZF | 2021-02-01 | ||
| 烧碱合约 | SH00.ZF | SHJQ00.ZF | 2023-09-15 | ||
| 对二甲苯合约 | PX00.ZF | PXJQ00.ZF | 2023-09-15 |
# 3.34 获取当前期货主力合约
ContextInfo.get_main_contract()
功能： 获取当前期货主力合约。
语法： ContextInfo.get_main_contract(codemarket)
参数： codemarket —— 主力连续代码，格式为品种名加00，如“IF00.IF”，“zn00.SF”，“SA00.ZF”
返回： 字符串str，当月主力合约代码
示例：
#coding:gbk
def init(ContextInfo):
print("当前主力合约的代码:",ContextInfo.get_main_contract('IF00.IF'))
"""
运行结果：
当前主力合约的代码: IF2009
"""
2
3
4
5
6
7
8
# 3.35 获取合约乘数
ContextInfo.get_contract_multiplier()
功能： 获取合约乘数。
语法： ContextInfo.get_contract_multiplier(contractcode)
参数： contractcode —— 字符串型。合约代码， 'code.market'，如：“IF1707.IF”
返回： 数值
示例：
#coding:gbk
def init(ContextInfo):
print("合约 IF1707.IF 的乘数:",ContextInfo.get_contract_multiplier('IF1707.IF'))
"""
运行结果：
合约 IF1707.IF 的乘数: 300
"""
2
3
4
5
6
7
8
# 3.36 获取期货合约到期日
ContextInfo.get_contract_expire_date()
功能： 获取期货合约到期日。
语法： ContextInfo.get_contract_expire_date(codemarket)
参数：
- Codemarket —— 合约和市场,如IF00.IF,zn00.SF
返回：整数值 int，表示合约到期日
示例：
#coding:gbk
def init(ContextInfo):
print("合约 IF00.IF 的到期日是:", ContextInfo.get_contract_expire_date('IF00.IF'))
"""
运行结果：
合约 IF00.IF 的到期日是: 20230915
"""
2
3
4
5
6
7
8
# 3.37 获取指定期权品种的详细信息
ContextInfo.get_option_detail_data()
功能： 获取指定期权品种的详细信息。
语法： ContextInfo.get_option_detail_data(optioncode)
参数：
- optioncode —— 期权代码,如'10001506.SHO',参数必填，可以为空字符串，则取当前主图的品种
返回：一个字典。其中包含的信息请参考示例
示例：
#coding:gbk
def init(ContextInfo):
print('\n期权品种 10001506.SHO 的详细信息如下：')
print(ContextInfo.get_option_detail_data('10001506.SHO'))
"""
期权品种 10001506.SHO 的详细信息如下：
{'ExchangeID': 'SHO', # 期权市场代码
'InstrumentID': '10001506', # 期权代码
'ProductID': '50ETF(510050)', # 期权标的的产品ID
'OpenDate': 20181025, # 发行日期
'ExpireDate': 20190626, # 到期日
'PreClose': 0.3711, # 前收价格
'SettlementPrice': 0.3701, # 前结算价格
'UpStopPrice': 0.662, # 当日涨停价
'DownStopPrice': 0.0001, # 当日跌停价
'LongMarginRatio': 12.0, # 多头保证金率
'ShortMarginRatio': 7.0, # 空头保证金率
'PriceTick': 0.0001, # 最小变价单位
'VolumeMultiple': 10202, # 合约乘数
'MaxMarketOrderVolume': 10, # 涨跌停价最大下单量
'MinMarketOrderVolume': 1, # 涨跌停价最小下单量
'MaxLimitOrderVolume': 1, # 限价单最大下单量
'MinLimitOrderVolume': 1, # 限价单最小下单量
'OptUnit': 1.7976931348623157e+308, # 期权合约单位
'MarginUnit': 7349.32, # 期权单位保证金
'OptUndlCode': '', # 期权标的证券代码
'OptUndlMarket': '', # 期权标的证券市场
'OptExercisePrice': 2.549, # 期权行权价
'NeeqExeType': 0, # 全国股转转让类型
'OptUndlRiskFreeRate': 1.7976931348623157e+308, # 期权标的无风险利率
'OptUndlHistoryRate': 1.7976931348623157e+308, # 期权标的历史波动率
'EndDelivDate': 20190626, # 期权行权终止日
'optType': 'CALL'
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 3.38 获取指定期权标的对应的期权品种列表
ContextInfo.get_option_undl_data()
功能： 获取指定期权标的对应的期权品种列表。
语法： ContextInfo.get_option_undl_data(undl_code_ref)
参数：
- undl_code_ref——期权标的代码,如'510300.SH'，传空字符串时获取全部标的数据
返回：
指定期权标的代码时返回对应该标的的期权合约列表list
期权标的代码为空字符串时返回全部标的对应的品种列表的字典dict
示例：
#coding:gbk
def init(ContextInfo):
print('\n期权标的 510300.SH 对应的期权品种如下：')
print(ContextInfo.get_option_undl_data('510300.SH'))
"""
运行结果：
期权标的 510300.SH 对应的期权品种如下：
['10005123.SHO', '10005124.SHO', '10005125.SHO', '10005126.SHO', '10005127.SHO', '10005128.SHO', '10005129.SHO', '10005130.SHO', '10005131.SHO', '10005132.SHO', '10005133.SHO', '10005134.SHO', '10005135.SHO', '10005136.SHO', '10005137.SHO', '10005138.SHO', '10005139.SHO', '10005140.SHO', ...
]
"""
2
3
4
5
6
7
8
9
10
11
# 3.39 获取指定期权列表
ContextInfo.get_option_list()
功能： 获取指定期权列表。如获取历史期权，需先下载过期合约列表。
语法： ContextInfo.get_option_list(undl_code,dedate,opttype,isavailable)
参数：
- undl_code——期权标的代码,如'510300.SH'
- dedate——期权到期月或当前交易日期，"YYYYMM"格式为期权到期月，"YYYYMMDD"格式为获取当前日期交易的期权
- opttype——期权类型，默认值为空，"CALL"，"PUT"，为空时认购认沽都取
- isavailable——是否可交易，当dedate的格式为"YYYYMMDD"格式为获取当前日期交易的期权时，isavailable为True时返回当前可用，为False时返回当前和历史可用
返回： 期权合约列表list
示例：
# 获取到期月份为202101的上交所510300ETF认购合约
data=ContextInfo.get_option_list('510300.SH','202101',"CALL")
# 获取20210104当天上交所510300ETF可交易的认购合约
data=ContextInfo.get_option_list('510300.SH','20210104',"CALL",True)
# 获取20210104当天上交所510300ETF已经上市的认购合约(包括退市)
data=ContextInfo.get_option_list('510300.SH','20210104',"CALL",False)
2
3
4
5
6
7
8
# 3.40 获取股票期权的实时隐含波动率
ContextInfo.get_option_iv()
功能： 获取股票期权的实时隐含波动率。
语法： ContextInfo.get_option_iv(optioncode)
参数：
- optioncode——期权代码，如'10003280.SHO'
返回： 浮点数
示例：
#coding:gbk
def init(ContextInfo):
print(ContextInfo.get_option_iv('10003280.SHO'))
2
3
4
5
# 3.41 基于BS模型计算欧式期权理论价格
ContextInfo.bsm_price()
功能： 基于Black-Scholes-Merton模型，输入期权标的价格、期权行权价、无风险利率、期权标的年化波动率、剩余天数、标的分红率、计算期权的理论价格。
语法： ContextInfo.bsm_price(optionType,objectPrices,strikePrice,riskFree,sigma,days,dividend)
参数：
- optionType——期权类型，认购：'C'，认沽：'P'
- objectPrices——期权标的价格，可以是价格列表或者单个价格
- strikePrice——期权行权价
- riskFree——无风险收益率
- sigma——标的波动率
- days——剩余天数
- dividend——分红率
返回：objectPrices为float时，返回float；objectPrices为list时，返回list；计算结果最小值0.0001，结果保留4位小数。如果输入非法参数则返回NaN
示例：
import numpy as np
object_prices=list(np.arange(3,4,0.01));
#计算剩余15天的行权价3.5的认购期权,在无风险利率3%,分红率为0,标的年化波动率为23%时标的价格从3元到4元变动过程中期权理论价格序列
prices=ContextInfo.bsm_price('C',object_prices,3.5,0.03,0.23,15,0)
print(prices);
#计算剩余15天的行权价3.5的认购期权,在无风险利率3%,分红率为0,标的年化波动率为23%时标的价格为3.51元的平值期权的理论价格
price=ContextInfo.bsm_price('C',3.51,3.5,0.03,0.23,15,0)
print(price);
2
3
4
5
6
7
8
# 3.42 基于BS模型计算欧式期权隐含波动率
ContextInfo.bsm_iv()
功能： 基于Black-Scholes-Merton模型,输入期权标的价格、期权行权价、期权现价、无风险利率、剩余天数、标的分红率,计算期权的隐含波动率。
语法： ContextInfo.bsm_iv(optionType,objectPrices,strikePrice,optionPrice,riskFree,days,dividend)
参数：
- optionType——期权类型，认购：'C'，认沽：'P'
- objectPrice——期权标的价格
- strikePrice——期权行权价
- optionPrice——期权现价
- riskFree——无风险收益率
- days——剩余天数
- dividend——分红率
返回： 浮点数
示例：
iv=ContextInfo.bsm_iv('C',3.51,3.5,0.0725,0.03,15);
#计算剩余15天的行权价3.5的认购期权,在无风险利率3%,分红率为0时,标的现价3.51元,期权价格0.0725元时的隐含波动率
2
# =====几乎不用=====
# 3.43 获取历史行情 ContextInfo.get_history_data()
WARNING
此方法已不再使用，请使用 ContextInfo.get_market_data_ex()
# 3.44 下载指定合约代码指定周期对应时间范围的行情数据
down_history_data()
download_history_data()
功能： 下载指定合约代码指定周期对应时间范围的行情数据。
语法：
down_history_data(stockcode,period,startTime,endTime)
download_history_data(stockcode,period,startTime,endTime)
TIP
此方法意指在策略运行时下载历史数据，但几乎不会应用在实际工作中，强烈建议手动在主界面顶部菜单中，点击 “操作” --> “数据管理” 面板中下载历史数据。
参数：
stockcode——string，股票代码，形式如'stkcode.market'，如'600000.SH'
period——string，时间周期，'tick' 表示 分笔线，'1d' 表示 日线，'1m'：表示1分钟线，'5m' 表示 5分钟线
startTime，endTime：string —— 分别代表起止时间，"20200101"或"20200101093000"，可以为空；
示例：
#encoding:gbk
def init(ContextInfo):
down_history_data("600000.SH","1d","","")
# 执行后没有任何反馈，也没有进度条之类的提示。因此几乎不用。
2
3
4
5
6
# 3.45 获取本地行情数据
ContextInfo.get_local_data()
功能： 获取某一个指定品种的本地行情数据。使用前需提前下载好历史数据。 此方法同 ContextInfo.get_history_data()一样，几乎已弃用。
语法： ContextInfo.get_local_data(stock_code,start_time='',end_time='',period='1d',divid_type='none',count=-1) 参数：
stock_code —— 字符串型。表示想要获取的品种代码。
start_date —— 字符串型（String），表示开始时间，如 '20170101'，'20170101000000'。如果缺省则表示不使用
end_date —— 字符串型（String），表示结束时间，如 '20170101'，'20170101000000'。如果缺省则使用当前 K 线的时间
period —— 字符串型（String），指定时间周期。
dividend_type —— 数值型（number），表示复权类型，默认为 不复权。
| 字符串 | 表达意义 |
|---|---|
| 0 | 不复权 |
| 1 | 向前复权 |
| 2 | 向后复权 |
| 3 | 等比向前复权 |
| 4 | 等比向后复权 |
count —— 默认参数，缺省值为 -1，大于等于 0 时，效果与 获取历史行情数据的方法（get_history_data） 保持一致。
如果此参数 count 和 参数 start_time/end_time 同时使用，则最终的效果如下表所示：
| count 取值 | start_time/end_time是否生效 | start_time/end_time设置效果 |
|---|---|---|
| count >= 0 | 无效 | 从当前时间往回取多少个周期的值，取值数量完全取决于 count |
| count = -1 | 生效 | 同时设置开始时间和结束时间，在所设置的时间段内取值 |
| count = -1 | 生效 | 开始时间结束时间都不设置，取当前最新bar的值 |
| count = -1 | 生效 | 只设置开始时间，取所设开始时间到当前时间的值 |
| count = -1 | 生效 | 只设置结束时间，取股票上市第一根 bar 到所设结束时间的值 |
返回：返回一个字典（Dict），键（key） 为 timetag，值（value）为另一个 Dict (valuedict)
当参数 period='tick' 时，返回值为分笔数据，valuedict 字典中包含的 key 如下：
{
'lastPrice'： # 最新价
'amount'： # 成交额
'volume'： # 成交量
'pvolumn'： # 前成交量
'openInt'： # 持仓量
'stockStatus'： # 股票状态
'lastSettlementPrice'： # 最新结算价
'open': # 开盘价
'high': # 最高价
'low': # 最低价
'settlementPrice'： # 结算价
'lastClose': # 昨收盘价
'askPrice'： # 列表（List)，卖价五档
'bidPrice'： # 列表（List)，买价五档
'askVol'： # 列表（List)，卖量五档
'bidVol'； # 列表（List)，买量五档
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
当参数 period 为其它值时，valuedict字典中包含的 key 如下：
{
amount： # 成交额
volume： # 成交量
open： # 开盘价
high： # 最高价
low： # 最低价
close： # 收盘价
}
2
3
4
5
6
7
8
*注：时间区间两边闭区间
示例：
#encoding:gbk
def init(ContextInfo):
# 需提前下载好本地数据
Result = ContextInfo.get_local_data(
stock_code='600027.SH', # 指定品种
start_time='20200901',
end_time='20200905',
period='1m',
divid_type='none'
)
print(Result) # 打印输出
"""
如果返回值为一个 空字典 {} ，则需检查是否已下载了历史数据。
运行结果：
{1693531860000: # 对应的时间戳
{'open': 5.06, # 开盘价
'high': 5.09, # 最高价
'low': 5.04, # 最低价
'close': 5.06, # 收盘价
'volume': 14988, # 成交量
'amount': 7586910.0 # 成交金额
},
1693531920000:
{'open': 5.05,
'high': 5.05,
'low': 5.03,
'close': 5.04,
'volume': 11412,
'amount': 5752400.0
},
1693531980000:
{'open': 5.04,
'high': 5.05,
'low': 5.03,
'close': 5.04,
'volume': 8661,
'amount': 4365096.0
},
1693532040000:
{'open': 5.04,
'high': 5.04,
'low': 5.03,
'close': 5.04,
'volume': 5682,
'amount': 2860395.0
},
......
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# 3.46 根据ETF基金代码获取ETF申赎清单及对应成分股数据
get_etf_info()
功能： 根据指定的ETF基金代码获取申赎清单及对应成分股数据。此方法需要ETF交易权限，并且需要提前下载申赎清单数据。如帐户没有相应权限，则无法使用。
语法： get_etf_info(stockcode)
参数：
stockcode —— ETF基金代码，如"510050.SH" 返回：
返回一个字典dict，其中包含的数据详见示例：
示例：
#encoding:gbk
def init(ContextInfo):
# 获取ETF基金代码为511050的全部ETF申赎清单数据
print(get_etf_info("510050.SH"))
"""
运行结果：
{'etfCode': '510050', # ETF 代码
'etfExchID': 'SH', # 交易所
'prCode': '510050', # 基金申赎代码
'cashBalance': 62182.33, # 现金差额（单位：元）
'maxCashRatio': 0.5, # 现金替代比例上限
'reportUnit': 900000, # 最小申购、赎回单位（单位：份）
'name': ' ', # 基金名称
'navPerCU': 2374240.29, # 最小申购、赎回单位净值（单位：元）
'nav': 2.638, # 基金份额净值（单位：元）
'ecc': 67484.89, # 预估现金差额（单位：元）
'needPublish': 1, # 是否需要公布IOPV（1：是，0：否）
'enableCreation': 1, # 是否允许申购（1：是，0：否）
'enableRedemption': 1, # 是否允许赎回（1：是，0：否）
'creationLimit': 0, # 申购上限（单位:份，0：不限制）
'redemptionLimit': 0, # 赎回上限（单位:份，0：不限制）
'type': 14,
'tradingDay': '', # 交易日期（格式YYYYMMDD）
'preTradingDay': '', # 前交易日期（格式YYYYMMDD）
'stocks': # 成分股列表
{'600010.SH': # 股票代码
{'exchangeID': 'SH', # ETF基金市场代码
'etfCode': '510050', # ETF基金代码
'etfName': ' ', # ETF基金名称
'componentExchID': 'SH', # 成份股市场代码
'componentCode': '600010', # 成份股代码
'componentName': '包钢股份', # 成份股名称
'componentVolume': 7900, # 成份股数量
'ReplaceFlag': 49, # 替代标记（48:禁止替代，49：允许替代，50：必须替代，51：替补替代）
'ReplaceRatio': 0.1, # 溢价比率
'ReplaceBalance': 0.0 # 替代金额
},
'600028.SH':
{'exchangeID': 'SH',
'etfCode': '510050',
'etfName': ' ',
'componentExchID': 'SH',
'componentCode': '600028',
'componentName': '中国石化',
'componentVolume': 6600,
'ReplaceFlag': 49,
'ReplaceRatio': 0.1,
'ReplaceBalance': 0.0
},
'600030.SH':
{'exchangeID': 'SH',
'etfCode': '510050',
'etfName': ' ',
'componentExchID': 'SH',
'componentCode': '600030',
'componentName': '中信证券',
'componentVolume': 3400,
'ReplaceFlag': 49,
'ReplaceRatio': 0.1,
'ReplaceBalance': 0.0
},
...
}
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
# 3.47 根据ETF基金代码获取ETF的基金份额参考净值
get_etf_iopv()
功能： 根据ETF基金代码获取ETF的基金份额参考净值
语法： get_etf_iopv(stockcode)
参数：
- stockcode：ETF基金代码（如"510050.SH"）
返回： IOPV，基金份额参考净值
示例：
#encoding:gbk
def init(ContextInfo):
# ETF基金 511050 的 净值
print(get_etf_iopv("510050.SH"))
"""
运行结果：
2.613
"""
2
3
4
5
6
7
8
9
# 3.48 获取某只指数历史调整日的历史的成分股列表
ContextInfo.get_his_index_data()
使用前需要下载 “板块成分股”，否则此方法返回值是一个空列表。
功能： 获取某只指数历史调整日的历史的成分股列表。
参数：
- stockcode —— 股票代码，如'000300.SH'
返回： 一个字典，其中的key是日期，对应的值即是当天调整的股票代码。
示例：
#encoding:gbk
def init(ContextInfo):
print("\n沪深300指数 曾经调整的股票代码：\n")
print(ContextInfo.get_his_index_data('000300.SH'))
"""
运行结果：
沪深300指数 曾经调整的股票代码：
{'20050408': ['000001.SZ', '000002.SZ', '000009.SZ', '000012.SZ', '000016.SZ', '000021.SZ', ...]
"""
2
3
4
5
6
7
8
9
10
11
# 3.49 获取市场已退市合约
ContextInfo.get_his_contract_list()
使用前需要下载 “过期合约列表”，否则此方法返回值是一个空列表。当然，基本也用不上这个方法。谁没事去查已经退市的品种？
功能： 获取市场已退市合约。执行前需要提前下载好 “过期合约列表”。
参数：
- market ——市场代码。如：上证所SH、深交所SZ、上期所SF、大商所DF、郑商所ZF、中金所IF、能源中心INE、沪港通HGT、 深港通SGT、外部自定义市场ED。
返回： 列表list。其中包含合约品种的代码。
示例：
#encoding:gbk
def init(ContextInfo):
print("上海沪市已退市的品种合约有：\n",ContextInfo.get_his_contract_list('SH'))
"""
运行结果：
【2023-09-08 09:27:38.805】 上海沪市已退市的品种合约有：
['719103.SH', '141945.SH', '105901.SH', '708376.SH', '512571.SH', '134338.SH', '164862.SH', '161109.SH', '106327.SH', '148333.SH', '122480.SH', '787633.SH', '756797.SH', '134723.SH', '787228.SH', '517801.SH', '148728.SH', '161512.SH', '172670.SH', '104230.SH', '127441.SH', '136634.SH', '000842.SH', '136519.SH', '600485.SH', '517286.SH', '172146.SH', '163333.SH', '140542.SH', '136102.SH', '174610.SH', '020323.SH', '738153.SH', '732518.SH', '124951.SH', '130654.SH', '521969.SH', '732103.SH', '738548.SH', '176707.SH', '107291.SH', '511861.SH', '144303.SH', '787105.SH', '106411.SH', '736359.SH', '148405.SH', '147925.SH', '515391.SH', '161224.SH', '715133.SH', '134015.SH', '103961.SH', '136176.SH', '172529.SH', ......]
"""
2
3
4
5
6
7
8
9
10
11
# 3.50 获取对应周期的北向数据
ContextInfo.get_north_finance_change()
功能： 获取对应周期的北向数据。
语法： ContextInfo.get_north_finance_change(period)
参数：period —— '1d' 表示日线 ；'1m' 表示一分钟
返回：一个字典dict，其中的key是时间戳， 对应的 value值仍然是一个dict，其中包含的信息详见以下示例：
示例：
#encoding:gbk
def init(ContextInfo):
print("\n北向资金当日数据：\n",ContextInfo.get_north_finance_change('1d'))
"""
运行结果：
北向资金当日数据：
{1416153600000:
{'hgtNorthBuyMoney': 120820000, # 沪港通HGT北向买入资金
'hgtNorthSellMoney': 0, # 沪港通HGT北向卖出资金
'hgtSouthBuyMoney': 1772000000, # 沪港通HGT南向买入资金
'hgtSouthSellMoney': 84000000, # 沪港通HGT南向卖出资金
'sgtNorthBuyMoney': 0, # 深港通SGT北向买入资金
'sgtNorthSellMoney': 0, # 深港通SGT北向卖出资金
'sgtSouthBuyMoney': 0, # 深港通SGT南向买入资金
'sgtSouthSellMoney': 0, # 深港通SGT南向卖出资金
'hgtNorthNetInFlow': 13000000000, # 沪港通HGT北向资金净流入
'hgtNorthBalanceByDay': 0, # 沪港通HGT北向当日资金余额
'hgtSouthNetInFlow': 1768000000, # 沪港通HGT南向资金净流入
'hgtSouthBalanceByDay': 8732000000, # 沪港通HGT南向当日资金余额
'sgtNorthNetInFlow': 0, # 深港通SGT北向资金净流入
'sgtNorthBalanceByDay': 0, # 深港通SGT北向当日资金余额
'sgtSouthNetInFlow': 0, # 深港通SGT南向资金净流入
'sgtSouthBalanceByDay': 0 # 深港通SGT南向当日资金余额
}
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 3.51 获取（北向）指定品种的持股统计及明细
ContextInfo.get_hkt_statistics()
ContextInfo.get_hkt_details()
这2个方法是与 北向资金有关的持股信息。需要提前下载好 “港股资金流向数据”，否则无返回值。
功能： 获取北向持股中，指定品种的有关数据。
参数：stockcode —— 指定的股票品种，如：600000.SH
返回：一个字典，其中key值是统计数据的时间戳，对应的 value 仍是一个字典，所包含内容详见示例：
#encoding:gbk
def init(ContextInfo):
print("\n北向资金持股中 600000.SH 的统计信息如下：\n")
print(ContextInfo.get_hkt_statistics('600000.SH'))
print('==============分割线====================')
print("\n北向资金持股中 600000.SH 的详细信息如下：\n")
print(ContextInfo.get_hkt_details('600000.SH'))
print("\n\n如返回值为空，请先在 数据管理 中下载“港股资金流向数据”")
"""
北向资金持股中 600000.SH 的统计信息如下：
{1507478400000: # 统计的时间戳
{'stockCode': '600000.SH', # 股票名称
'ownSharesAmount': 185395143, # 持股数量
'ownSharesMarketValue': 2417552664.72, # 持股市值
'ownSharesRatio': 0.65, # 持股数量占比
'ownSharesNetBuy': 0.0 # 净买入
}
}
==============分割线====================
北向资金持股中 600000.SH 的详细信息如下：
{1597766400000: # 统计的时间戳
{'stockCode': '600000.SH', # 股票名称
'ownSharesCompany':'ABN AMRO CLEARING HONG KONG LTD', # 机构名称
'ownSharesAmount': 147700, # 持股数量
'ownSharesMarketValue': 1562200.0, # 持股市值
'ownSharesRatio': 0.0, # 持股数量占比
'ownSharesNetBuy': 0.0 # 净买入
}
}
如返回值为空，请先在 数据管理 中下载“港股资金流向数据”
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 3.52 获取无风险利率
ContextInfo.get_risk_free_rate()
语法：ContextInfo.get_risk_free_rate(index)
功能： 获取无风险利率，用十年期国债收益率CGB10Y作无风险利率
参数： index —— 当前主图 上最新一根K 线的索引号。不可省缺，任一整数即可。
返回：浮点数
示例：
#encoding:gbk
def init(ContextInfo):
print(ContextInfo.get_risk_free_rate(0))
"""
运行结果：
十年期国债收益率 CGB10Y 为： 11.98
"""
2
3
4
5
6
7
8
9
# 3.53 获取除权除息日和复权因子
ContextInfo.get_divid_factors()
需要提前下载好 “除权数据”，否则无返回值。
功能：获取除权除息日和复权因子。
参数： stock.market：股票代码.市场代码，如 '600000.SH'
返回：一个字典 dict。其中的key为除权除息的日期，对应的 value 即为复权因子。
示例：
#encoding:gbk
def init(ContextInfo):
Result = ContextInfo.get_divid_factors('600000.SH')
print(Result)
"""
运行结果：
{962812800000: [0.15000000596046448, 0.0, 0.0, 0.0, 0.0, 0, 1.0065019505851756], 1029945600000: [0.20000000298023224, 0.0, 0.5, 0.0, 0.0, 0, 1.5169002473206923], 1056297600000: [0.10000000149011612, 0.0, 0.0, 0.0, 0.0, 0, 1.0083612040133778], 1084982400000: [0.10999999940395355, 0.0, 0.0, 0.0, 0.0, 0, 1.011853448275862], 1115827200000: [0.11999999731779099, 0.0, 0.0, 0.0, 0.0, 0, 1.0172910662824206], 1147363200000: [0.0, 0.30000001192092896, 0.0, 0.0, 0.0, 0, 1.3005988023952095], 1148486400000: [0.12999999523162842, 0.0, 0.0, 0.0, 0.0, 0, 1.0131712259371835], 1184688000000: [0.15000000596046448, 0.0, 0.0, 0.0, 0.0, 0, 1.0041459369817578], 1208966400000: [0.1599999964237213, 0.30000001192092896, 0.0, 0.0, 0.0, 0,]
......
"""
2
3
4
5
6
7
8
9
10
11
# 3.54 获取某只股票ST的历史
ContextInfo.get_his_st_data()
获取历史ST状态
get_st_status()
这2个方法（函数）都需要提前下载“过期合约K线”的数据，不是“过期合约列表”。否则返回值为空。
功能： 获取某只股票ST的历史，历史ST状态。
参数：stockcode——string，股票代码，如'000004.SZ'
返回：一个字典。
示例：
#encoding:gbk
def init(ContextInfo):
print('\n股票 000792.SZ 的历史ST状态\n')
print(get_st_status('000792.SZ'))
print('\n===========分割线=====================\n')
print('\n股票 000004.SZ 的ST历史\n')
print(ContextInfo.get_his_st_data('000004.SZ'))
"""
股票 000792.SZ 的历史ST状态
{'*ST': [['20190430', '20210810']]}
===========分割线=====================
股票 000004.SZ 的ST历史
{'ST': [['19990427', '20010306'],
['20070525', '20090421'],
['20100531', '20110608'],
['20220506', '20230628']
],
'*ST': [['20060421', '20070525'],
['20090421', '20100531']
]
}
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 3.55 设置股票池
ContextInfo.set_universe()
WARNING
此法是早期订阅股票池的函数，不再推荐使用！
功能：设定股票池，声明想要订阅的交易品种
语法： ContextInfo.set_universe(stocklist)
参数： stocklist —— 是一个列表（List），其中包含想要订阅的品种代码。
返回值： 无
示例：
def init(ContextInfo):
stocklist = ['000300.SH','000004.SZ']
ContextInfo.set_universe(stocklist)
2
3
# 3.56 获取已设置的股票池中的品种列表
ContextInfo.get_universe()
功能：获取已设置好的股票池中的股票
语法：ContextInfo.get_universe()
参数：无
返回值： 一个包含股票代码的列表
示例：通常用于核验一下 ContextInfo.set_universe()方法设置的品种。
# coding:gbk
def init(ContextInfo):
stocklist = ['000300.SH','000004.SZ']
ContextInfo.set_universe(stocklist)
print(ContextInfo.get_universe())
""" 运行结果
['000004.SZ', '000300.SH']
与第5行设置的结果是一致的。
"""
2
3
4
5
6
7
8
9
10
11
这个方法（函数）用来检查上一个方法（函数）的运行结果，一个 set，一个是 get，很明显嘛。
# 4） 交易动作的方法（函数）
交易函数下单 和 手动在交易界面中点击下单 ，二者的流程其实是一样的，唯一的区别是：交易函数下单通过解析下单函数接口传过来的参数，形成相应的下单任务；而手动点击下单通过解析界面的输入、选择，形成相应的下单任务。
运行策略模型的流程如下：
一、编写测试代码，并保存。
#coding:gbk
def init(ContextInfo):
pass
def handlebar(ContextInfo):
passorder(23,1101,'6000000248','000001.SZ',5,-1,ContextInfo)
# 在帐户 6000000248 中，买入（23）单支股票（1101），代码为 000001.SZ，按最新价（5），无论价格类型（-1），回传ContextInfo
2
3
4
5
6
7
8
二、运行策略程序
请点击主界面上的“模型交易”按钮，以切换到模型交易界面。在此界面左侧，找到刚刚保存的策略代码。
点击选择之后，会弹出 “新建策略交易” 窗口
在此窗口中，请选择指定你的帐号类型、资金帐号、主图代码、运行周期。最后记得点击 “确定”。
此时，应该可以在中间的策略列表部分看到刚刚选择的策略，其中策略名称就是上一步中选择的策略名称，主图标的、策略周期都是在“新建策略交易”窗口中的设定值，请仔细核对一下。
此时请点击“运行模式”下面的按钮，以切换到“实盘”模式，
在弹出的“提示”窗口中，点击“确定”
然后，请点击 “操作”下面的 三角符号，该策略即开始运行。在下面的“成交”标签页中，如果看到了实际成交的股标，即表示该帐号已经通畅可用。
如果下单失败，可能需要 管理端 开放权限，这需要与券商 以及 讯投软件商 联系。
迅投 QMT 系统提供了一系列的 Python 下单函数接口，本节将详细一一介绍。
一个策略模型在下单交易时，通常是如下的流程： （1）下单之前，首先会查询一下资金账号的信息，如：判定资金是否充足，账号是否在登录状态，统计持仓情况等等。 通常会用到 get_trade_detail_data() 函数，用到 account 参数； （2）第二步通常是设置一个股票列表（蓝子）。也就是想要观察的交易品种。迅投QMT一次大概只能观察300个以内的交易品种，因此没必要那么贪心，一上来就要全市场、全品种，那......通常会用到获取某一板块的股票列标，或”我的自选“中的品种。ContextInfo.get_stock_list_in_sector('我的自选') （3）确定了想要观察的品种之后，在 init() 中即可准备好历史数据，用 ContextInfo.get_market_data_ex() 即可，根据需要获取到 "high","open","low","close" 等K线数据。如果需要用到不同时间周期的数据，也可以一并准备好，并考虑数据对齐。同时，获取到K线数据后，即可计算出需要用的到的指标，如均线、RSI等。 （4）在实时行情中，策略模型中要求的条件达到（满足）了，可用下单函数，如： passorder() 等方法执行交易指令；当然，在下单前最好事先检查一下是否已经下了委托单order ，这里又要用到 get_trade_detail_data() 函数，用到 order 参数； （5） 检查 委托单 的状态，以便判断各种情况等。通常用 get_value_by_order_id()函数。当一个 委托单 的状态变成 “已成”后，那么就会生成一条对应的成交单（deal）；用原 委托号 就可直接查看成交情况。委托单 和 成交单 的 Id号是一样的，都是对象 m_strOrderSysID 的属性值。可根据 Position 持仓信息进一步验证。 （6）根据 委托号 获取 委托信息，根据委托状态，或模型条件的要求，用 cancel 取消委托。
注：在回测模式中，交易函数调用虚拟账号进行交易，在历史 K 线上记录买卖点，用以计算策略净值/回测指标；实盘运行调用策略中设置的资金账号进行交易，产生实际委托；模拟运行模式下交易函数无效。其中，can_cancel_order, cancel_task, cancel和do_order交易函数在回测模式中无实际意义，不建议使用。
- 交易函数
| 序号 | 函数（方法）名称 | 表达意义 | |
|---|---|---|---|
| 1 | passorder | 综合交易下单 | |
| 2 | algo_passorder | 算法交易下单 | |
| 3 | smart_algo_passorder | 智能算法交易 | |
| 5 | get_value_by_order_id | 根据委托Id取委托或成交信息 | |
| 6 | get_last_order_id | 获取最新的委托或成交的委托Id | |
| 7 | can_cancel_order | 查询委托是否可撤销 | |
| 8 | cancel | 取消委托 | |
| 9 | cancel_task | 撤销任务 | |
| 10 | pause_task | 暂停任务 | |
| 11 | resume_task | 继续任务 | |
| 12 | do_order | 实时触发前一根 bar 信号函数 |
- 股票下单函数
| 序号 | 函数（方法）名称 | 表达意义 | |
|---|---|---|---|
| 1 | order_lots | 指定手数交易 | |
| 2 | order_value | 指定价值交易 | |
| 3 | order_percent | 一定比例下单 | |
| 4 | order_target_value | 目标价值下单 | |
| 5 | order_target_percent | 目标比例下单 | |
| 6 | order_shares | 指定股数交易 |
- 期货下单函数
| 序号 | 函数（方法）名称 | 表达意义 | |
|---|---|---|---|
| 1 | buy_open | 买入开仓 | |
| 2 | sell_close_tdayfirst | 卖出平仓，平今优先 | |
| 3 | sell_close_ydayfirst | 卖出平仓，平昨优先 | |
| 4 | sell_open | 卖出开仓 | |
| 5 | buy_close_tdayfirst | 买入平仓，平今优先 | |
| 6 | buy_close_ydayfirst | 买入平仓，平昨优先 |
# 4.01 综合交易下单
passorder()
TIP
这是唯一必须要理解的下单函数。别的方法（函数）如果不理解也罢了，这个必须掌握。
功能： 综合交易下单。注意：对 账号组 的操作相当于对账号组里的每个账号做同样的操作，如
passorder(23,1202, 'testS', '000001.SZ', 5, -1, 50000, ContextInfo)
# 对账号组 testS 里的所有账号都以最新价开仓买入 50000 元市值的 000001.SZ 平安银行
passorder(60,1101,"test",'510050.SH',5,-1,1,ContextInfo)
# 对账号组 test 申购1个单位(900000股)的华夏上证50ETF(只申购不买入成分股)。
2
3
4
5
语法：
passorder(
opType, # 操作动作。如 23 表示买入A股品种，24 表示卖出A股品种
orderType, # 下单方式。如 1101 表示 单股、单账号、普通、股/手方式下单
accountid, # 下单的账号ID
orderCode, # 交易品种代码
prType, # 下单时选择的价格。
price, # 下单价格
volume, # 交易量(手数)
[strategyName, # 策略名称，可省缺
quickTrade, # 即时下单，可省缺
userOrderId, # 用户自设委托 ID， 可省缺
]
ContextInfo # 必须对象参数
)
2
3
4
5
6
7
8
9
10
11
12
13
14
参数：
- optype 操作动作：
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 用于期货六键 | ||
| 0 | 开多 | |
| 1 | 平昨多 | |
| 2 | 平今多 | |
| 3 | 平开空 | |
| 4 | 平昨空 | |
| 5 | 平今空 | |
| 用于期货四键 | ||
| 6 | 平多，优先平今 | |
| 7 | 平多，优先平昨 | |
| 8 | 平空，优先平今 | |
| 9 | 平空，优先平昨 | |
| 用于期货两键 | ||
| 10 | 卖出，如有多仓，优先平仓，优先平今，如有余量，再开空 | |
| 11 | 卖出，如有多仓，优先平仓，优先平昨，如有余量，再开空 | |
| 12 | 买入，如有空仓，优先平仓，优先平今，如有余量，再开多 | |
| 13 | 买入，如有空仓，优先平仓，优先平昨，如有余量，再开多 | |
| 14 | 买入，不优先平仓 | |
| 15 | 卖出，不优先平仓 | |
| 股票买卖 | ||
| 23 | 买入A股，沪港通、深港通 的股票 | |
| 24 | 卖出A股，沪港通、深港通 的股票 | |
| 融资融券 | ||
| 27 | 融资买入 | |
| 28 | 融券卖出 | |
| 29 | 买券还券 | |
| 30 | 直接还券 | |
| 31 | 卖券还款 | |
| 32 | 直接还款 | |
| 33 | 信用帐号股票买入 | |
| 34 | 信用帐号股票卖出 | |
| 组合交易 | ||
| 25 | 组合买入，或沪港通、深港通的组合买入 | |
| 26 | 组合卖出，或沪港通、深港通的组合卖出 | |
| 27 | 融资买入 | |
| 28 | 融券卖出 | |
| 29 | 买券还券 | |
| 31 | 卖券还款 | |
| 33 | 信用账号股票买入 | |
| 34 | 信用账号股票卖出 | |
| 35 | 普通账号一键买卖 | |
| 36 | 信用账号一键买卖 | |
| 40 | 期货组合开多 | |
| 43 | 期货组合开空 | |
| 46 | 期货组合平多,优先平今 | |
| 47 | 期货组合平多,优先平昨 | |
| 48 | 期货组合平空,优先平今 | |
| 49 | 期货组合平空,优先平昨 | |
| 期权交易 | ||
| 50 | 买入开仓 | |
| 51 | 卖出平仓 | |
| 52 | 卖出开仓 | |
| 53 | 买入平仓 | |
| 54 | 备兑开仓 | |
| 55 | 备兑平仓 | |
| 56 | 认购行权 | |
| 57 | 认沽行权 | |
| 58 | 证券锁定 | |
| 59 | 证券解锁 | |
| ETF交易 | ||
| 60 | 申购 | |
| 61 | 赎回 | |
| 专项两融 | ||
| 70 | 专项融资买入 | |
| 71 | 专项融券卖出 | |
| 72 | 专项买券还券 | |
| 73 | 专项直接还券 | |
| 74 | 专项卖券还款 | |
| 75 | 专项直接还款 | |
| 可转债 | ||
| 80 | 普通账户转股 | |
| 81 | 普通账户回售 | |
| 82 | 信用账户转股 | |
| 83 | 信用账户回售 |
- orderType，下单方式
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 1101 | 单股、单账号、普通、股/手方式下单 | |
| 1102 | 单股、单账号、普通、金额（元）方式下单 | （只支持股票，不支持期货） |
| 1113 | 单股、单账号、总资产、比例 [0 ~ 1] 方式下单 | |
| 1123 | 单股、单账号、可用、比例[0 ~ 1]方式下单 | |
| 1201 | 单股、账号组（无权重）、普通、股/手方式下单 | |
| 1202 | 单股、账号组（无权重）、普通、金额（元）方式下单 | （只支持股票，不支持期货） |
| 1213 | 单股、账号组（无权重）、总资产、比例 [0 ~ 1] 方式下单 | |
| 1223 | 单股、账号组（无权重）、可用、比例 [0 ~ 1] 方式下单 | |
| 2101 | 组合、单账号、普通、按组合股票数量（篮子中股票设定的数量）方式下单 > 对应 volume 的单位为篮子的份 | |
| 2102 | 组合、单账号、普通、按组合股票权重（篮子中股票设定的权重）方式下单 > 对应 volume 的单位为元 | |
| 2103 | 组合、单账号、普通、按账号可用方式下单 > （底层篮子股票的分配方式是按可用资金比例后按篮子中股票权重分配，如用户没填权重则按相等权重分配） | 只对股票篮子支持 |
| 2201 | 组合、账号组（无权重）、普通、按组合股票数量方式下单 | |
| 2202 | 组合、账号组（无权重）、普通、按组合股票权重方式下单 | |
| 2203 | 组合、账号组（无权重）、普通、按账号可用方式下单只对股票篮子支持 | |
| 2331 | 组合、套利、合约价值自动套利、按组合股票数量方式下单 | 对应组合套利交易接口特殊设置 |
| 2332 | 组合、套利、按合约价值自动套利、按组合股票权重方式下单 | 对应组合套利交易接口特殊设置 |
| 2333 | 组合、套利、按合约价值自动套利、按账号可用方式下单 | 对应组合套利交易接口特殊设置 |
- accountID
下单的账号ID。（可以写多个帐号 或 账号组的名称 或 套利组的名称（一个篮子一个套利账号，如 accountID = '股票账户名, 期货账号'）
orderCode，交易的品种代码
a、如果是单独一个 股票 或 期货、港股 品种，此处直接填写品种合约代码即可；
b、如果是组合交易，此处填写篮子名称；
c、如果是组合套利，则填一个篮子名和一个期货合约名（如orderCode = '篮子名, 期货合约名'）prType，下单时选择的价格。在套利交易中，这个 prType 只对篮子起作用，期货的采用默认的方式：
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| -1 | 无效 | 实际下单时,取交易面板上的交易函数设定的选价类型为准 |
| 0 | 卖5价 | |
| 1 | 卖4价 | |
| 2 | 卖3价 | |
| 3 | 卖2价 | |
| 4 | 卖1价 | |
| 5 | 最新价 | |
| 6 | 买1价 | |
| 7 | 买2价 | 组合不支持 |
| 8 | 买3价 | 组合不支持 |
| 9 | 买4价 | 组合不支持 |
| 10 | 买5价 | 组合不支持 |
| 11 | 指定价模型价 | 只对单股情况支持,对组合交易不支持 |
| 12 | 涨跌停价 | |
| 13 | 挂单价 | |
| 14 | 对手价 | |
| 27 | 市价即成剩撤 | 仅对股票期权申报有效 |
| 28 | 市价即全成否则撤 | 仅对股票期权申报有效 |
| 29 | 市价剩转限价 | 仅对股票期权申报有效 |
| 42 | 最优五档即时成交剩余撤销申报 | 仅对上交所申报有效 |
| 43 | 最优五档即时成交剩转限价申报 | 仅对上交所申报有效 |
| 44 | 对手方最优价格委托 | 仅对深交所申报有效 |
| 45 | 本方最优价格委托 | 仅对深交所申报有效 |
| 46 | 即时成交剩余撤销委托 | 仅对深交所申报有效 |
| 47 | 最优五档即时成交剩余撤销委托 | 仅对深交所申报有效 |
| 48 | 全额成交或撤销委托 | 仅对深交所申报有效 |
| 49 | 科创板盘后定价 |
price，下单价格。单股下单时， prType 参数为 11，49 时，此参数才有效，其它情况无效。如果 prType 参数不为 11，49 时，此参数也需要填写，可随意写任意数值，如 -1，0，2，100 等；组合下单时，是组合套利时，price 作套利比例有效，其它情况无效。
volume，下单数量（股 / 手 / 元 / %），即交易量。根据参数 orderType 的值，最后一位确定 volume 的单位：
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 单股下单时 | ||
| 1 | 股 / 手 | |
| 2 | 金额（元） | |
| 3 | 比例（%） | |
| 组合下单时 | ||
| 1 | 按组合股票数量（份） | |
| 2 | 按组合股票权重（元） | |
| 3 | 按账号可用（%） |
strategyName，字型串型（String），自定义的策略名，用来区分 order 委托和 deal 成交来自不同的策略。根据策略名，get_trade_detail_data，get_last_order_id 方法（函数）可以获取对应的策略名称，对应的委托或持仓结果。此参数可缺省。此参数 strategyName 只对同账号本地客户端有效，即只对当前客户端下的单进行策略区分，且该策略区分只能当前客户端使用。
quickTrade，整数型（Int）表示是否立即触发下单。 0表示 否 ；1表示 是。passorder 执行时是对最后一根K线完全走完后，在下一根K线的第一个tick时触发下单交易；当此参数 quickTrade 设置为1时，非历史 bar上执行时（ContextInfo.is_last_bar()为True），只要策略模型中调用到就触发下单交易。当此参数 quickTrade 设置为 2 时，不判断 bar （K线）状态，只要在策略模型中调用到就触发下单交易，历史的 bar上也能触发下单，因此，在实盘运用时，可能会触 发重复下单，请谨慎使用。
userOrderId，整数型（String）用户自设委托 ID，可缺省不写。此参数必须必须和前面的 strategyName 和 quickTrade 参数一起使用。对应 order 委托对象和 deal 成交对象中的 m_strRemark 属性，通过 get_trade_detail_data 函数 或 委托主推函数 order_callback 和 成交主推函数 deal_callback 可以获取到 这两个对象信息。
userOrderParam，字符串（String），用户自定义交易参数模板名称，可缺省。如果要使用，则必须必须与前面 的 strategyName 和 quickTrade 参数一起使用。
返回：无
示例：
def handlebar(ContextInfo):
# 单股单账号期货最新价买入 10 手
passorder(0, 1101, 'test', target, 5, -1, 10, 1, ContextInfo)
# 单股单账号期货指定价买入 10 手
passorder(3, 1101, 'test', target, 11, 3000, 10, 1, ContextInfo)
# 单股单账号股票最新价买入 100 股（1 手）
passorder(23, 1101, 'test', '600000.SH', 5, 0, 100, '',1,'',ContextInfo)
# 单股单账号股票指定价买入 100 股（1 手）
passorder(23, 1101, 'test', '600000.SH', 11, 7, 100, '',1,'',ContextInfo)
2
3
4
5
6
7
8
9
10
11
12
13
14
# 4.02 智能算法交易
smart_algo_passorder()
功能： 智能算法交易
语法：
smart_algo_passorder(
opType,
orderType,
accountid,
orderCode,
prType,
modelprice,
volume,
strageName,
quickTrade,
userid,
smartAlgoType,
limitOverRate,
minAmountPerOrder,
[targetPriceLevel,startTime,endTime,limitControl],
ContextInfo
)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
参数：
- opType 表示操作类型
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 股票买卖 | ||
| 23 | A股 或 沪港通、深港通 股票买入 | |
| 24 | A股 或 沪港通、深港通 股票卖出 | |
| 融资融券 | ||
| 27 | 融资买入 | |
| 28 | 融券卖出 | |
| 29 | 买券还券 | |
| 30 | 直接还券 | |
| 31 | 卖券还款 | |
| 32 | 直接还款 | |
| 33 | 信用账号股票买入 | |
| 34 | 信用账号股票卖出 | |
| 35 | 普通账号一键买卖 | |
| 36 | 信用账号一键买卖 |
- orderType 表示下单方式
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 1101 | 单股、单账号、普通、股/手方式下单 | |
| 1102 | 单股、单账号、普通、金额（元）方式下单 | 只支持股票 |
| 1113 | 单股、单账号、总资产、比例 [0 ~ 1] 方式下单 | |
| 1123 | 单股、单账号、可用、比例[0 ~ 1]方式下单 | |
| 1201 | 单股、账号组（无权重）、普通、股/手方式下单 | |
| 1202 | 单股、账号组（无权重）、普通、金额（元）方式下单 | 只支持股票 |
| 1213 | 单股、账号组（无权重）、总资产、比例 [0 ~ 1] 方式下单 | |
| 1223 | 单股、账号组（无权重）、可用、比例 [0 ~ 1] 方式下单 |
accountID 资金账号，下单的账号ID（可多个）或 账号组的名称 或 套利组名称（一个篮子一个套利账号,如accountID=’股票 账户名,期货账号’）
orderCode，下单的合约品种代码。此此的品种代码有两种，一种是 单股 或 单期货、港股,此参数填写合约代码即可，如 ‘600000.SH’；如果是组合交易,则该参数填写篮子名称；如果是组合套利,则填一个篮子名和一个期货合约名（如orderCode=’篮子名,期货合约名’）
prType，下单的价格类型。特殊的情况是对于套利：此参数 prType 只对篮子起作用，期货的采用默认的方式。
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 0 | 卖5价 | |
| 1 | 卖4价 | |
| 2 | 卖3价 | |
| 3 | 卖2价 | |
| 4 | 卖1价 | |
| 5 | 最新价 | |
| 6 | 买1价 | |
| 7 | 买2价 | 组合不支持 |
| 8 | 买3价 | 组合不支持 |
| 9 | 买4价 | 组合不支持 |
| 10 | 买5价 | 组合不支持 |
| 11 | 指定价模型价 | 只对单股情况支持,对组合交易不支持 |
| 12 | 涨跌停价 | |
| 13 | 挂单价 | |
| 14 | 对手价 |
price，下单价格。仅当参数 prType 为 11 时，即模型价时，此参数 price 才有效；其它情况无效。
volume，下单数量，即交易量（股 / 元 / %）。根据参数 orderType 值的最后一位来确定此参数 volume 的单位：在单股下单时：1：表示股；2：金额（元）；3：表示比例（%）
strageName，策略名称，与方法 passorder 不同，此处不可缺省
quickTrade，整数值（Int），表示是否立马触发下单，0 表示 否，1表示 是
userid，投资备注。与方法 passorder 不同，此处不可缺省
smartAlgoType，字符串型（String），表示 智能算法类型
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| VWAP | VWAP | |
| TWAP | TWAP | |
| VP | 跟量 | |
| PINLINE | 跟价 | |
| DMA | 快捷 | |
| FLOAT | 盘口 | |
| SWITCH | 换仓 | |
| ICEBERG | 冰山 | |
| MOC | 尾盘 |
limitOverRate，整数型（Int）量比，数据范围 0 -100，如果输入其他无效值，则limitOverRate为0。网格算法无此项。
minAmountPerOrder，整数型（Int），智能算法最小委托金额，数据范围 0 -- 100000，默认为0。
targetPriceLevel，智能算法目标价格
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 1 | 己方盘口1 | |
| 2 | 己方盘口2 | |
| 3 | 己方盘口3 | |
| 4 | 己方盘口4 | |
| 5 | 己方盘口5 | |
| 6 | 最新价 | |
| 7 | 对方盘口 |
注： 一、输入无效值则targetPriceLevel为1； 二、本项只针对冰山算法,其他算法可缺省。
startTime/endTime，智能算法 开始和结束时间， 格式"HH:MM:SS"，如"10:30:00"。如果缺省值，则默认为"09:30:00"，"15:30:00"
limitControl，涨跌停控制 1：涨停不卖跌停不卖 0：无； 默认值为1
返回： 无
示例：
def handlebar(ContextInfo):
# 账户600000105 最新价 开仓 买入50000 000001.SZ平安银行,使用TWAP智能算法,量比20%,最小买卖金额0
smart_algo_passorder(
23,
1101,
'600000105',
'000001.SZ',
5,
-1,
50000,
"strageName",
0,
"remark",
"TWAP",
20,
0,
ContextInfo
)
# 账户600000105最新价快速交易开仓买入50000股的000001.SZ平安银行,使用TWAP智能算法,量比20%,最小买卖金额0 且有效时长为 09:30-14:00
smart_algo_passorder(
23,
1101,
'600000105',
'000001.SZ',
5,
-1,
50000,
"strageName",
1,
"remark",
"TWAP",
20,
0,
0,
'09:30:00',
'14:00:00',
ContextInfo
)
# 账户600000105最新价快速交易开仓买入50000股的000001.SZ平安银行,使用TWAP智能算法,量比20%,最小买卖金额0且有效时长为09:30-14:00,不对智能算法涨停做限制
smart_algo_passorder(
23,
1101,
'600000105',
'000001.SZ',
5,
-1,
50000,
"strageName",
1,
"remark",
"TWAP",
20,
0,
0,
'09:30:00',
'14:00:00',
0,
ContextInfo
)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# 4.03 根据委托号获取委托或成交信息
get_value_by_order_id()
功能： 根据当天的 委托号 获取 委托单 或 成交单 的信息。
语法：
get_value_by_order_id(
orderId,
accountID,
strAccountType,
strDatatype
)
2
3
4
5
6
参数：
orderId —— 字符串（String）委托号。
accountID —— 字符串（String）资金账号。
strAccountType —— 字符串型（String）账号类型。
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 'FUTURE' | 期货 | |
| 'STOCK' | 股票 | |
| 'CREDIT' | 信用 | |
| 'HUGANGTONG' | 沪港通 | |
| 'SHENGANGTONG' | 深港通 | |
| 'STOCK_OPTION' | 期权 |
strDatatype —— 字符串型（String）'ORDER' 表示 委托单 ，'DEAL'表示已成交的单子
返回：一个对象（PythonObj）
示例：
#coding:gbk
def init(ContextInfo):
ContextInfo.accid = '6000000248'
def handlebar(ContextInfo):
orderid = get_last_order_id(ContextInfo.accid, 'stock', 'order')
print(orderid)
obj = get_value_by_order_id(orderid,ContextInfo.accid, 'stock', 'order')
print(obj.m_strInstrumentID)
2
3
4
5
6
7
8
9
10
11
12
# 4.04 获取最新的委托或成交的委托号
get_last_order_id()
功能： 获取最新的委托或成交的委托号。
语法：
get_last_order_id(
accountID,
strAccountType,
strDatatype,
strategyName
)
2
3
4
5
6
参数： accountID —— 字符型（String）资金账号。 strAccountType —— 字符型（String）账号类型。
strDatatype —— 字符型（String）'ORDER' 表示 委托单 ，'DEAL'表示已成交的单子
strategyName —— 字符型（String）表达策略名称，对应 passorder 下单函数中的参数strategyName 的值。
返回： 字符型（String）表示委托号，如果没找到返回 '-1'
示例代码见上例
# 4.05 查询委托是否可撤销
can_cancel_order()
功能： 查询指定的委托单是否可撤销。 语法：
can_cancel_order(
orderId,
accountID,
strAccountType
)
2
3
4
5
参数：
orderId —— 字符串（String），委托订单号。
accountID —— 字符串（String）资金账号。
strAccountType —— 字符串（String）账号类型
返回： 布尔值（Bool），True：表示撤销，False：表示不可撤销
示例：
#coding:gbk
def init(ContextInfo):
ContextInfo.accid = '6000000248'
def handlebar(ContextInfo):
orderid = get_last_order_id(ContextInfo.accid,'stock','order')
print("获取到的委托单号为：",orderid)
can_cancel = can_cancel_order(orderid,ContextInfo.accid,'stock')
print("委托单 ",orderid,' 是否可撤消:', can_cance
2
3
4
5
6
7
8
9
10
11
# 4.06 取消委托
cancel()
功能： 取消指定的委托 语法：
cancel(
orderId,
accountId,
accountType,
ContextInfo
)
2
3
4
5
6
参数：
orderId —— 字符串型（String）想要取消的委托订单号。
accountID —— 字符串型（String）资金账号。
strAccountType —— 字符串型（String）账号类型
ContextInfo —— 对象（pythonobj） 默认参数，可缺省
返回： 布尔值（Bool）是否发出了取消委托信号， True 表示 是 False表示 否
示例：
#coding:gbk
def init(ContextInfo):
ContextInfo.accid = '6000000248'
def handlebar(ContextInfo):
orderid = get_last_order_id(ContextInfo.accid, 'stock', 'order')
print(cancel(orderid, ContextInfo.accid, 'stock', ContextInfo))
2
3
4
5
6
7
8
# 4.07 取消任务
cancel_task()
功能： 撤销任务。
语法：
cancel_task(
taskId,
accountId,
accountType,
ContextInfo
)
2
3
4
5
6
参数：
taskId —— 字符串型（String）任务编号。如果此参数为空，则表示撤销该资金账号上所有可撤销的任务。
accountID —— 字符串型（String）资金账号。
strAccountType —— 字符串型（String）账号类型
ContextInfo —— 对象（pythonobj） 默认参数，可缺省
返回： 布尔值（Bool）是否发出了取消任务信号， True 表示 是 False表示 否
示例：
#coding:gbk
def init(ContextInfo):
ContextInfo.accid = '6000000248'
def handlebar(ContextInfo):
objlist = get_trade_detail_data(ContextInfo.accid,'stock','task')
for obj in obj_list:
cancel_task(obj.m_nTaskId,ContextInfo.accid,'stock',ContextInfo)
2
3
4
5
6
7
8
9
10
# 4.08 暂停任务
pause_task()
功能： 暂停智能算法任务。
语法：
pause_task(
taskId,
accountId,
accountType,
ContextInfo
)
2
3
4
5
6
参数：
taskId —— 字符串型（String）任务编号。如果此参数为空，则表示暂停该资金账号上所有可暂停的任务。
accountID —— 字符串型（String）资金账号。
strAccountType —— 字符串型（String）账号类型
ContextInfo —— 对象（pythonobj） 默认参数，可缺省
返回： 布尔值（Bool）是否发出了暂停委托信号， True 表示 是 False表示 否
示例：
#coding:gbk
def init(ContextInfo):
ContextInfo.accid = '6000000248'
def handlebar(ContextInfo):
objlist = get_trade_detail_data(ContextInfo.accid,'stock','task')
for obj in obj_list:
pause_task(obj.m_nTaskId,ContextInfo.accid,'stock',ContextInfo)
2
3
4
5
6
7
8
9
10
# 4.09 继续任务
resume_task()
功能： 继续智能算法任务。
resume_task(
taskId,
accountId,
accountType,
ContextInfo
)
2
3
4
5
6
参数：
taskId —— 字符串型（String）任务编号。如果此参数为空，则表示暂停该资金账号上所有可暂停的任务。
accountID —— 字符串型（String）资金账号。
strAccountType —— 字符串型（String）账号类型
ContextInfo —— 对象（pythonobj） 默认参数，可缺省
返回： 布尔值（Bool）是否发出了继续任务的指令， True 表示 是， False表示 否
示例：
#coding:gbk
def init(ContextInfo):
ContextInfo.accid = '6000000248'
def handlebar(ContextInfo):
objlist = get_trade_detail_data(ContextInfo.accid,'stock','task')
for obj in obj_list:
resume_task(obj.m_nTaskId,ContextInfo.accid,'stock',ContextInfo)
2
3
4
5
6
7
8
9
10
# 4.10 实时触发前一根K线信号
do_order()
功能： 实时触发前一根 K 线信号函数。 系统实盘中交易下单函数一般是把上一个周期产生的信号在最新的周期的第一个 tick 下单出去，而日 K 线第一个 tick 是在 9:25 分集合竞价结束时产生，如果策略模型在 9:25 分之后跑又想把前一天的下单信号发出去，就可用 do_order 函数配合实现。 特别需要注意的是，有调用 do_order 函数的策略模型跑在 9:25 分之前或别的日内周期下时，原有下单 函数和 do_order 函数都有下单信号，有可能导致重复下单。
参数： 无
返回： 无 示例：
#coding:gbk
# 实现跑日 K 线及以上周期下,在固定时间点把前一周期的交易信号发送出去
def init(ContextInfo):
pass
def handlebar(ContextInfo):
order_lots('000002.SZ', 1, ContextInfo, '600000248')
ticktimetag = ContextInfo.get_tick_timetag()
int_time = int(timetag_to_datetime(ticktimetag, '%H%M%S'))
if 100500 <= int_time < 100505:
do_order(ContextInfo)
2
3
4
5
6
7
8
9
10
11
12
13
# 4.11 指定手数交易
order_lots()
功能： 按指定手数进行， 买/卖单交易。
语法：
order_lots(
stockcode,
lots[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 股票品种代码，字符型（String），如 '000002.SZ'
lots —— 手数，整数型（Int）
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 'LATEST' | 最新价 | 默认值 |
| 'FIX' | 指定 | |
| 'HANG' | 挂单 | |
| 'COMPETE' | 对手 | |
| 'MARKET' | 市价 | |
| 'SALE5', 'SALE4', 'SALE3', 'SALE2', 'SALE1' | 卖5-1价 | |
| 'BUY1', 'BUY2', 'BUY3', 'BUY4', 'BUY5' | 买1-5价 |
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
示例：
#coding:gbk
def init(ContextInfo):
pass
def handlebar(ContextInfo):
# 按最新价下 1 手买入
order_lots('000002.SZ', 1, ContextInfo, '600000248')
# 用对手价下 1 手卖出
order_lots('000002.SZ', -1, 'COMPETE', ContextInfo, '600000248')
# 用指定价 37.5 下 2 手卖出
order_lots('000002.SZ', -2, 'fix', 37.5, ContextInfo, '600000248')
2
3
4
5
6
7
8
9
10
11
12
# 4.12 指定价值交易
order_value()
功能： 按指定金额进行， 买/卖单交易。
语法：
order_value(
stockcode,
value[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 股票品种代码，字符型（String），如 '000002.SZ'
value —— 金额，双精度浮点型（Double）
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
示例：
#coding:gbk
def init(ContextInfo):
pass
def handlebar(ContextInfo):
# 按最新价下 10000 元买入
order_value('000002.SZ', 10000, ContextInfo, '600000248')
# 用对手价下 10000 元卖出
order_value('000002.SZ', -10000, 'COMPETE', ContextInfo, '600000248')
# 用指定价 37.5 下 20000 元卖出
order_value('000002.SZ', -20000, 'fix', 37.5, ContextInfo,'60000248')
2
3
4
5
6
7
8
9
10
11
12
# 4.13 指定比例交易
order_percent()
功能： 指定一个比例值，发送一个等于目前投资组合价值（市场价值和目前现金的总和）一定百分比的买/ 卖单，正数代表买，负数代表卖。股票的股数总是会被调整成对应的一手的股票数的倍数（1 手是 100股）。百分比是一个小数，并且小于或等于1（小于等于100%），0.5 表示的是 50%。需要注意，如果资金不足，将不会发送交易指令。
语法：
order_percent(
stockcode,
percent,
style,
price,
ContextInfo,
accId
)
2
3
4
5
6
7
8
参数：
stockcode —— 股票品种代码，字符型（String），如 '000002.SZ'
percent —— 百分比，双精度浮点型（Double）。1 表示 100%，因此通常设置的数值小于1，如 0.5 表示 50%
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
示例：
#coding:gbk
def init(ContextInfo):
pass
def handlebar(ContextInfo):
# 按最新价下 5.1% 价值买入
order_percent('000002.SZ', 0.051, ContextInfo, '600000248')
# 用对手价下 5.1% 价值卖出
order_percent('000002.SZ', -0.051, 'COMPETE', ContextInfo, '600000248')
# 用指定价 37.5 下 10.2% 价值卖出
order_percent('000002.SZ', -0.102, 'fix', 37.5, ContextInfo, '600000248')
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 4.14 指定目标价值交易
order_target_value()
功能： 指定目标品种价值，去执行交易 买入/卖出操作，并且自动调整该证券的仓位到一个目标价值。如果还没有任何该证券的仓位，那么会买入全部目标价值的证券；如果已经有了该证券的仓位，则会买入 / 卖出调整该证券的现在仓位和目标仓位的价值差值的数目的证券。需要注意，如果资金不足，将不会发送交易订单。
语法：
order_target_value(
stockcode,
tar_value[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 股票品种代码，字符型（String），如 '000002.SZ'
tar_value —— 目标价值金额（元），非负数，双精度浮点型（Double）。
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
示例：
#coding:gbk
def init(ContextInfo):
pass
def handlebar(ContextInfo):
# 按最新价下调仓到 10000 元持仓
order_target_value('000002.SZ', 10000, ContextInfo, '600000248')
# 用对手价调仓到 10000 元持仓
order_target_value('000002.SZ', 10000, 'COMPETE', ContextInfo,'600000248')
# 用指定价 37.5 下调仓到 20000 元持仓
order_target_value('000002.SZ', 20000, 'fix', 37.5, ContextInfo,'600000248')
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 4.15 指定目标比例交易
order_target_percent()
功能： 指定目标比例交易，买入 / 卖出证券以自动调整该证券的仓位到占有一个指定的投资组合的目标百分比。投资组合价值等于所有已有仓位的价值和剩余现金的总和。买 / 卖单会被下舍入一手股数（A股是 100 的倍数）的倍数。目标百分比应该是一个小数，并且最大值应该小于等于1，比如 0.5 表示50%，需要注意，如果资金不足，该API将不会创建发送订单。
语法：
order_target_percent(
stockcode,
tar_percent[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 股票品种代码，字符型（String），如 '000002.SZ'
tar_percent —— 目标百分比 [0 ~ 1]，双精度浮点型（Double）。
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
示例：
#coding:gbk
def init(ContextInfo):
pass
def handlebar(ContextInfo):
# 按最新价下买入调仓到 5.1% 持仓
order_target_percent('000002.SZ', 0.051, ContextInfo, '600000248')
# 用对手价调仓到 5.1% 持仓
order_target_percent('000002.SZ', 0.051, 'COMPETE', ContextInfo,'600000248')
# 用指定价 37.5 调仓到 10.2% 持仓
order_target_percent('000002.SZ', 0.102, 'fix', 37.5, ContextInfo,'600000248')
2
3
4
5
6
7
8
9
10
11
12
13
14
# 4.16 指定股数交易
order_shares()
功能：指定股票数量，下单交易买 / 卖单，这是最常见的下单方式之一。参数 style 可用于设定交易时的选价类型，默认为最新价 'LATEST'
语法：
order_shares(
stockcode,
shares[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 股票品种代码，字符型（String），如 '000002.SZ'
shares —— 想要交易的股票数量，整数型（Int）。为 100 的整数倍
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
示例：
def handlebar(ContextInfo):
# 按最新价下 100 股买入
order_shares('000002.SZ', 100, ContextInfo, '600000248')
# 用对手价下 100 股卖出
order_shares('000002.SZ', -100, 'COMPETE', ContextInfo, '600000248')
# 用指定价 37.5 下 200 股卖出
order_shares('000002.SZ', -200, 'fix', 37.5, ContextInfo, '600000248')
2
3
4
5
6
7
8
9
10
# 4.17 期货买入开仓
buy_open()
功能： 期货买入开仓
语法：
buy_open(
stockcode,
amount[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 品种代码，字符型（String），如 'IF1805.IF'
amount —— 想要交易的手数，整数型（Int）。
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
| 参数值 | 表达意义 | 备注 |
|---|---|---|
| 'LATEST' | 最新价 | 默认值 |
| 'FIX' | 指定 | |
| 'HANG' | 挂单 | |
| 'COMPETE' | 对手 | |
| 'MARKET' | 市价 | |
| 'SALE1' | 卖1价 | |
| 'BUY1' | 买1价 |
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
def handlebar(ContextInfo):
# 按最新价 1 手买入开仓
buy_open('IF1805.IF', 1, ContextInfo, '110476')
# 用对手价 1 手买入开仓
buy_open('IF1805.IF', 1, 'COMPETE', ContextInfo, '110476')
# 用指定价 3750 元 2 手买入开仓
buy_open('IF1805.IF', 2, 'fix', 3750, ContextInfo, '110476')
2
3
4
5
6
7
8
9
# 4.18 期货买入平仓（平今优先）
buy_close_tdayfirst()
功能： 期货买入平仓，平今优先
语法：
buy_close_tdayfirst(
stockcode,
amount[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 品种代码，字符型（String），如 'IF1805.IF'
amount —— 想要交易的手数，整数型（Int）。
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
def handlebar(ContextInfo):
# 按最新价 1 手买入开仓，平今优先
buy_close_tdayfirst('IF1805.IF', 1, ContextInfo, '110476')
# 用对手价 1 手买入开仓，平今优先
buy_close_tdayfirst('IF1805.IF', 1, 'COMPETE', ContextInfo, '110476')
# 用指定价 3750 元 2 手买入开仓，平今优先
buy_close_tdayfirst('IF1805.IF', 2, 'fix', 3750, ContextInfo, '110476')
2
3
4
5
6
7
8
9
# 4.19 期货买入平仓（平昨优先）
buy_close_ydayfirst()
功能： 期货买入开仓，平昨优先
语法：
buy_close_ydayfirst(
stockcode,
amount[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 品种代码，字符型（String），如 'IF1805.IF'
amount —— 想要交易的手数，整数型（Int）。
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
def handlebar(ContextInfo):
# 按最新价 1 手买入开仓，平昨优先
buy_close_ydayfirst('IF1805.IF', 1, ContextInfo, '110476')
# 用对手价 1 手买入开仓，平昨优先
buy_close_ydayfirst('IF1805.IF', 1, 'COMPETE', ContextInfo, '110476')
# 用指定价 3750 元 2 手买入开仓，平昨优先
buy_close_ydayfirst('IF1805.IF', 2, 'fix', 3750, ContextInfo, '110476')
2
3
4
5
6
7
8
9
# 4.20 期货卖出开仓
sell_open()
功能： 期货卖出开仓
语法：
sell_open(
stockcode,
amount[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 品种代码，字符型（String），如 'IF1805.IF'
amount —— 想要交易的手数，整数型（Int）。
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
def handlebar(ContextInfo):
# 按最新价 1 手卖出开仓
buy_open('IF1805.IF', 1, ContextInfo, '110476')
# 用对手价 1 手卖出开仓
buy_open('IF1805.IF', 1, 'COMPETE', ContextInfo, '110476')
# 用指定价 3750 元 2 手卖出开仓
buy_open('IF1805.IF', 2, 'fix', 3750, ContextInfo, '110476')
2
3
4
5
6
7
8
9
# 4.21 期货卖出平仓（平今优先）
sell_close_tdayfirst()
功能： 期货卖出平仓，平今优先
语法：
sell_close_tdayfirst(
stockcode,
amount[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 品种代码，字符型（String），如 'IF1805.IF'
amount —— 想要交易的手数，整数型（Int）。
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
def handlebar(ContextInfo):
# 按最新价 1 手买入开仓，平今优先
sell_close_tdayfirst('IF1805.IF', 1, ContextInfo, '110476')
# 用对手价 1 手买入开仓，平今优先
sell_close_tdayfirst('IF1805.IF', 1, 'COMPETE', ContextInfo, '110476')
# 用指定价 3750 元 2 手买入开仓，平今优先
sell_close_tdayfirst('IF1805.IF', 2, 'fix', 3750, ContextInfo, '110476')
2
3
4
5
6
7
8
9
# 4.22 期货卖出平仓（平昨优先）
sell_close_ydayfirst()
功能： 期货卖出平仓，平昨优先
语法：
sell_close_tdayfirst(
stockcode,
amount[,
style,
price],
ContextInfo[,
accId]
)
2
3
4
5
6
7
8
参数：
stockcode —— 品种代码，字符型（String），如 'IF1805.IF'
amount —— 想要交易的手数，整数型（Int）。
style —— 下单选价类型，字符串型（String）默认为最新价 'LATEST'
price —— 价格，双精度浮点型（Double）
ContextInfo —— Python 对象（PythonObj），这里必须是 ContextInfo
accId —— 账号，字符型（String）
返回： 无
def handlebar(ContextInfo):
# 按最新价 1 手买入开仓，平昨优先
sell_close_ydayfirst('IF1805.IF', 1, ContextInfo, '110476')
# 用对手价 1 手买入开仓，平昨优先
sell_close_ydayfirst('IF1805.IF', 1, 'COMPETE', ContextInfo, '110476')
# 用指定价 3750 元 2 手买入开仓，平昨优先
sell_close_ydayfirst('IF1805.IF', 2, 'fix', 3750, ContextInfo, '110476')
2
3
4
5
6
7
8
9
# 4.23 [已弃用]获取两融负债合约明细
（5.24） get_debt_contract()
已弃用
# 4.24 获取两融担保标的明细
get_assure_contract()
功能： 获取信用账户担保合约明细
语法： get_debt_contract(accId)
参数：
accId —— 信用账户
def handlebar(ContextInfo):
obj_list = get_assure_contract('6000000248')
for obj in obj_list:
# 输出担保合约名
print(obj.m_strInstrumentName)
2
3
4
5
6
7
# 4.25 获取可融券明细
get_enable_short_contract()
功能： 获取信用账户当前可融券的明细
语法： get_enable_short_contract(accId)
参数：
accId —— 信用账户
def handlebar(ContextInfo):
obj_list = get_enable_short_contract('6000000248')
for obj in obj_list:
# 输出可融券合约名
print(obj.m_strInstrumentName)
2
3
4
5
6
# 4.26 算法交易下单
algo_passorder()
功能： 算法交易下单，此时使用交易面板-程序交易-函数交易-函数交易参数中设置的下单类型（普通交 易,算法交易,随机量交易）。 如果函数交易参数使用未修改的默认值，此函数和passorder函数一致。 设置了函数交易参数后，将会使用函数交易参数的超价等拆单参数,如果入参的prType = -1，同 时将会使用函数交易参数的报价方式。
语法：
algo_passorder(
opType,
orderType,
accountid,
orderCode,
prType,
modelprice,
volume[,
strategyName,
quickTrade,
userOrderId,
userOrderParam],
ContextInfo
)
2
3
4
5
6
7
8
9
10
11
12
13
14
示例： 可参考 4.02 智能算法交易
# 4.27 获取股票篮子
get_basket()
功能： 获取股票篮子
参数：
basketName —— 字符串（String）股票篮子名称
语法： get_basket(basketName)
示例：
print( get_basket('basket1') )
# 4.28 设置股票篮子
set_basket()
功能： 设置passorder的股票篮子,仅用于passorder进行篮子交易,设置成功后,用get_basket可以取出后 即可进行passorder组合交易下单
语法： set_basket(basketDict)
参数：
basketDict —— 字典类型（Dict）表示一个股票篮子，格式如下：
{'name':股票篮子名称,
'stocks':[
{'stock':股票名称,
'weight':权重,
'quantity':数量,
'optType':交易类型
}
]
}
2
3
4
5
6
7
8
9
10
# 4.29 获取未了结负债合约明细
get_unclosed_compacts()
功能： 获取未了结负债合约明细
语法： get_unclosed_compacts(accountID,accountType)
参数：
accountID —— 字符串型（String）表示资金账号
accountType —— 字符串型（String）账号类型
返回： 一个列表（List）[ CStkUnclosedCompacts, ... ]
其中 CStkUnclosedCompacts 属性如下：
| 属性名称 | 数据类型 | 表示意义 | 备注 |
|---|---|---|---|
| m_strAccountID | 字符串型（String） | 账号ID | |
| m_nBrokerType | 整数型（Int） | 账号类型 | 1-期货账号, 2-股票账号, 3-信用账号, 5-期货期权账号, 6-股票期权账号, 7-沪港通账号, 11-深港通账号) |
| m_strExchangeID | 字符串型（String） | 市场代码 | |
| m_strInstrumentID | 字符串型（String） | 证券代码 | |
| m_eCompactType | 整数型（Int） | 合约类型 | 32-不限制,48-融资,49-融券 |
| m_eCashgroupProp | 整数型（Int） | 头寸来源 | 32-不限制,48-普通头寸,49-专项头寸 |
| m_nOpenDate | 整数型（Int） | 开仓日期 | 如'20201231' |
| m_nBusinessVol | 整数型（Int） | 合约证券数量 | |
| m_nRealCompactVol | 整数型（Int） | 未还合约数量 | |
| m_nRetEndDate | 整数型（Int） | 到期日 | 如'20201231' |
| m_dBusinessBalance | 浮点型(Float) | 合约金额 | |
| m_dBusinessFare | 浮点型(Float) | 合约息费 | |
| m_dRealCompactBalance | 浮点型(Float) | 未还合约金额 | |
| m_dRealCompactFare | 浮点型(Float) | 未还合约息费 | |
| m_dRepaidFare | 浮点型(Float) | 已还息费 | |
| m_dRepaidBalance | 浮点型(Float) | 已还金额 | |
| m_strCompactId | 整数型（Int） | 合约编号 | |
| m_strEntrustNo | 字符串型（String） | 委托编号 | |
| m_nRepayPriority | 整数型（Int） | 偿还优先级 | |
| m_strPositionStr | 字符串型（String） | 定位串 | |
| m_eCompactRenewalStatus | 整数型（Int） | 合约展期状态 | 48-可申请, 49-已申请, 50-审批通过, 51-审批不通过, 52-不可申请, 53-已执行, 54-已取消 |
| m_nDeferTimes | 整数型（Int） | 展期次数 |
示例：
get_unclosed_compacts('6000000248', 'CREDIT')
# 4.30 获取已了结负债合约明细
get_closed_compacts()
功能： 获取已了结负债合约明细
语法： get_closed_compacts(accountID,accountType)
参数： accountID —— 字符串型（String）资金账号 accountType —— 字符串型（String），账号类型
返回：
一个列表（List）[ CStkUnclosedCompacts, ... ]
其中 CStkUnclosedCompacts 属性如前 4.29 获取未了结负债合约明细 中的描述一致。
# 4.31 获取沪深港通汇率数据
get_hkt_exchange_rate()
功能： 获取沪深港通汇率数据
语法： get_hkt_exchange_rate(accountID,accountType)
参数： accountID —— 字符串型（String）资金账号 accountType —— 字符串型（String），账号类型。必须填HUGANGTONG或者SHENGANGTONG
返回：一个字典（Dict）字段功能： bidReferenceRate:买入参考汇率 askReferenceRate:卖出参考汇率 dayBuyRiseRate:日间买入参考汇率浮动比例
# 4.32 取可融券明细
get_enable_short_contract()
功能： 取可融券明细
语法： get_enable_short_contract(accountID)
参数：accountID —— 字符串型（String）资金账号
返回： 列表（List）,其中是 PythonObj ，通过 dir(pythonobj) 可返回对象的属性列表
示例：
def handlebar(ContextInfo):
obj_list = get_enable_short_contract('6000000248')
for obj in obj_list:
print( obj.m_strInstrumentName)
2
3
4
# 4.33 取期权标的持仓
get_option_subject_position()
功能： 取期权标的持仓
语法：get_option_subject_position(accountID)
accountID —— 字符串型（String）资金账号
返回： 列表（List）,其中是 PythonObj ，通过 dir(pythonobj) 可返回对象的属性列表
示例：
def handlebar(ContextInfo)
data=get_option_subject_position('880399990383')
print(len(data));
for obj in data:
print(obj.m_strInstrumentName,obj.m_lockVol,obj.m_coveredVol);
2
3
4
5
# 4.34 取期权组合持仓
get_comb_option()
功能： 取期权组合持仓
语法： get_comb_option(accountID)
参数： accountID —— 字符串型（String）资金账号
返回： 列表（List）,其中是 PythonObj ，通过 dir(pythonobj) 可返回对象的属性列表
obj_list=get_comb_option('880399990383')
print(len(obj_list));
forobjinobj_list:
print(obj.m_strCombCodeName,obj.m_strCombID,obj.m_nVolume,obj.m_nFrozenVolume)
2
3
4
# 4.35 构建期权组合持仓
make_option_combination()
功能： 构建期权组合持仓
语法：
make_option_combination(
combType,
orderCodeDict,
modelVolume,
accountID,
strategyName,
userOrderId,
ContextInfo
)
2
3
4
5
6
7
8
9
参数：
combType —— 组合策略类型
50:认购牛市价差策略
51:认沽熊市价差策略
52:认沽牛市价差策略
53:认购熊市价差策略
54:跨式空头
55:宽跨式空头
56:保证金开仓转备兑开仓
57:备兑开仓转保证金开仓
orderCodeDict —— 期权组合，{option:holdType}。
option —— 期权代码,格式如 10000001.SHO，
holdType —— 48:权利 ， 49:义务 ， 50:备兑
modelVolume —— 下单量
strategyName —— 策略名
userOrderId —— 投资备注
示例：
ContextInfo.accid='880399990383'
make_option_combination(50,
{'10003006.SHO':48,'10003259.SHO':49},1,ContextInfo.accid,'stragegyName','str
Remark',ContextInfo);
#第一个参数50为认购牛市价差策略
#第二个参数10003006.SHO(50ETF购6月3400),48(权利仓)10003259.SHO(50ETF购6月
4400)49(义务仓)
#50ETF购6月3400/50ETF购6月4400g构建认购牛市价差策略
2
3
4
5
6
7
8
# 4.36 解除期权组合持仓
release_option_combination()
功能： 解除期权组合持仓
语法：
release_option_combination(
combID,
accountID,
strategyName,
userOrderId,
contextInfo
)
2
3
4
5
6
7
参数：
combID —— 持仓中期权组合编码
accountID —— 字符串型（String）表示账号
strategyName —— 字符串型（String）表示 策略名
userOrderId —— 字符串型（String）投资备注
示例：
ContextInfo.accid='880399990383'
release_option_combination('V950034404',ContextInfo.accid,'strategyName','use
rOrderId',ContextInfo)
# 解除组合号码为V950034404的组合期权(同组合策略持仓中的组合号码)
2
3
4
# 5） 成交回报实时主推函数
所谓主推函数，意即无需开发人员在代码中去调用的函数。而是当发生某一事件时，会自动运行的函数。如：成交了一个订单，则QMT会自动调用一次 deal_callback() 函数，执行其中的指令。
WARNING
注：成交回报实时主推函数仅在实盘运行模式下生效。
意即，需要在 “策略交易”界面中，运行一个策略。并且该策略的代码中包含以下主推函数。当对应的事件发生时，才会主动运行一次这个函数，执行其中的指令。在策略编辑器中，是看不到执行效果的。
# 5.1 资金账号变化
account_callback()
功能： 当资金账号状态有变化时，自动运行一次这个函数
语法： account_callback(ContextInfo, accountInfo)
参数：
- ContextInfo —— 特定对象
- accountInfo —— 资金账号对象，可对应查看5.3. 附录3 交易函数内含属性说明
返回： 无
示例：
# coding:gbk
def init(ContextInfo):
# 设置对应的资金账号
ContextInfo.set_account('410038216969') # 此处请替换成你自己的帐号
def account_callback(ContextInfo, accountInfo):
print('===========accountInfo 对象的属性============================================')
print("帐号ID", accountInfo.m_strAccountID)
print("账号类型", accountInfo.m_nBrokerType) # 1- 期货,2-股票,3-信用,5-期货期权,6-股票期权,7-沪港通,11-深港通
print("保证金比率", accountInfo.m_dMaxMarginRate) # 股票的保证金率等于 1 因此股票帐户没有此属性
print("冻结保证金", accountInfo.m_dFrozenMargin) # 股票帐户没有此属性
print("冻结金额", accountInfo.m_dFrozenCash) # 内外源冻结保证金和手续费四个的和 股票帐户没有此属性
print("冻结手续费", accountInfo.m_dFrozenCommission)
print("风险度", accountInfo.m_dRisk) # 冻结资金 / 可用资金，股票帐户没有此属性
print("单位净值", accountInfo.m_dNav)
print("期初权益", accountInfo.m_dPreBalance) # 期初权益，也叫静态权益 股票帐户没有此属性
print("总资产", accountInfo.m_dBalance) # 动态权益，即市值
print("可用金额", accountInfo.m_dAvailable)
print("手续费", accountInfo.m_dCommission) # 已经用掉的手续费
print("持仓盈亏", accountInfo.m_dPositionProfit)
print("平仓盈亏", accountInfo.m_dCloseProfit) # 股票帐户没有此属性
print("出入金净值", accountInfo.m_dCashIn)
print("当前使用的保证金", accountInfo.m_dCurrMargin) # 股票帐户没有此属性
print("初始权益", accountInfo.m_dInitBalance)
print("账号状态", accountInfo.m_strStatus)
print("期初平仓盈亏", accountInfo.m_dInitCloseMoney)
print("总市值", accountInfo.m_dInstrumentValue) # 合约价值
print("入金", accountInfo.m_dDeposit)
print("出金", accountInfo.m_dWithdraw)
print("上次信用额度", accountInfo.m_dPreCredit) # 股票帐户没有此属性
print("上次质押", accountInfo.m_dPreMortgage) # 股票帐户没有此属性
print("质押", accountInfo.m_dMortgage) # 股票帐户没有此属性
print("信用额度", accountInfo.m_dCredit) # 股票帐户没有此属性
print("证券初始资金", accountInfo.m_dAssetBalance) # 股票帐户没有此属性
print("起始日期", accountInfo.m_strOpenDate) # 股票帐户没有此属性
print("可取金额", accountInfo.m_dFetchBalance)
print("交易日", accountInfo.m_strTradingDate)
print("股票总市值", accountInfo.m_dStockValue) # 期货帐户没有此属性
print("债券总市值", accountInfo.m_dLoanValue) # 期货帐户没有此属性
print("基金总市值", accountInfo.m_dFundValue) # 包括ETF和封闭式基金， 期货帐户没有此属性
print("回购总市值", accountInfo.m_dRepurchaseValue) # 期货帐户没有此属性
print("多单总市值", accountInfo.m_dLongValue) # 现货帐户没有此属性
print("空单总市值", accountInfo.m_dShortValue) # 现货帐户没有此属性
print("净持仓总市值", accountInfo.m_dNetValue) # 净持仓市值 = 多 - 空
print("净资产", accountInfo.m_dAssureAsset)
print("总负债", accountInfo.m_dTotalDebit)
print("可信资产", accountInfo.m_dEntrustAsset) # 用于校对
print("总市值", accountInfo.m_dInstrumentValueRMB) # 沪港通 （人民币）
print("申购费", accountInfo.m_dSubscribeFee)
print("库存市值", accountInfo.m_dGoldValue) # 黄金现货库存市值
print("现货冻结", accountInfo.m_dGoldFrozen) # 黄金现货冻结
print("占用保证金", accountInfo.m_dMargin)
print("币种", accountInfo.m_strMoneyType)
print("购买力", accountInfo.m_dPurchasingPower)
print("原始保证金", accountInfo.m_dRawMargin)
print("买入待交收", accountInfo.m_dBuyWaitMoney) # 金额（元）
print("卖出待交收", accountInfo.m_dSellWaitMoney) # 金额（元）
print("本期间应计利息", accountInfo.m_dReceiveInterestTotal)
print("权利金收支", accountInfo.m_dRoyalty) # 期货期权用
print("冻结权利金", accountInfo.m_dFrozenRoyalty) # 期货期权用
print("实时占用保证金", accountInfo.m_dRealUsedMargin) # 用于股票期权
print("实时风险度", accountInfo.m_dRealRiskDegree)
"""
运行结果：
===========accountInfo 对象的属性==============================
帐号ID 410038216969
账号类型 2
保证金比率 0.0
冻结保证金 199922620.34
冻结金额 0.0
冻结手续费 0.0
风险度 0.0
单位净值 0.0
期初权益 199922620.34
总资产 199922620.34
可用金额 199922620.34
手续费 0.0
持仓盈亏 0.0
平仓盈亏 0.0
出入金净值 0.0
当前使用的保证金 0.0
初始权益 199922620.34
账号状态 登录成功
期初平仓盈亏 0.0
总市值 0.0
入金 0.0
出金 0.0
上次信用额度 0.0
上次质押 0.0
质押 0.0
信用额度 0.0
证券初始资金 199922620.34
起始日期
可取金额 199922620.34
交易日 20230919
股票总市值 0.0
债券总市值 0.0
基金总市值 0.0
回购总市值 0.0
多单总市值 0.0
空单总市值 0.0
净持仓总市值 0.0
净资产 199922620.34
总负债 0.0
可信资产 0.0
总市值 0.0
申购费 0.0
库存市值 0.0
现货冻结 0.0
占用保证金 0.0
币种
购买力 0.0
原始保证金 0.0
买入待交收 0.0
卖出待交收 0.0
本期间应计利息 0.0
权利金收支 0.0
冻结权利金 0.0
实时占用保证金 0.0实时风险度 0.0
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
# 5.2 任务状态变化
task_callback()
TIP
- 仅在实盘运行模式下生效。
- 需要先在init里调用
ContextInfo.set_account后生效。
语法： task_callback(ContextInfo, taskInfo)
功能： 当账号任务状态有变化时，这个函数会主动运行一次。
参数：
- ContextInfo —— 特定对象
- taskInfo —— 任务对象，请参考示例中的属性描述。
返回： 无
示例：
请在策略编辑器中，将示例代码，先保存为策略文件，可用名称为“tasktest”；
然后在“策略交易”界面中运行这个策略，并点击“实盘“模式；
在”交易“界面中，任意手动下一个委托单，如委托买入某一支股票，即可触发一个任务。此时，在”任务列表“中即可看到刚刚操作的记录；
点击”策略交易“，回到此界面，即可在”策略日志“中看到程序的输出结果；
# coding:GBK
def init(ContextInfo):
# 设置对应的资金账号
ContextInfo.set_account('410038216969')
def task_callback(ContextInfo, taskInfo):
print('===========taskInfo 对象中包含的属性============================================')
print("任务号ID " ,taskInfo.m_nTaskId)
print("任务状态" ,taskInfo.m_eStatus) # 任务状态 ETaskStatus 类型,详见 QMT 知识库中的说明
print("任务状态消息" ,taskInfo.m_strMsg)
print("任务开始时间" ,taskInfo.m_startTime)
print("任务结束时间" ,taskInfo.m_endTime)
print("任务取消时间" ,taskInfo.m_cancelTime)
print("已成交量" ,taskInfo.m_nBusinessNum)
print("组合Id" ,taskInfo.m_nGroupId)
print("下单品种代码" ,taskInfo.m_stockCode) # 不针对组合下单
print("下单用户" ,taskInfo.m_strAccountID) # 单用户下单时适用
print("下单操作类型" ,taskInfo.m_eOperationType) # 详见 EOperationType类型, 详见 QMT 知识库中的说明
print("算法交易" ,taskInfo.m_eOrderType) # EOrderType类型, 详见 QMT 知识库中的说明
print("报价方式" ,taskInfo.m_ePriceType) # 详见 EPriceType QMT 知识库中的说明
print("委托价" ,taskInfo.m_dFixPrice)
print("委托量" ,taskInfo.m_nNum)
"""
===========taskInfo 对象中包含的属性============================================
任务号ID 5
任务状态 3
任务状态消息 5.3000全部委托!
任务开始时间 1695180356
任务结束时间 2147483647
任务取消时间 2147483647
已成交量 0
组合Id 5
下单品种代码 600027.SH
下单用户 410038216969
下单操作类型 18
算法交易 0
报价方式 10
委托价 5.3
委托量 200
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 5.3 委托状态变化
order_callback()
功能： 当账号委托状态有变化时，这个函数会主动运行一次。
语法：order_callback(ContextInfo, orderInfo)
参数：
- ContextInfo ——特定对象
- orderInfo —— 委托账号对象，请参考示例中的属性描述。
返回： 无
示例：
同理，需参照上例，先保存为一个策略程序，然后在“策略交易”中运行此程序。再手动操作一个 委托单，则此函数会自动执行一次，即可看到执行的结果。
# coding:GBK
def init(ContextInfo):
# 设置对应的资金账号
ContextInfo.set_account('410038216969')
def order_callback(ContextInfo, orderInfo):
print('===========orderInfo 对象中包含的属性============================================')
print("资金账号 " ,orderInfo.m_strAccountID)
print("证券市场" ,orderInfo.m_strExchangeID)
print("交易市场" ,orderInfo.m_strExchangeName)
print("品种代码" ,orderInfo.m_strProductID)
print("品种名称" ,orderInfo.m_strProductName)
print("合约代码" ,orderInfo.m_strInstrumentID)
print("合约名称" ,orderInfo.m_strInstrumentName)
print("内部委托号" ,orderInfo.m_strOrderRef)
print("委托价格类型" ,orderInfo.m_nOrderPriceType) # 如市价单、限价单 ， 详见 QMT 知识库中的说明 EBrokerPriceType 类型描述
print("交易方向" ,orderInfo.m_nDirection) # 如多、空，详见 QMT 知识库中的说明 EEntrustBS 类型描述
print("开平标志" ,orderInfo.m_nOffsetFlag) # 如：买卖/开平 ，区别 期货、股票与期权的交易。详见 EOffset_Flag_Type 类型, QMT 知识库中的说明
print("投保类型" ,orderInfo.m_nHedgeFlag) # 详见 EHedge_Flag_Type 类型, QMT 知识库中的说明
print("委托价格" ,orderInfo.m_dLimitPrice)
print("最初委托量" ,orderInfo.m_nVolumeTotalOriginal)
print("报单状态" ,orderInfo.m_nOrderSubmitStatus) # 股票没有此属性 详见 EEntrustSubmitStatus 类型, QMT 知识库中的说明
print("委托号" ,orderInfo.m_strOrderSysID)
print("委托状态" ,orderInfo.m_nOrderStatus) # 详见 EEntrustStatus 类型, QMT 知识库中的说明
print("已成交量" ,orderInfo.m_nVolumeTraded)
print("当前总委托量" ,orderInfo.m_nVolumeTotal) # 股票的值为 总委托量 减去 已成交量
print("报错消息ID" ,orderInfo.m_nErrorID)
print("报错消息" ,orderInfo.m_strErrorMsg)
print("任务号" ,orderInfo.m_nTaskId)
print("冻结金额" ,orderInfo.m_dFrozenMargin)
print("冻结手续费" ,orderInfo.m_dFrozenCommission)
print("委托日期" ,orderInfo.m_strInsertDate)
print("委托时间" ,orderInfo.m_strInsertTime)
print("成交均价" ,orderInfo.m_dTradedPrice)
print("已撤数量" ,orderInfo.m_dCancelAmount)
print("买卖标记" ,orderInfo.m_strOptName) # 中文显示
print("成交金额" ,orderInfo.m_dTradeAmount) # 期货 = 均价 * 量 * 合约乘数
print("委托类型" ,orderInfo.m_eEntrustType) # 详见 EEntrustTypes 类型, QMT 知识库中的说明
print("废单原因" ,orderInfo.m_strCancelInfo)
print("标的证券代码" ,orderInfo.m_strUnderCode)
print("备兑标记" ,orderInfo.m_eCoveredFlag) # ECoveredFlag 类型，'0' - 非备兑，'1' - 备兑
print("港股通委托价格" ,orderInfo. m_dOrderPriceRMB) # （人民币），目前用于港股通
print("港股通成交金额" ,orderInfo.m_dTradeAmountRMB) # （人民币），目前用于港股通
print("汇率" ,orderInfo.m_dReferenceRate)
print("合约编号" ,orderInfo.m_strCompactNo)
print("头寸来源" ,orderInfo.m_eCashgroupProp) # 详见 EXTCompactBrushSource类型 QMT 知识库中的说明
print("在途保证金" ,orderInfo.m_dShortOccupedMargin)
print("是否是迅投交易" ,orderInfo.m_strXTTrade)
print("账号key" ,orderInfo.m_strAccountKey)
print("投资备注" ,orderInfo.m_strRemark)
"""
===========orderInfo 对象中包含的属性============================================
资金账号 410038216969
证券市场 SH
交易市场 上证所
品种代码
品种名称
合约代码 600740
合约名称 山西焦化
内部委托号 9167682570542907397
委托价格类型 50
交易方向 48
开平标志 48
投保类型 49
委托价格 5.2
最初委托量 200
报单状态 51
委托号 805011942
委托状态 50
已成交量 0
当前总委托量 200
报错消息ID 2147483647
报错消息
任务号 6
冻结金额 1040.0
冻结手续费 2.104
委托日期 20200920
委托时间 142241
成交均价 0.0
已撤数量 0.0
买卖标记 限价买入
成交金额 0.0
委托类型 48
废单原因
标的证券代码
备兑标记 0
港股通委托价格 0.0
港股通成交金额 0.0
汇率 0.0
合约编号
头寸来源 48
在途保证金 1.7976931348623157e+308
是否是迅投交易 本终端
账号key 2____11075________49____410038216969____
投资备注
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
# 5.4 成交状态变化
deal_callback()
功能： 当账号成交状态有变化时，这个函数会主动运行一次。
语法：deal_callback(ContextInfo, dealInfo)
参数：
- ContextInfo ——特定对象
- dealInfo —— 资金账号对象，请参考示例中的属性描述。
返回： 无
示例：
# coding:GBK
def init(ContextInfo):
# 设置对应的资金账号
ContextInfo.set_account('410038216969')
def deal_callback(ContextInfo, dealInfo):
print('===========dealInfo 对象中包含的属性============================================')
print("资金账号 " ,dealInfo.m_strAccountID)
print("证券市场" ,dealInfo.m_strExchangeID)
print("交易市场" ,dealInfo.m_strExchangeName)
print("品种代码" ,dealInfo.m_strProductID)
print("品种名称" ,dealInfo.m_strProductName)
print("合约代码" ,dealInfo.m_strInstrumentID)
print("合约名称" ,dealInfo.m_strInstrumentName)
print("成交编号" ,dealInfo.m_strTradeID)
print("内部委托号" ,dealInfo.m_strOrderRef)
print("委托号" ,dealInfo.m_strOrderSysID)
print("交易方向" ,dealInfo.m_nDirection) # 如多、空，详见 QMT 知识库中的说明 EEntrustBS 类型描述
print("开平标志" ,dealInfo.m_nOffsetFlag) # 如：买卖/开平 ，区别 期货、股票与期权的交易。详见 EOffset_Flag_Type 类型, QMT 知识库中的说明
print("实际开平标志" ,dealInfo.m_nRealOffsetFlag) # 如：买卖/开平 ，主要是区分平今和平昨。详见 EOffset_Flag_Type 类型, QMT 知识库中的说明
print("投保类型" ,dealInfo.m_nHedgeFlag) # 详见 EHedge_Flag_Type 类型, QMT 知识库中的说明
print("成交均价" ,dealInfo.m_dPrice)
print("成交量" ,dealInfo.m_nVolume)
print("成交日期" ,dealInfo.m_strTradeDate)
print("成交时间" ,dealInfo.m_strTradeTime)
print("手续费" ,dealInfo.m_dComssion)
print("成交金额" ,dealInfo.m_dTradeAmount) # 期货 = 均价 * 量 * 合约乘数
print("任务号" ,dealInfo.m_nTaskId)
print("委托价格类型" ,dealInfo.m_nOrderPriceType) # 如市价单、限价单 ， 详见 QMT 知识库中的说明 EBrokerPriceType 类型描述
print("买卖标记" ,dealInfo.m_strOptName) # 中文显示
print("委托类型" ,dealInfo.m_eEntrustType) # 详见 EEntrustTypes 类型, QMT 知识库中的说明
print("成交类型" ,dealInfo.m_eFutureTradeType) # 详见 EFutureTradeType 类型, QMT 知识库中的说明
print("备兑标记" ,dealInfo.m_eCoveredFlag) # ECoveredFlag 类型，'0' - 非备兑，'1' - 备兑
print("平今量" ,dealInfo.m_nCloseTodayVolume)
print("港股通委托价格" ,dealInfo. m_dOrderPriceRMB) # （人民币），目前用于港股通
print("港股通成交价格" ,dealInfo. m_dPriceRMB) # （人民币），目前用于港股通
print("港股通成交金额" ,dealInfo.m_dTradeAmountRMB) # （人民币），目前用于港股通
print("汇率" ,dealInfo.m_dReferenceRate)
print("是否是迅投交易" ,dealInfo.m_strXTTrade)
print("合约编号" ,dealInfo.m_strCompactNo)
print("平仓盈亏" ,dealInfo.m_dCloseProfit)
print("投资备注" ,dealInfo.m_strRemark)
print("账号key" ,dealInfo.m_strAccountKey)
print("订单编号" ,dealInfo.m_nRef)
"""
运行结果：
===========dealInfo 对象中包含的属性============================================
资金账号 410038216969
证券市场 SZ
交易市场 深交所
品种代码
品种名称
合约代码 000851
合约名称 高鸿股份
成交编号 591627450056722
内部委托号 9167682570542907397
委托号 805054363
交易方向 48
开平标志 48
实际开平标志 -1
投保类型 49
成交均价 6.22
成交量 200
成交日期 20230921
成交时间 110542
手续费 2.1244
成交金额 1244.0
任务号 6
委托价格类型 50
买卖标记 限价买入
委托类型 48
成交类型 48
备兑标记 48
平今量 0
港股通委托价格 0.0
港股通成交价格 0.0
港股通成交金额 0.0
汇率 0.0
是否是迅投交易 本终端
合约编号
平仓盈亏 0.0
投资备注
账号key 2____11075________49____410038216969____
订单编号 0
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
# 5.5 持仓状态变化
position_callback()
功能： 当账号持仓状态发生变化时，这个函数会主动运行一次。此方法可以在 策略编辑器 中直接运行测试，看到执行结果。
语法：position_callback(ContextInfo, positonInfo)
参数：
- ContextInfo ——特定对象
- positonInfo —— 资金账号对象。请参考示例中的属性描述。
返回： 无
示例：
# coding:GBK
def init(ContextInfo):
# 设置对应的资金账号
ContextInfo.set_account('410038216969')
def position_callback(ContextInfo, positionInfo):
print('===========positionInfo 对象中包含的属性============================================')
print("资金账号 " ,positionInfo.m_strAccountID)
print("证券市场" ,positionInfo.m_strExchangeID)
print("交易市场" ,positionInfo.m_strExchangeName)
print("品种代码" ,positionInfo.m_strProductID)
print("品种名称" ,positionInfo.m_strProductName)
print("合约代码" ,positionInfo.m_strInstrumentID)
print("合约名称" ,positionInfo.m_strInstrumentName)
print("投保类型" ,positionInfo.m_nHedgeFlag) # 股票无此属性 详见 EHedge_Flag_Type 类型, QMT 知识库中的说明
print("交易方向" ,positionInfo.m_nDirection) # 股票无此属性 如多、空，详见 QMT 知识库中的说明 EEntrustBS 类型描述
print("成交日期" ,positionInfo.m_strOpenDate)
print("成交编号" ,positionInfo.m_strTradeID)
print("持仓量" ,positionInfo.m_nVolume) # 当前持仓量
print("持仓成本" ,positionInfo.m_dOpenPrice)
print("最后成交日期" ,positionInfo.m_strTradingDay) # 实盘时即当前交易日，回测时是股票最后交易的日期
print("使用的保证金" ,positionInfo.m_dMargin) # 股票无此属性
print("开仓成本" ,positionInfo.m_dOpenCost) # 股票无此属性
print("结算价" ,positionInfo.m_dSettlementPrice) # 股票即为当前价
print("平仓量" ,positionInfo.m_nCloseVolume) # 股票无此属性
print("平仓额" ,positionInfo.m_dCloseAmount) # 股票无此属性
print("浮动盈亏" ,positionInfo.m_dFloatProfit)
print("平仓盈亏" ,positionInfo.m_dCloseProfit) # 股票无此属性
print("市值" ,positionInfo.m_dMarketValue)
print("持仓成本" ,positionInfo.m_dPositionCost)
print("持仓盈亏" ,positionInfo.m_dPositionProfit)
print("最新结算价" ,positionInfo.m_dLastSettlementPrice) # 股票无此属性
print("合约价值" ,positionInfo.m_dInstrumentValue) # 股票无此属性
print("是否今仓" ,positionInfo.m_bIsToday)
print("股东账号" ,positionInfo.m_strStockHolder)
print("冻结数量" ,positionInfo.m_nFrozenVolume) # 期货无此属性
print("可用余额" ,positionInfo.m_nCanUseVolume) # 期货无此属性
print("在途股份" ,positionInfo.m_nOnRoadVolume) # 期货无此属性
print("昨仓拥股" ,positionInfo.m_nYesterdayVolume) # 期货无此属性
print("最新价" ,positionInfo.m_dLastPrice) # 股票即为当前价
print("开仓均价" ,positionInfo.m_dAvgOpenPrice)
print("盈亏比例" ,positionInfo.m_dProfitRate)
print("成交类型" ,positionInfo.m_eFutureTradeType)
print("到期日" ,positionInfo.m_strExpireDate) # 逆回购用
print("组合成交号" ,positionInfo.m_strComTradeID)
print("组合序号" ,positionInfo.m_nLegId)
print("累计成本" ,positionInfo.m_dTotalCost) # 用于股票信用帐号
print("单股成本" ,positionInfo.m_dSingleCost) # 用于股票信用帐号
print("备兑数量" ,positionInfo.m_nCoveredVolume) # 用于 个股期权
print("持仓类型" ,positionInfo.m_eSideFlag) # ESideFlag 持仓类型 ，用于个股期权 '0' - 权利，'1' - 义务，'2' - '备兑'
print("汇率" ,positionInfo.m_dReferenceRate) # 用于港股通
print("分级基金可用" ,positionInfo.m_dStructFundVol) # 可分拆或可合并
print("分级基金可赎回量" ,positionInfo.m_dRedemptionVolume)
print("申赎可用量" ,positionInfo.m_nPREnableVolume) # 录当日申购赎回的股票或基金数量
print("实时占用保证金" ,positionInfo.m_dRealUsedMargin) # 用于 期权
print("权利金" ,positionInfo.m_dRoyalty)
print("标的证券最新价" ,positionInfo.m_dStockLastPrice) # 用于 期权
print("静态持仓占用保证金",positionInfo.m_dStaticHoldMargin) # 用于 期权
print("期权组合占用量" ,positionInfo.m_nOptCombUsedVolume)
print("个股期权量" ,positionInfo.m_nEnableExerciseVolume) # 用于 个股期权
print("账号key" ,positionInfo.m_strAccountKey)
"""
执行结果：
===========positionInfo 对象中包含的属性============================================
资金账号 410038216969
证券市场 SH
交易市场 上证所
品种代码
品种名称
合约代码 600027
合约名称 华电国际
投保类型 49
交易方向 48
成交日期
成交编号
持仓量 200
持仓成本 5.380100049999999
最后成交日期 20230921
使用的保证金 0.0
开仓成本 1076.02
结算价 5.4
平仓量 0
平仓额 0.0
浮动盈亏 4.0000000000000036
平仓盈亏 0.0
市值 1080.0
持仓成本 1076.02
持仓盈亏 3.980000000000018
最新结算价 0.0
合约价值 1080.0
是否今仓 True
股东账号 A103190588
冻结数量 100
可用余额 100
在途股份 0
昨仓拥股 200
最新价 5.4
开仓均价 5.380100049999999
盈亏比例 0.0036988160071374306
成交类型 48
到期日
组合成交号
组合序号 0
累计成本 0.0
单股成本 0.0
备兑数量 0
持仓类型 0
汇率 0.0
分级基金可用 0
分级基金可赎回量 0
申赎可用量 100
实时占用保证金 0.0
权利金 0.0
标的证券最新价 1.7976931348623157e+308
静态持仓占用保证金 1.7976931348623157e+308
期权组合占用量 0
个股期权量 -1
账号key 2____11075________49____410038216969____
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
# 5.6 异常下单主推
orderError_callback()
功能： 当账号下单异常时，运行这个函数
语法：orderError_callback(ContextInfo,orderArgs)
参数：
- ContextInfo —— 特定对象
- orderArgs —— 下单参数
errMsg —— 错误信息。 并不支持此参数，官方文档中的错误！
返回： 无
示例：
# coding:GBK
def init(ContextInfo):
# 设置对应的资金账号
ContextInfo.set_account('410038216969')
def position_callback(ContextInfo,orderArgs):
print('===========orderArgs 对象中包含的属性============================================')
print("是否今仓 " ,orderArgs.m_bIsToday)
print("开仓均价 " ,orderArgs.m_dAvgOpenPrice)
print("平仓额 " ,orderArgs.m_dCloseAmount)
print("平仓盈亏 " ,orderArgs.m_dCloseProfit)
print("浮动盈亏 " ,orderArgs.m_dFloatProfit)
print("合约价值 " ,orderArgs.m_dInstrumentValue)
print("最新价 " ,orderArgs.m_dLastPrice)
print("最新结算价 " ,orderArgs.m_dLastSettlementPrice)
print("使用的保证金 " ,orderArgs.m_dMargin)
print("市值 " ,orderArgs.m_dMarketValue)
print("开仓成本 " ,orderArgs.m_dOpenCost)
print("开仓价格 " ,orderArgs.m_dOpenPrice)
print("持仓成本 " ,orderArgs.m_dPositionCost)
print("持仓盈亏 " ,orderArgs.m_dPositionProfit)
print("盈亏比例 " ,orderArgs.m_dProfitRate)
print("实时占用保证金 " ,orderArgs.m_dRealUsedMargin)
print("分级基金可赎回量 " ,orderArgs.m_dRedemptionVolume)
print("汇率 " ,orderArgs.m_dReferenceRate) # 用于港股通
print("权利金 " ,orderArgs.m_dRoyalty)
print("结算价 " ,orderArgs.m_dSettlementPrice)
print("单股成本 " ,orderArgs.m_dSingleCost)
print("静态持仓占用保证金 " ,orderArgs.m_dStaticHoldMargin) # 用于期权
print("标的证券最新价 " ,orderArgs.m_dStockLastPrice) # 用于期权
print("分级基金可用 " ,orderArgs.m_dStructFundVol) # 可分拆或可合并
print("累计成本 " ,orderArgs.m_dTotalCost)
print("成交类型 " ,orderArgs.m_eFutureTradeType)
print("持仓类型 " ,orderArgs.m_eSideFlag) # 用于个股期权，标记 '0' - 权利，'1' - 义务，'2' - '备兑'
print("可用余额 " ,orderArgs.m_nCanUseVolume)
print("m_nCidIncrease " ,orderArgs.m_nCidIncrease)
print("m_nCidIsDelist " ,orderArgs.m_nCidIsDelist)
print("m_nCidRateOfCurrentLine " ,orderArgs.m_nCidRateOfCurrentLine)
print("m_nCidRateOfTotalValue " ,orderArgs.m_nCidRateOfTotalValue)
print("平仓量 " ,orderArgs.m_nCloseVolume)
print("备兑数量 " ,orderArgs.m_nCoveredVolume)
print("买卖方向 " ,orderArgs.m_nDirection) # 股票 该值始终是 48
print("用于个股期权 " ,orderArgs.m_nEnableExerciseVolume)
print("冻结数量 " ,orderArgs.m_nFrozenVolume)
print("投保 " ,orderArgs.m_nHedgeFlag) # 股票不需要
print("组合序号 " ,orderArgs.m_nLegId)
print("在途股份 " ,orderArgs.m_nOnRoadVolume)
print("期权组合占用数量 " ,orderArgs.m_nOptCombUsedVolume)
print("申赎可用量 " ,orderArgs.m_nPREnableVolume)
print("持仓量 " ,orderArgs.m_nVolume)
print("昨仓拥股 " ,orderArgs.m_nYesterdayVolume) # 截止到昨夜的持仓量，不是 昨天一天的持仓量。
print("账号ID " ,orderArgs.m_strAccountID)
print("账号key " ,orderArgs.m_strAccountKey)
print("组合成交号 " ,orderArgs.m_strComTradeID)
print("市场 " ,orderArgs.m_strExchangeID)
print("交易所名称 " ,orderArgs.m_strExchangeName)
print("到期日 " ,orderArgs.m_strExpireDate)
print("证券代码 " ,orderArgs.m_strInstrumentID)
print("证券名称 " ,orderArgs.m_strInstrumentName)
print("成交日期 " ,orderArgs.m_strOpenDate)
print("品种代码 " ,orderArgs.m_strProductID)
print("品种名称 " ,orderArgs.m_strProductName)
print("股东账号 " ,orderArgs.m_strStockHolder)
print("成交编号 " ,orderArgs.m_strTradeID)
print("交易日 " ,orderArgs.m_strTradingDay)
print("m_xtTag " ,orderArgs.m_xtTag)
"""
运行结果：
===========orderArgs 对象中包含的属性============================================
是否今仓 True
开仓均价 2.6201000999999997
平仓额 0.0
平仓盈亏 0.0
浮动盈亏 0.0
合约价值 259.0
最新价 2.59
最新结算价 0.0
使用的保证金 0.0
市值 259.0
开仓成本 262.01
开仓价格 2.6201000999999997
持仓成本 262.01
持仓盈亏 -3.009999999999991
盈亏比例 -0.011488111140796118
实时占用保证金 0.0
分级基金可赎回量 0
汇率 0.0
权利金 0.0
结算价 2.59
单股成本 0.0
静态持仓占用保证金 1.7976931348623157e+308
标的证券最新价 1.7976931348623157e+308
分级基金可用 0
累计成本 0.0
成交类型 48
持仓类型 0
可用余额 100
m_nCidIncrease -2147473664
m_nCidIsDelist -2072858414
m_nCidRateOfCurrentLine 0
m_nCidRateOfTotalValue 0
平仓量 0
备兑数量 0
买卖方向 48
用于个股期权 -1
冻结数量 0
投保 49
组合序号 0
在途股份 0
期权组合占用数量 0
申赎可用量 100
持仓量 100
昨仓拥股 100
账号ID 410038216969
账号key 2____11075________49____410038216969____
组合成交号
市场 SZ
交易所名称 深交所
到期日
证券代码 000836
证券名称 富通信息
成交日期
品种代码
品种名称
股东账号 0103749588
成交编号
交易日 20230922
m_xtTag None
"""
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
# 需帐户支持的方法，略
以下方法（函数），需帐户为 信用帐户或两融帐户。因此无乎用不上，具体用法略。
查询信用账户明细
query_credit_account()
查询信用账户明细回调
credit_account_callback()
查询信用账户明细回调
query_credit_opvolume()
查询两融最大可下单量
credit_opvolume_callback()
# 6） 引用函数
注：以下函数均支持 回测 和 实盘/模拟 运行模式。
# 6.1 获取外部扩展数据
# ext_data()
功能： 获取扩展数据
语法：ext_data(extdataname, stockcode, deviation, ContextInfo)
参数：
extdataname ——string，扩展数据名
stockcode —— string，形式如 'stkcodemarket'，如 '600000.SH'
deviation ——number，K 线偏移，可取值：
0：不偏移
N：向右偏移N
-N：向左偏移N
返回： number
示例：
def handlebar(ContextInfo):
print(ext_data('mycci', '600000.SH', 0, ContextInfo))
2
# 6.2 获取扩展数据按数值品种排名
# ext_data_rank()
功能： 获取引用的扩展数据的数值在所有品种中的排名
语法： ext_data_rank(extdataname, stockcode, deviation, ContextInfo)
参数：
extdataname —— string，扩展数据名
stockcode —— string，形式如 'stkcodemarket'，如 '600000.SH'
deviation —— number，K 线偏移，可取值：
0：不偏移
N：向右偏移N
-N：向左偏移N
ContextInfo：pythonObj，Python 对象，这里必须是 ContextInfo
返回： number
示例：
def handlebar(ContextInfo):
print(ext_data_rank('mycci', '600000.SH', 0, ContextInfo))
2
# 6.3 获取扩展数据按时间品种排名
# ext_data_rank_range()
功能： 获取引用的扩展数据的数值在指定时间区间内所有品种中的排名
语法： ext_data_rank_range(extdataname, stockcode, begintime, endtime, ContextInfo)
参数：
extdataname —— string，扩展数据名
stockcode —— string，形式如 'stkcodemarket'，如 '600000.SH'
begintime —— string，区间的起始时间（包括该时间点在内）格式为 '2016-08-02 12:12:30'
endtime —— string，区间的结束时间（包括该时间点在内）格式为 '2017-08-02 12:12:30'
ContextInfo：pythonObj，Python 对象，这里必须是 ContextInfo
返回： pythonDict
示例：
def handlebar(ContextInfo):
print(ext_data_rank_range('mycci', '600000.SH', '2016-08-02 12:12:30','2017-08-02 12:12:30', ContextInfo))
2
# 6.4 获取扩展数据时间区间内的值
# ext_data_range()
功能： 获取扩展数据在指定时间区间内的值
语法：ext_data_range(extdataname, stockcode, begintime, endtime, ContextInfo)
参数：
extdataname —— string，扩展数据名
stockcode —— string，形式如 'stkcodemarket'，如 '600000.SH'
begintime —— string，区间的起始时间（包括该时间点在内）格式为 '2016-08-02 12:12:30'
endtime —— string，区间的结束时间（包括该时间点在内）格式为 '2017-08-02 12:12:30'
ContextInfo：pythonObj，Python 对象，这里必须是 ContextInfo
返回： pythonDict
示例：
def handlebar(ContextInfo):
print(ext_data_range('mycci', '600000.SH', '2016-08-02 12:12:30', '2017-08-02 12:12:30', ContextInfo))
2
3
# 6.5 获取因子数据
# get_factor_value()
功能： 获取因子数据
语法： get_factor_value(factorname, stockcode, deviation, ContextInfo)
参数：
factorname —— string，因子名
stockcode —— string，形式如 'stkcodemarket'，如 '600000.SH'
deviation —— number，K 线偏移，0 不偏移，N 向右偏移 N，-N 向左偏移 N
ContextInfo —— pythonObj，Python 对象，这里必须是 ContextInfo
返回： number
示例：
def handlebar(ContextInfo):
print(get_factor_value('zzz', '600000.SH', 0, ContextInfo))
2
# 6.6 获取因子数据品种排名
# get_factor_rank()
功能： 获取引用的因子数据的数值在所有品种中排名
语法： get_factor_rank(factorname, stockcode, deviation, ContextInfo)
参数：
factorname —— string，因子名
stockcode —— string，形式如 'stkcodemarket'，如 '600000.SH'
deviation —— number，K 线偏移，0不偏移，N向右偏移N，-N向左偏移N
ContextInfo —— pythonObj，Python 对象，这里必须是 ContextInfo
返回： number
示例：
def handlebar(ContextInfo):
print(get_factor_rank('zzz', '600000.SH', 0, ContextInfo))
2
# 6.7 调用VBA模型
# call_vba()
功能： 获取引用的 VBA 模型运行的结果
语法： call_vba(factorname, stockcode, [period, dividend_type, barpos, ]ContextInfo)
注：使用该函数时需补充好本地 K 线或分笔数据
参数：
factorname —— string，模型名及引用变量，如 'MA.ma1'，其中 MA是模型名称，ma1 是其中一个变量，不区分大小写；
stockcode —— string，形式如 'stkcodemarket'，如 '600000.SH '
period —— string，K 线周期类型，可缺省，默认为当前主图周期线型，可选值：'tick' 表示 分笔，'1d'表示日线，'1m' 表示1分钟......
dividend_type —— string，除复权，可缺省，默认当前图复权方式，可选值：'’none' 表示 不复权
barpos —— number，对应 bar 下标，可缺省，默认当前主图调用到的 bar 的对应下标
ContextInfo —— pythonObj，Python 对象，这里必须是 ContextInfo
返回： 浮点数，float 对应最后一根K线的值。
WARNING
应用时，主图请选择对应的时间周期。如果要获取动态指标，则只支持5m， 1d；取动态数据时需要调用set_universe，且该接口有订阅限制，订阅有最大数量限制(当前为500个）
需在 handlebar() 中调用VBA模型，如此才会在每一根K线上计算一次。
示例：
#coding:gbk
# 获取vba指标
def init(ContextInfo):
#主图请选择对应周期， 想要获取动态指标，则只支持5m， 1d
# 注意，取动态数据时需要调用set_universe，且该接口有订阅限制，
# 详见 http://docs.thinktrader.net/vip/pages/cc95b6/#_1-qmt行情数据基础概念
# 关于订阅的说明
ContextInfo.set_universe(['300014.SZ','600011.SH'])
def handlebar(ContextInfo):
ma1 = call_vba('MA.ma1','300014.SZ',ContextInfo)
j1 = call_vba('KDJ.J','300014.SZ',ContextInfo)
ma2 = call_vba('MA.ma1','600011.SH',ContextInfo)
j2 = call_vba('KDJ.J','600011.SH',ContextInfo)
print('300014.SZ ma', round(ma1, 2), 'kdj j: ', round(j1, 3), '600011.SH ma', round(ma2, 2), 'kdj j: ', round(j2, 3))
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 6.8 调用VBA组合模型
# call_formula()
功能： python调用组合模型，返回GruopModelInfo结构体
语法：call_formula(formulaName,code,period,divideType,basket,argsDict,startime="",endTime="",count =-1)
注：使用该函数时需补充好本地 K 线或分笔数据
参数：
factorname —— string，模型名及引用变量，如 'MA.ma1'
stockcode —— string，形式如 'stkcodemarket'，如 '600000.SH '
period —— string，K 线周期类型，可缺省，默认为当前主图周期线型，可选值：'tick' 表示 分笔，'1d'表示日线，'1m' 表示1分钟......
dividend_type —— string，除复权，可缺省，默认当前图复权方式，可选值：'’none' 表示 不复权
basket —— dict，组合模型的股票池权重，形如{'SH600000':0.06,'SZ000001':0.01}
argsDict —— dict，组合模型的入参，{参数名:参数值}，形如{'a':1}
startTime —— string，缺失参数，组合模型运行起始时间，形如:'20200101'
endTime —— string，缺失参数，组合模型运截止时间，形如:'20200101'
count —— int，缺省参数，组合模型运行范围为向前count根bar
返回： GruopModelInfo结构体。GruopModelInfo.result为当前模型的运行结果，运行 GruopModelInfo.unsubscribe()会取消组合模型的运行，GruopModelInfo随着python的析构也会调用取消组合模型运行。
示例：
def handlebar(ContextInfo):
basket={'SH600000':0.06,'SZ000001':0.01}
argsDict={'a':100}
groupModelInfo=call_formula('testGroupModel','000300.SH',basket,argsDict);
print(groupModelInfo.result);
groupModelInfo.unsubscribe();#取消组合模型运行
2
3
4
5
6
7
# 7） 绘图函数
以下函数，其实就是在图表上画线或显示文字、符号，即画出自定义指标。基本原理就是给定座标，然后指定画线，还是写文字。座标的 X 轴其实就是时间戳，从左往右，最新的时间在最右边；Y轴就是当前品种的报价；指定了 X，Y ，然后告诉程序想画的线型、粗细、颜色等参数，或写什么文字即可。在绘制前需要指定绘画的位置，即副图、主图叠加 或 主图。迅投QMT中提供的画图功能有限，基本方法就是以下几个。
写好代码后，需要先保存。然后切换到”行情“界面，单击左侧面板底部的”模型“标签，在其中双击刚刚保存的自定义指标名称，即可看到绘制的效果。
# 7.1 在界面上画图
ContextInfo.paint()
功能： 根据指定的座标，画线。
语法： ContextInfo.paint(name, data, index, drawStyle, selectcolor = 'white', limit = '')
参数：
name —— string，为这个绘画的指标起一个名称，会显示在左上角
data —— number，名称后面显示的数值，可以理解为这个指标的值
index —— number，显示索引位置，填 -1 表示按主图索引显示
drawStyle —— number，线型，0 表示曲线 42 表示 柱状线
selectcolor —— string，颜色（不填默认为白色）目前支持以下几种颜色：blue：蓝brown：棕cyan：蓝绿green：绿magenta：品红red：红white：白yellow：黄
limit —— string，背景网格，'noaxis' 表示不画网格线： 'nodraw' ：不画出指标的线
（官方文档中居然把 关键字参数的名称也写错，也是醉了。）
返回： 无
示例：
#encoding:gbk
def handlebar(ContextInfo):
# 获取图表上，K线对应的时间戳。即 x 座标
realtimetag = ContextInfo.get_bar_timetag(ContextInfo.barpos)
# 获取对应的时间上 K 线的收盘价。即 y 座标
ind_Value = ContextInfo.get_close_price('', '', realtimetag)
# 绘制指标
ContextInfo.paint(name = '收盘价', # 指标名称 close
data = ind_Value, # 显示在名称后面的 值
index = -1, # 显示索引位置，-1 表示按 主图上的K线索引值
drawStyle = 0, # 线型，0 表示曲线，42 表示 柱子
selectcolor = 'white', # 线的颜色
limit = 'noaxis' # 画线控的控制
)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 7.2 在图形上显示文字
ContextInfo.draw_text()
功能： 在图形上显示文字
语法： ContextInfo.draw_text(condition, position, text)
参数： condition —— 条件，为 True 时 才显示 Position —— 位置，即 Y座标价格 text —— 文字
返回： 无
示例：
#encoding:gbk
def handlebar(ContextInfo):
# 获取图表上，K线对应的时间戳。即 x 座标
realtimetag = ContextInfo.get_bar_timetag(ContextInfo.barpos)
# 获取对应的时间上 K 线的收盘价。即 y 座标
ind_Value = ContextInfo.get_close_price('', '', realtimetag)
# 右侧面板上选择 主图叠加，在最右的K线上方 + 1 的位置，显示文字
ContextInfo.draw_text(ContextInfo.barpos == ContextInfo.time_tick_size -1, # 满足此条件才显示，即 最右边的K线上
ind_Value+ 1, # 显示的位置，在K线上方
"显示文字。" # 显示汉字，可能会出现乱码。加上一个中文句号可以改善。
)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 7.3 在图形上显示数字
ContextInfo.draw_number()
功能： 在图形上显示数字
语法： ContextInfo.draw_number(cond, height, number, precision)
参数： cond —— bool，条件 height —— number，显示数字的的高度位置 text —— string，显示的具体数字。数字不要超出图表太多。 precision —— 显示小数位数（取值范围 0 - 7）
返回： 无
示例：
#encoding:gbk
def handlebar(ContextInfo):
# 获取图表上，K线对应的时间戳。即 x 座标
realtimetag = ContextInfo.get_bar_timetag(ContextInfo.barpos)
# 获取对应的时间上 K 线的收盘价。即 y 座标
ind_Value = ContextInfo.get_market_data(['close'])
# 右侧面板上选择 主图叠加，在最右的K线上方 + 1 的位置，显示文字
ContextInfo.draw_number(ContextInfo.barpos == ContextInfo.time_tick_size -1, # 满足此条件才显示，即 最右边的K线上
ind_Value+ 1, # 显示的位置，在K线上方
ind_Value+3.1415926, # 数字不要超出图表太多。
7
)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 7.4 在两个数之间绘垂直线
ContextInfo.draw_vertline()
功能： 在数字1和数字2之间绘垂直线
语法： ContextInfo.draw_vertline(cond, number1, number2, color = '', limit = '')
参数： cond —— bool，条件 number1 —— number，数字1 number2 —— number，数字2 color —— string，颜色（不填默认为白色）目前支持以下几种颜色：blue：蓝brown：棕cyan：蓝绿green：绿magenta：品红red：红white：白yellow：黄 limit —— string，画线控制，可取值：'noaxis'： 不影响坐标画线 'nodraw' ：不画线
返回： 无
示例：
#encoding:gbk
def handlebar(ContextInfo):
close = ContextInfo.get_market_data(['close'])
open = ContextInfo.get_market_data(['open'])
# 右侧面板上选择 主图叠加，在最右的K线上方 + 1 的位置，显示文字
ContextInfo.draw_vertline(1, # 满足此条件才显示，1 表示全都画
close, # 画垂直线的起点
open, # 画垂直线的终点
'yellow', # 画线的颜色
)
2
3
4
5
6
7
8
9
10
11
12
13
14
# 7.5 在图形上绘制小图标
ContextInfo.draw_icon()
功能： 在图形上绘制小图标
语法： ContextInfo.draw_icon(cond, height, type)
参数： cond —— bool，条件 height —— number，图标的位置 text —— number，图标的类型，可取值：1：椭圆 0：矩形
返回： 无
示例：
#encoding:gbk
def handlebar(ContextInfo):
close = ContextInfo.get_market_data(['close'])
# 右侧面板上选择 主图叠加，在最右的K线上方 + 1 的位置，显示文字
ContextInfo.draw_icon(1, # 满足此条件才显示，1 表示全都画
close, # 画垂直线的起点
0, # 画线的颜色
)
2
3
4
5
6
7
8
9
10
11
# 附录：
# 一、MACD 红绿买卖 回测模型源码
# coding:GBK
"""
MACD 红绿买卖 回测
"""
class G():pass
g = G()
g.m5Data = {}
g.StockList = ["603055.SH","000797.SZ"]
g.StockPos = {}
account = "620000123673"
SectorName = "上证50" # 如 “上证50”
def init(ContextInfo):
print("\n 程序 开始准备历史 数据。")
ContextInfo.set_account(account)
if len(SectorName) > 0:
g.StockList = ContextInfo.get_stock_list_in_sector(SectorName)
g.m5Data = ContextInfo.get_market_data_ex(
['close'], # 获取 收盘价
g.StockList, # 股票品种列表
period = '5m', # 时间周期 5分钟
count = -1, # 获取 500 根历史K线的数据
subscribe = False # 订阅品种后续的报价
)
print("\n 获取历史数据完成。")
def handlebar(ContextInfo):
if not ContextInfo.do_back_test:
print("\n 此程序专用于 回测模式，不适用于模拟运行。")
return
timetag_1 = ContextInfo.get_bar_timetag(ContextInfo.barpos)
timetag_2 = ContextInfo.get_bar_timetag(ContextInfo.barpos-1)
timetag_3 = ContextInfo.get_bar_timetag(ContextInfo.barpos-2)
bar_1stime = timetag_to_datetime(timetag_1,"%Y%M%D%H%M%S")
bar_2stime = timetag_to_datetime(timetag_2,"%Y%M%D%H%M%S")
bar_3stime = timetag_to_datetime(timetag_3,"%Y%M%D%H%M%S")
for Symbol in g.StockList:
g.StockPos[Symbol] = {"持股总数量":0,
"可用数量":0,
"持股的总金额":0,
"盈亏比例":0
}
pos_list = get_trade_detail_data(account,'stock','position')
for pos in pos_list:
Symbol = pos.m_strInstrumentID + "." + pos.m_strExchangeID
g.StockPos[Symbol]["持股总数量"] = pos.m_nVolume
g.StockPos[Symbol]["可用数量"] = pos.m_nCanUseVolume
for Symbol in g.StockList:
macd3hist = call_vba('MACD.macd1',Symbol,'5m',ContextInfo.barpos-2,ContextInfo)
macd2hist = call_vba('MACD.macd1',Symbol,'5m',ContextInfo.barpos-1,ContextInfo)
if (g.StockPos[Symbol]["持股总数量"] < 100 and
macd3hist < 0 and
macd2hist > 0 # MACD 的柱子 由绿翻红 了
):
print("\n 当前品种",Symbol,"时间",bar_1stime,"MACD柱子绿翻红了，买入")
passorder(23,1101,account,Symbol,5,0,100,"MACD绿翻红",1,"1",ContextInfo)
if (g.StockPos[Symbol]["持股总数量"] >= 100 and
macd3hist > 0 and
macd2hist < 0
):
print("\n 当前品种",Symbol,"时间",bar_1stime,"MACD柱子红翻绿了，卖出")
passorder(24,1101,account,Symbol,5,0,100,"MACD红翻绿",1,"1",ContextInfo)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
# 二、MACD 红绿买卖 实时交易模型源码
# coding:GBK
"""
5m 图表上，观察 MACD 指标
MACD柱子绿翻红，买入100股
MACD柱子红翻绿，卖出100股
"""
import pandas as pd
import numpy as np
import talib
class G(): pass
g = G()
g.m5Data = {} # 用于保存5分钟的K线数据
g.StockList = ['601225.SH','000004.SZ']
g.StockPos = {} # 用于保存帐户中持有股标订单
account ="620000123673"
SectorName = "上证50" # 板块名 如“上证50”
def init(ContextInfo):
print("程序开始在 实时模拟仿真模式 下运行。")
ContextInfo.set_account(account)
if len(SectorName) > 0:
g.StockList = ContextInfo.get_stock_list_in_sector(SectorName)
for s in g.StockList:
g.m5Data[s] = {
}
g.StockPos[s] = {"持股总数量":0,
"可用数量":0
}
print("初始化完成。")
def handlebar(ContextInfo):
if not ContextInfo.is_last_bar():
return
Symbol = g.StockList[0]
if len(g.m5Data[Symbol]) == 0:
print("开始获取历史数据.......")
g.m5Data = ContextInfo.get_market_data_ex(
['close'],
g.StockList,
period = '5m',
count = 100,
subscribe = True
)
for Symbol in g.StockList:
closePrice = g.m5Data[Symbol]['close']
closePrice = closePrice.values
macd,signal,hist = talib.MACD(closePrice,fastperiod =12,slowperiod = 26,signalperiod = 9)
g.m5Data[Symbol]['hist'] = hist
print("获取历史数据完成。")
# =======获取持仓数据=========================================================
PosList = get_trade_detail_data(account,'stock','position')
for pos in PosList:
Symbol = pos.m_strInstrumentID + '.' + pos.m_strExchangeID # 组合成 600225.SH 这样的字符串
if Symbol not in g.StockList:
continue
g.StockPos[Symbol]["持股总数量"] = pos.m_nVolume
g.StockPos[Symbol]["可用数量"] = pos.m_nCanUseVolume
#--------刷新行情报价的数据 ---------------------------------------------------
m5Data = ContextInfo.get_market_data_ex(
['close'],
g.StockList,
period = '5m',
count = 1,
subscribe = True
)
for Symbol in g.StockList:
g5mD_stime = g.m5Data[Symbol].index.tolist()
m5D_stime = m5Data[Symbol].index.tolist()
if len(m5D_stime) > 0:
if m5D_stime[-1] not in g5mD_stime: # 5m 图表上更新了一根K线
g.m5Data[Symbol] = pd.concat([g.m5Data[Symbol],m5Data[Symbol]])
if m5D_stime[-1] == g5mD_stime[-1]:
g.m5Data[Symbol].iloc[-1] = m5Data[Symbol].iloc[-1]
# ------------计算 MACD 指标 ----------------------------------
closePrice = g.m5Data[Symbol]['close']
closePrice = closePrice.values
macd,signal,hist = talib.MACD(closePrice,fastperiod =12,slowperiod = 26,signalperiod = 9)
g.m5Data[Symbol]['hist'] = hist
# -------根据需求判断 是否 交易了---------------------------------
if not ContextInfo.is_new_bar():
return
if (g.StockPos[Symbol]["持股总数量"] < 100 and
g.m5Data[Symbol]["hist"].iloc[-3] < 0 and
g.m5Data[Symbol]["hist"].iloc[-2] > 0
):
print("当前品种：",Symbol,"MACD 柱子绿翻红了，买入")
passorder(23,1101,account,Symbol,5,0,100,"1",1,"1",ContextInfo)
if (g.StockPos[Symbol]["可用数量"] >= 100 and
g.m5Data[Symbol]["hist"].iloc[-3] > 0 and
g.m5Data[Symbol]["hist"].iloc[-2] < 0
):
print("当前品种：",Symbol,"MACD 柱子红翻绿了，卖出")
passorder(24,1101,account,Symbol,5,0,100,"1",1,"1",ContextInfo)
print("程序完成一次执行任务。")
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124