vn.py

基于python的开源交易平台开发框架

19635 人关注

最新文章

华尔街见闻成为vn.py项目的战略合作伙伴
随着vn.py项目的快速发展，社区成员变得越来越多样，也逐渐出现了一些全新的需求，例如项目学习培训、历史行情数据、特定策略的专用交易通道、文档的编写和维护等等。但是…查看全文
用python的交易员
7 days ago
51 赞5 条评论
用Python的交易员的Live--vn.py的过去、现在和将来
我是用 python 的交易员，知乎Python和量化交易话题的优秀回答者，金融工程硕士，目前在均直资产担任期权业务主管。同时我也是开源量化交易框架vn.py的作者，项目目前是国…查看全文
用python的交易员
a month ago
32 赞9 条评论
vn.py发布v1.6.2
过去两个月发布的v1.6和v1.6.1给大家带来了很多困扰，主要是因为项目规模扩大后模块间依旧采用的Python隐式相对引用的Import方式，对运行时的目录很敏感，对于不熟悉Python…查看全文
用python的交易员
2 months ago
93 赞52 条评论
vn.py发布v1.6
之前v1.6预定的是Spread Trading模块的开发，不过因为两个商品期权上市的关系最近比较忙，就选择在v1.6里提前了英文版翻译的开发，接下来的v1.7将会是Spread Trading。目前…查看全文
用python的交易员
3 months ago
36 赞22 条评论
突破GIL...... - 转载 - Quicklib 源码分析 3、4
写在前面星期天又快结束了，好久没有一个周末的情绪如此跌宕起伏，从开始对于技术研究方面的期待，到目前对于Quicklib作者一些行为的懵逼.这次直接合并发完金融民工对于Qui…查看全文
用python的交易员
3 months ago
64 赞21 条评论
突破GIL？? - 转载 - Quicklib 源码分析 2
提示：干货分析在第二段和第三段，想节省时间的朋友可以跳过第一段。写在前面周末陪家人出去玩了一天，回来后看到Quicklib的作者在我的两篇文章下发了不少重复的评论，简单…查看全文
用python的交易员
4 months ago
17 赞40 条评论
突破GIL？！ - 转载 - Quicklib 源码分析 1
写在前面昨天文章中提到过的Quicklib的事情，目前整个情况的发展有点超出我的预期，Quicklib的作者早上很快发出了第二篇文章：Quicklib对VNPY团队贬低回应和异步IO与传统架…查看全文
用python的交易员
4 months ago
31 赞36 条评论
什么？有人解决了Python最难的问题GIL！还用来做高频交易？！
申明事情起源于这篇文章：Quicklib对VNPY团队贬低回应和异步IO与传统架构性能对比 - 知乎专栏Quicklib利用Python特点，在底层驱动上采用了异步IO来替代多线程，使得底层没…查看全文
用python的交易员
4 months ago
219 赞64 条评论
vn.py发布v1.5
标题图片里的是本人挺喜欢的一个威士忌牌子：强尼遛弯，而曲折不平的道路挺符合最近几个月开发v1.5时遇到的情况，当协作的团队成员数量上升时你会面对很多原本不存在的挑战…查看全文
用python的交易员
4 months ago
80 赞21 条评论
用Python的交易员的Live--阅读：交易员的内功修炼
我是用 python 的交易员，vn.py 作者，懂点交易，懂点编程。在平时的工作和社交中，经常遇到一些朋友为了如何提高自己在交易方面的内功而烦恼：有些是想要毕业后从事交易…查看全文
用python的交易员
5 months ago
30 赞4 条评论
vn.py文档编写计划
鸡年的第一篇文章，给各位读者拜个年，祝大家新的一年身体健康，全家幸福～需求之前在vn.py项目2017年计划里面提到，如果对vn.py社区用户们的需求情况做个排序，项目文档绝…查看全文
用python的交易员
6 months ago
85 赞27 条评论
开箱即用的开源云端量化交易平台 —— 写在vn.py v1.4发布之际
开箱即用想想还是在开头声明下：这一段是帮量衍投资做的一个产品广告，一是感谢量衍对于vn.py社区做出的贡献，二是也确实觉得这个产品对于很多用户有价值（尤其是新手）。…查看全文
用python的交易员
6 months ago
143 赞40 条评论
2017年vn.py项目计划
去年初写2016年项目计划的情景还历历在目，眨眼就一年过去了，vn.py项目在2016年的成长速度远远超出了我的预期。截止写这篇文章的2017年1月7日，vn.py项目在Github上收获了…查看全文
用python的交易员
7 months ago
205 赞45 条评论
vnpy接收行情数据性能测试与改进优化
近来，量化交易平台vnpy因其开源、功能强大、开发容易、可定制性强的特点，目前已经被广泛应用在量化交易中。行情数据落地是量化交易平台必须解决的一个基础问题，它有两个方面的作用：一…查看全文
Jerry He
7 months ago
38 赞13 条评论
vn.py项目开通捐赠
vn.py项目两岁啦，感谢社区一直以来的热情支持，没有你们就没有今天的vn.py！最近提出希望捐赠的朋友挺多，决定开始接受捐赠。现阶段计划将收到的全部捐赠资金都投入到vn.p…查看全文
用python的交易员
7 months ago
61 赞20 条评论
vn.trader的tick-to-trade延时测试
原创文章，转载请注明出处：用Python的交易员tick-to-trade延时对于量化交易平台而言，最重要的技术指标之一就是所谓的tick-to-trade延时，即从底层API收到一个tick行情推…查看全文
用python的交易员
8 months ago
52 赞29 条评论
百倍加速！Python量化策略的算法性能提升指南
原创文章，转载请注明出处：用Python的交易员性能问题Python在2016年里可以说是风靡国内量化投资圈，目前整个生态链已经初具规模：交易：vn.py、easytrader、at_py数据：tu…查看全文
用python的交易员
8 months ago
883 赞56 条评论
用Python的交易员的Live--外汇交易，那些 MT4 背后的东西
我是陈晓优，知乎网名：用 Python 的交易员，现在均直资产担任期权部门主管。我在业余时间维护了一款针对国内市场的开源量化交易平台开发框架 vn.py ，目前是国内用户最多…查看全文
用python的交易员
8 months ago
90 赞14 条评论
vn.py发布v1.2
标题里的是vn.py的v1.2中基于多进程（multiprocessing）模块并行优化参数时把CPU跑满的截图，从此CPU几百核的土豪们可以节约大把时间享受人生了。距离上一个版本v1.1的发布…查看全文
用python的交易员
9 months ago
147 赞23 条评论
用python的交易员的 Live －－聊聊期权交易
我是陈晓优，知乎网名：用 Python 的交易员，现在均直资产担任期权部门主管。我在业余时间维护了一款针对国内市场的开源量化交易平台开发框架 vn.py，目前是国内用户最多…查看全文
用python的交易员
10 months ago
119 赞12 条评论

{"database":{"Post":{"22713839":{"title":"用python的交易员的 Live －－聊聊期权交易","author":"traderusingpython","content":"我是陈晓优，知乎网名：用 Python 的交易员，现在均直资产担任期权部门主管。 我在业余时间维护了一款针对国内市场的开源量化交易平台开发框架 vn.py，目前是国内用户最多的量化金融开源项目之一。<br><br>之前在知乎做了两次Live，非常感谢广大知友的支持，整体上反响都挺积极的，接下来打算把自己的Live做成一个系列，从个人的角度和大家分享一些量化交易领域的见闻。之前聊过了编程语言和量化入门，现在该讲讲具体的交易了。因为本职工作的关系，平时经常有人问我一些关于期权交易的问题，但是由于期权作为非线性衍生品的复杂性，只言片语的解答往往使得提问者感觉云里雾里，比提问前更加迷糊。自从50ETF期权在2015年2月上市以来，中国的期权市场已经快走过了两个年头，而vn.py项目也脱胎于我自己的期权交易系统，所以决定这次Live的主题就来聊聊期权交易。<br><br>网上介绍期权的资料不少，但是大部分都过分强调公式和理论，催眠效果十分优良。那么在本次的 Live 中，我打算从市场参与者的角度来和大家来分享一些自己在国内期权市场上的知识和经验：<br><ul><li>非线性衍生品的特点，不要把期权当作期货或者股票来做交易</li><li>数量化的分析方法：定价公式和希腊值</li><li>\n\n期权交易的核心：波动率和Gamma Scalping</li><li>期权在投资组合中的战略价值</li></ul><br>本次Live主要定位于一场针对期权新手的快速入门课，如果你有着以下的需求，相信我的 Live 会让你有所收获：<br><ul><li>金融相关专业的在校大学生，希望毕业后能够从事期权相关的研究和交易工作<br></li><li>传统的主观投资者，希望通过期权交易来提高自己的投资组合业绩，降低持仓风险</li><li>期货和股票方面的量化投资者，希望进一步扩展自己的交易策略引入期权这一全新的交易品种</li></ul><br>【传送门】<a href=\"https://www.zhihu.com/lives/765200230466465792?utm_campaign=zhihulive&amp;utm_source=zhihucolumn&amp;utm_medium=Livecolumn\" data-editable=\"true\" data-title=\"https://www.zhihu.com/lives/765200230466465792\" class=\"\">https://www.zhihu.com/lives/765200230466465792</a><br><br><br><br><br>版权声明：讲者在本产品上发表的全部原创内容（包括但不限于文字、音频、图片等）著作权均归讲者本人所有。未经讲者授权许可，听众用户不得以任何载体或形式使用讲者的内容。","updated":"2016-09-30T07:28:42.000Z","canComment":false,"commentPermission":"anyone","commentCount":12,"likeCount":119,"state":"published","isLiked":false,"slug":"22713839","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2016-09-30T15:28:42+08:00","links":{"comments":"/api/posts/22713839/comments"},"url":"/p/22713839","titleImage":"https://pic2.zhimg.com/v2-211152e51c410be299c9aad69ecb63dd_r.png","summary":"","href":"/api/posts/22713839","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":12,"likesCount":119},"23399539":{"title":"vn.py发布v1.2","author":"traderusingpython","content":"标题里的是vn.py的v1.2中基于多进程（multiprocessing）模块并行优化参数时把CPU跑满的截图，从此CPU几百核的土豪们可以节约大把时间享受人生了。<p>距离上一个版本v1.1的发布过去4个月后终于完成了v1.2，主要增加的功能：</p><h2><b><u>vn.rpc模块</u></b></h2><p>实现客户端到服务端的跨进程函数调用，同时支持服务端向客户端推送数据。有了这个模块后，可以大幅简化很多用户想要的GUI和引擎分离、网页端界面监控、大运算量策略独立运行、分布式架构等等功能的实现。</p><br><h2><b><u>vn.shzd和vn.ib接口</u></b></h2><p>直达期货的接口封装vn.shzd已经介入vn.trader，直达属于一家专业度较高的外盘期货经纪商，在速度和技术服务方面有一定的优势，国内很多大型机构偏好使用他们的通道。</p><p>初步完成了Interactive Brokers API的封装接口vn.ib，和IbPy相比的一些不同点：</p><ol><li><p>vn.ib基于Boost.Python封装了原生Posix C++接口，比起IbPy能提供更好的性能</p></li><li><p>vn.ib底层代码中添加了异常捕捉功能，避免IbPy的函数触发异常后没有报错直接断开连接，导致无法调试的问题</p></li><li><p>vn.ib安装时可能需要编译（默认的pyd在Windows7 Python 2.7 32位下编译），IbPy是纯Python的可以直接使用</p></li><li><p>vn.ib基于较新的IB官方API（9.72 beta）开发，IbPy则是采用了较老的API（9.70 stable）</p></li></ol><br><h2><b><u>增强CTA策略模块</u></b></h2><p>基于社区用户的反馈，增加了一些vn.trader中CTA模块（ctaAlgo）的功能：</p><p>1. 支持多进程参数优化，会自动根据电脑CPU的核心数量启动对应的进程池，大幅提高运算速度减少优化所需的时间，同时保持新优化函数和之前的一致性。</p><p>2. CTA实盘策略引擎提供对策略函数运行时的容错功能，避免出现因为某个策略逻辑有误导致整个系统在盘中被挂住或者崩溃的情况，发生异常时引擎会自动捕捉输出在监控界面上，并停止该策略的运行。</p><br><h2><b><u>其他</u></b></h2><ol><li>修改vn.trader中的路径配置方案，允许用户从任意目录启动交易平台（之前必须从vn.trader目录下启动，否则可能找不到模块文件），方便开发和Debug。<br></li><li>修复了一些社区提出的小改进点以及bug。<br></li></ol><br><h2><b><u>v1.3计划</u></b></h2><p>1. vn.ib接口替换掉IbPy接入到vn.trader中</p><p>2. 提供中泰证券的XTP柜台接口封装vn.xtp</p><p>3. 考虑接入LMAX外汇交易平台（真正的外汇交易所）的接口</p>","updated":"2016-11-03T08:57:35.000Z","canComment":false,"commentPermission":"anyone","commentCount":23,"likeCount":147,"state":"published","isLiked":false,"slug":"23399539","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2016-11-03T16:57:35+08:00","links":{"comments":"/api/posts/23399539/comments"},"url":"/p/23399539","titleImage":"https://pic4.zhimg.com/v2-b796223d1b3386165526303a8bd01813_r.png","summary":"","href":"/api/posts/23399539","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":23,"likesCount":147},"23678646":{"title":"用Python的交易员的Live--外汇交易，那些 MT4 背后的东西","author":"traderusingpython","content":"<p>我是陈晓优，知乎网名：用 Python 的交易员，现在均直资产担任期权部门主管。 我在业余时间维护了一款针对国内市场的开源量化交易平台开发框架 vn.py ，目前是国内用户最多的量化金融开源项目之一。</p><p>我本人差不多从十年前开始接触零售外汇交易（也是大部分人所谓的外汇投资），可以说是我作为一名交易员的职业生涯的起点，尽管由于各种原因现在每天交易工作的重心不在外汇上，也还是一直在关注着这个行业。在知乎上投资、交易相关的话题下，最常见的一类就是关于零售外汇交易的问题：某家外汇经纪商是否靠谱、某种技术分析方法是否有效、某个宏观经济事件对市场会有什么影响、 MT4 平台怎么写策略等等，其中还有不计其数的垃圾小广告。</p><p>诚然零售外汇交易在一定程度上推动了中国金融市场的发展（比如国内最早被人们所了解的程序化交易方式之一就是 MT4 平台上的 EA ），但是鱼龙混杂的整个行业环境也让大部分市场参与者摸不清其中的门道，所以我希望通过这次的 Live 来对零售外汇交易行业做一个比较系统化的介绍。听完这个 Live ，未必能让你掌握一劳永逸的「盈利圣杯」，但是一定可以帮你避开许多看起来充满诱惑的「致命陷阱」。在本次 Live 中，我会结合自己过去作为个人投资者和现在作为机构交易员的经验，通过从上至下的方式来介绍零售外汇交易这个行业。<br></p><br><p>本次 Live 主要包括以下内容： </p><ul><li>外汇市场的结构：每个参与者（央行、投行、高频交易公司、对冲基金、外汇经纪商、个人投资者）的生存方式是怎样的？ <br></li><li>外汇经纪商：经纪商的分类（ MM 、 STP 、 ECN 、 MTF ）是怎样的？ <br></li><li>MM 究竟是否靠坑客户来盈利？ <br></li><li>ECN 真的允许散户挂的单子进入市场么，如何分辨靠谱的经纪商？ <br></li><li>外汇交易软件（平台）： MT4 、 MT5 、 cTrader 、 API 、 FIX 、开源平台，哪个才应该是你的菜？ </li><li>国内现状：网上常见的各种外汇广告可信度有多少？ <br></li><li>国内资管行业对于各种外汇交易策略（短线、宏观交易、 CTA 、套利等）的观点何如？ <br></li><li>零售外汇交易中的坑：高杠杆、浮动点差、频繁断线、无法平仓等等<br></li></ul><br><p>【传送门】<a href=\"https://www.zhihu.com/lives/781853559883825152?utm_campaign=zhihulive&amp;utm_source=zhihucolumn&amp;utm_medium=Livecolumn\" class=\"\">https://www.zhihu.com/lives/781853559883825152?utm_campaign=zhihulive&amp;utm_source=zhihucolumn&amp;utm_medium=Livecolumn</a></p>","updated":"2016-11-15T06:03:29.000Z","canComment":false,"commentPermission":"anyone","commentCount":14,"likeCount":90,"state":"published","isLiked":false,"slug":"23678646","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2016-11-15T14:03:29+08:00","links":{"comments":"/api/posts/23678646/comments"},"url":"/p/23678646","titleImage":"https://pic4.zhimg.com/v2-755d049a5b53dbfb1dc0c50db0d2b267_r.jpg","summary":"","href":"/api/posts/23678646","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":14,"likesCount":90},"24168485":{"title":"百倍加速！Python量化策略的算法性能提升指南","author":"traderusingpython","content":"<p>原创文章，转载请注明出处：用Python的交易员</p><h3>性能问题</h3><p>Python在2016年里可以说是风靡国内量化投资圈，目前整个生态链已经初具规模：</p><ul><li>交易：vn.py、easytrader、at_py</li><li>数据：tushare</li><li>回测：rqalpha</li><li>在线平台：UQER、RiceQuant、JoinQuant</li></ul><p>随着用户越来越多，Python语言的性能问题也就逐渐成为整个社区关注的重点，经常遇到新手问：Python写的量化交易程序是不是很慢啊？</p><p>在他们心中，Python估计是这个样子：</p><img src=\"v2-00a331c182582a6754b01853d57fcebe.jpg\" data-rawwidth=\"473\" data-rawheight=\"309\"><p>（即使作为破旧自行车，我也深表怀疑这辆能不能骑好吧）</p><p>网上关于如何提升Python程序性能的文章不少，但大多不成体系只是非常简单的例子，总有点隔靴搔痒的感觉，和现实中应用的距离比较远。</p><p>作者一看，填补市场空白（装逼）的机会来了！！</p><p><strong>在这篇文章里，将会通过实际的例子展示如何对一段量化策略常用的代码实现百倍加速。</strong></p><img src=\"v2-9d5c7ce2be2c342eacfccf785c1dc5af.jpg\" data-rawwidth=\"401\" data-rawheight=\"193\"><h3>一段常用的代码</h3><p>接下来要用的例子相信几乎所有做量化策略的人都写过类似的代码：对时间序列求算术移动平均值。</p><p>这里我们先初始化即将用到的数据：10万个数据点（随机整数），遍历计算窗口为500的算术移动平均值，每种算法运行10次求平均耗时。</p><br><code lang=\"python\"># 这个测试目标在于仿造一个类似于实盘中，不断有新的数据推送过来，\n# 然后需要计算移动平均线数值，这么一个比较常见的任务。\n\nfrom __future__ import division\nimport time\nimport random\n\n# 生成测试用的数据\ndata = []\ndata_length = 100000    # 总数据量\nma_length = 500         # 移动均线的窗口\ntest_times = 10         # 测试次数\n\nfor i in range(data_length):\n    data.append(random.randint(1, 100))\n</code><p>在每次测试中，我们都通过遍历测试用数据的方式来模拟实盘中策略不断收到新数据推送的情况（同样适用于事件驱动的回测模式），将计算出的移动平均值不断保存到一个列表list中作为最终结果返回。</p><p>测试用电脑的配置情况：Core i7-6700K 4.0G/16G/Windows 7。</p><p>第一步我们以最简单、最原始的方式来计算移动平均值：</p><br><code lang=\"python\"># 计算500期的移动均线，并将结果保存到一个列表里返回\ndef ma_basic(data, ma_length):\n\n    # 用于保存均线输出结果的列表\n    ma = []\n\n    # 计算均线用的数据窗口\n    data_window = data[:ma_length]\n\n    # 测试用数据（去除了之前初始化用的部分）\n    test_data = data[ma_length:]\n\n    # 模拟实盘不断收到新数据推送的情景，遍历历史数据计算均线\n    for new_tick in test_data:\n        # 移除最老的数据点并增加最新的数据点\n        data_window.pop(0)\n        data_window.append(new_tick)\n\n        # 遍历求均线\n        sum_tick = 0\n        for tick in data_window:\n            sum_tick += tick\n        ma.append(sum_tick/ma_length)\n\n    # 返回数据\n    return ma\n\n# 运行测试\nstart = time.time()\n\nfor i in range(test_times):\n    result = ma_basic(data, ma_length)\n\ntime_per_test = (time.time()-start)/test_times\ntime_per_point = time_per_test/(data_length - ma_length)\n\nprint u'单次耗时：%s秒' %time_per_test\nprint u'单个数据点耗时：%s微秒' %(time_per_point*1000000)\nprint u'最后10个移动平均值：', result[-10:]\n</code><p>单次耗时指的是遍历完整个测试数据计算移动平均值所需的时间，单个数据点耗时指的是遍历过程中每个数据点的平均计算耗时，最后10个移动平均值用于和后续的算法进行比对，保证计算结果的正确性。</p><p><strong>ma_basic测试结果</strong></p><ul><li>单次耗时：1.15699999332秒</li><li>单个数据点耗时：11.6281406364微秒</li></ul><p>大约10万个数据点（说大约因为有500个用于初始化了），这个测试结果不能说很好但也还过得去。考虑到一个简单的双均线CTA策略（Double SMA Strategy），每个数据点来了后会进行两次均线计算，通常均线窗口不会超过500，且比较两根均线交叉情况的算法开销更低，估计策略单纯在信号计算方面的耗时会在30微秒以内，对于一个通常跑在1分钟线甚至更高时间周期上的策略而言已经是绰绰有余。</p><p>有了起点，下面来试着一步步提升性能。</p><h3>试试NumPy？</h3><p>用Python做数值运算性能不够的时候，很多人的第一反应就是上NumPy：之前的ma_basic里，比较慢的地方应该在每一个新的数据点加入到data_window中后遍历求平均值的代码，那么改用numpy.array数组来求和应该性能就会有所提升了吧？</p><br><code lang=\"python\"># 改用numpy（首先是一种常见的错误用法）\nimport numpy as np\n\ndef ma_numpy_wrong(data, ma_length):\n    ma = []\n    data_window = data[:ma_length]\n    test_data = data[ma_length:]\n\n    for new_tick in test_data:\n        data_window.pop(0)\n        data_window.append(new_tick)\n\n        # 使用numpy求均线，注意这里本质上每次循环\n        # 都在创建一个新的numpy数组对象，开销很大\n        data_array = np.array(data_window)\n        ma.append(data_array.mean())\n\n    return ma\n</code><p><strong>ma_numpy_wrong测试结果</strong></p><ul><li>单次耗时：2.11879999638秒</li><li>单个数据点耗时：21.2944723254微秒</li></ul><img src=\"v2-601876b8d700b681e10203d419d2c063.jpg\" data-rawwidth=\"528\" data-rawheight=\"235\"><p>WTF?!用NumPy后居然反而速度降低了一半（耗时增加到了快2倍）！</p><p>这里的写法是一个非常常见的NumPy错误用法，问题就出在：</p><blockquote><p>data_array = np.array(data_window)</p></blockquote><p>由于NumPy中的对象大多实现得比较复杂（提供了丰富的功能），所以其对象创建和销毁的开销都非常大。上面的这句代码意味着在计算每一个新数据点时，都要创建一个新的array对象，并且仅使用一次后就会销毁，使用array.mean方法求均值带来的性能提升还比不上array对象创建和销毁带来的额外开销。</p><p>正确的用法是把np.array作为data_window时间序列的容器，每计算一个新的数据点时，使用底层数据偏移来实现数据更新：</p><br><code lang=\"python\"># numpy的正确用法\ndef ma_numpy_right(data, ma_length):\n    ma = []\n\n    # 用numpy数组来缓存计算窗口内的数据\n    data_window = np.array(data[:ma_length])\n\n    test_data = data[ma_length:]\n\n    for new_tick in test_data:\n        # 使用numpy数组的底层数据偏移来实现数据更新\n        data_window[0:ma_length-1] = data_window[1:ma_length]\n        data_window[-1] = new_tick\n        ma.append(data_window.mean())\n\n    return ma\n</code><p><strong>ma_numpy_right测试结果</strong></p><ul><li>单次耗时：0.614300012589秒</li><li>单个数据点耗时：6.17386947325微秒</li></ul><p>速度比ma_basic提高了大约2倍，看来NumPy也就这么回事了。</p><h3>JIT神器：Numba</h3><p>关心过Python性能的朋友应该都听过PyPy的大名，通过重新设计的Python解释器，PyPy内建的JIT技术号称可以将Python程序的速度提高几十倍（相比于CPython），可惜由于兼容性的问题并不适合于量化策略开发这一领域。</p><p>幸运的是，我们还有Anaconda公司推出的Numba。Numba允许用户使用基于LLVM的JIT技术，对程序内想要提高性能的部分（函数）进行局部优化。同时Numba在设计理念上更加务实：可以直接在CPython中使用，和其他常用的Python模块的兼容性良好，并且最爽的是使用方法傻瓜到了极点：</p><br><code lang=\"python\"># 使用numba加速，ma_numba函数和ma_basic完全一样\nimport numba\n\n@numba.jit\ndef ma_numba(data, ma_length):\nma = []\ndata_window = data[:ma_length]\ntest_data = data[ma_length:]\n\nfor new_tick in test_data:\n    data_window.pop(0)\n    data_window.append(new_tick)\n    sum_tick = 0\n    for tick in data_window:\n        sum_tick += tick\n    ma.append(sum_tick/ma_length)\n\nreturn ma\n</code><p><strong>ma_numba测试结果</strong></p><ul><li>单次耗时：0.043700003624秒</li><li>单个数据点耗时：0.439196016321微秒</li></ul><p>OMG！就加了一行@numba.jit，性能竟然提高了26倍！这估计是按照代码修改行数算，性价比最高的优化方案了。</p><h3>改写算法</h3><p>从编程哲学的角度来看，想提高计算机程序的速度，一个最基本的原则就是降低算法复杂度。看到这里估计早就有量化老手ma_basic不爽了，弄个复杂度O(N)的算法来算平均值，就不能缓存下求和的结果，把复杂度降低到O(1)么？</p><br><code lang=\"text\"># 将均线计算改写为高速算法\ndef ma_online(data, ma_length):\n    ma = []\n    data_window = data[:ma_length]\n    test_data = data[ma_length:]\n\n    # 缓存的窗口内数据求和结果\n    sum_buffer = 0\n\n    for new_tick in test_data:\n        old_tick = data_window.pop(0)\n        data_window.append(new_tick)\n\n        # 如果缓存结果为空，则先通过遍历求第一次结果\n        if not sum_buffer:\n            sum_tick = 0\n            for tick in data_window:\n                sum_tick += tick\n            ma.append(sum_tick/ma_length)\n\n            # 将求和结果缓存下来\n            sum_buffer = sum_tick\n        else:\n            # 这里的算法将计算复杂度从O(n)降低到了O(1)\n            sum_buffer = sum_buffer - old_tick + new_tick\n            ma.append(sum_buffer/ma_length)\n\n    return ma\n</code><p><strong>ma_online测试结果</strong></p><ul><li>单次耗时：0.0348000049591秒</li><li>单个数据点耗时：0.349748793559微秒</li></ul><p>哲学果然才是最强大的力量！！！</p><img src=\"v2-c20a996c1c30899213eecded7d15a148.jpg\" data-rawwidth=\"492\" data-rawheight=\"300\"><p>(索罗斯：其实我是个哲学家。)</p><p>改写算法后的ma_online无需JIT就超越了ma_numba，将性能提高到了33倍（对比ma_basic），如果再把numba加上会如何？</p><br><code lang=\"python\"># 高速算法和numba结合，ma_online_numba函数和ma_online完全一样\n@numba.jit\ndef ma_online_numba(data, ma_length):\n    ma = []\n    data_window = data[:ma_length]\n    test_data = data[ma_length:]\n\n    sum_buffer = 0\n\n    for new_tick in test_data:\n        old_tick = data_window.pop(0)\n        data_window.append(new_tick)\n\n        if not sum_buffer:\n            sum_tick = 0\n            for tick in data_window:\n                sum_tick += tick\n            ma.append(sum_tick/ma_length)\n            sum_buffer = sum_tick\n        else:\n            sum_buffer = sum_buffer - old_tick + new_tick\n            ma.append(sum_buffer/ma_length)\n\n    return ma\n</code><p><strong>ma_online_numba测试结果</strong></p><ul><li>单次耗时：0.0290000200272秒</li><li>单个数据点耗时：0.29145748771微秒</li></ul><p>尽管性能进一步提升了到了40倍，不过相比较于ma_numba对比ma_basic的提升没有那么明显，果然哲学的力量还是太强大了。</p><h3>终极武器：Cython</h3><p>到目前为止使用纯Python环境下的优化方法我们已经接近了极限，想要再进一步就得发挥Python胶水语言的特性了：使用其他扩展语言。由于CPython虚拟机的开发语言是C，因此在性能提升方面的扩展语言主要选择就是C/C++，相关的工具包括ctypes、cffi、Swig、Boost.Python等，尽管功能十分强大，不过以上工具都无一例外的需要用户拥有C/C++语言相关的编程能力，对于很多Python用户而言是个比较麻烦的事。</p><p>好在Python社区对于偷懒的追求是永无止境的，Cython这一终极武器应运而生。关于Cython的详细介绍可以去<a href=\"http://www.cython.org/\" data-editable=\"true\" data-title=\"官网\">官网</a>看，简单来它的主要作用就是允许用户以非常接近Python的语法来实现非常接近C的性能。</p><p>先来试试最简单的方法：完全不修改任何代码，只是把函数放到.pyx文件里，调用Cython编译成.pyd扩展模块。</p><br><code lang=\"python\"># 基础的cython加速\ndef ma_cython(data, ma_length):\n    ma = []\n    data_window = data[:ma_length]\n    test_data = data[ma_length:]\n\n    for new_tick in test_data:\n        data_window.pop(0)\n        data_window.append(new_tick)\n\n        sum_tick = 0\n        for tick in data_window:\n            sum_tick += tick\n        ma.append(sum_tick/ma_length)\n\n    return ma\n</code><p><strong>ma_cython测试结果</strong></p><ul><li>单次耗时：0.600800013542秒</li><li>单个数据点耗时：6.03819109088微秒</li></ul><p>ma_cython和ma_basic的代码完全相同，简单使用Cython编译后性能提高了大约1倍，不过这和之前我们已经达成的优化效果比可以说是毫无吸引力。</p><p>Cython官方的Quick Start里，第一步是教会用户如何去编译程序，第二步就是如何使用静态声明来大幅提高性能，所以我们的下一步就是：静态声明+高速算法。</p><br><code lang=\"python\"># cython和高速算法\ndef ma_cython_online(data, ma_length):\n    # 静态声明变量\n    cdef int sum_buffer, sum_tick, old_tick, new_tick\n\n    ma = []\n    data_window = data[:ma_length]\n    test_data = data[ma_length:]\n    sum_buffer = 0\n\n    for new_tick in test_data:\n        old_tick = data_window.pop(0)\n        data_window.append(new_tick)\n\n        if not sum_buffer:\n            sum_tick = 0\n            for tick in data_window:\n                sum_tick += tick\n            ma.append(sum_tick/ma_length)\n\n            sum_buffer = sum_tick\n        else:\n            sum_buffer = sum_buffer - old_tick + new_tick\n            ma.append(sum_buffer/ma_length)\n\n    return ma\n</code><p><strong>ma_cython_online测试结果</strong></p><ul><li>单次耗时：0.00980000495911秒</li><li>单个数据点耗时：0.0984925121518微秒</li></ul><img src=\"v2-52ea5a40a60e4dd2274ee57795a914bb.jpg\" data-rawwidth=\"600\" data-rawheight=\"400\"><p>117倍！！！比ma_online_numba的速度还提高了接近3倍，98纳秒的计算速度已经足以满足大部分毫秒级别高频策略的延时需求。</p><p>主要的功臣是这行：</p><blockquote><p>cdef int sum_buffer, sum_tick, old_tick, new_tick</p></blockquote><p>把函数中用到的变量静态声明成int类型后，Cython在编译时无需再考虑Python对象的动态性特点，可以把整个函数高度优化成类似静态语言的实现，从而达到了接近C语言的运行性能，再加上复杂度O(1)的高速算法，有这个级别的性能提升也就不足为奇了。</p><p>附上简单的Cython使用指南：</p><ol><li>把要使用Cython编译的函数放到.pyx文件中，比如test.pyx</li><li>创建setup.py用于设置相关编译选项</li><li>打开cmd或者terminal进入到test.pyx和setup.py所在的文件夹</li><li>运行<strong>python setup.py build_ext --inplace</strong>，执行编译</li><li>若编译成功则在当前文件夹下会出现test.pyd</li><li>打开python像使用其他模块一样载入（import）test.pyd使用</li></ol><h3>写在最后</h3><p>感谢Numba、Cython和哲学的强大力量，作者最终装逼成功，从自己挖的“百倍加速”这个坑里爬了出来，不用当标题党了。</p><p>最终的算法性能对比图：</p><img src=\"v2-649260f639cf8244e31c55112346d0e3.png\" data-rawwidth=\"696\" data-rawheight=\"456\"><p>最后做一些总结吧：</p><ol><li>现实工作中遇到需要优化Python程序性能时，首先要做的就是去寻找程序里延时较大的热点代码，找到了问题所在，解决方案才有意义；</li><li>所有的优化工作都应该基于测试来一步步推进，同样的优化方法对于不同类型的代码效果可能是截然相反的，同时错误的优化方法还不如不要优化（比如ma_numpy_wrong）；</li><li>只需增加一句代码（@numba.jit）就能实现加速的Numba无疑是性价比最高的优化方案，值得优先尝试，不过需要注意numba的JIT技术局限性比较大（主要针对数值计算相关的逻辑）；</li><li>学习如何降低算法复杂度和编写更高效的算法，可以在潜移默化中提高自己的编程水平，在长期而言是对Quant或者程序员最有价值的优化方法；</li><li>如果其他优化方法都无法达到令你满意的性能水平，试试Cython（记得一定要加静态声明）;</li><li>一个好的程序架构设计非常重要，把功能不同的计算逻辑分解到不同的函数里，适当降低每个函数的代码行数，会有助于后期的性能优化工作。</li></ol><h2>文章中的所有代码以及测试用的Jupyter Notebook都可以在<a href=\"https://github.com/vnpy/vnpy/tree/dev/vn.how\" data-editable=\"true\" data-title=\"vn.py项目的Github仓库\">vn.py项目的Github仓库</a>下载，记得点Star!</h2>","updated":"2016-12-04T15:17:51.000Z","canComment":false,"commentPermission":"anyone","commentCount":56,"likeCount":883,"state":"published","isLiked":false,"slug":"24168485","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2016-12-04T23:17:51+08:00","links":{"comments":"/api/posts/24168485/comments"},"url":"/p/24168485","titleImage":"https://pic4.zhimg.com/v2-649260f639cf8244e31c55112346d0e3_r.png","summary":"","href":"/api/posts/24168485","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":56,"likesCount":883},"24242972":{"title":"vn.trader的tick-to-trade延时测试","author":"traderusingpython","content":"<p>原创文章，转载请注明出处：用Python的交易员</p><h3>tick-to-trade延时</h3><p>对于量化交易平台而言，最重要的技术指标之一就是所谓的tick-to-trade延时，即从底层API收到一个tick行情推送的tick_time，到平台内部处理完毕再调用底层API发出委托的trade_time，中间所耗费的时间。</p><p>通常出于纯粹测试平台性能的目的，会采用收到行情后不进行任何策略逻辑计算，立即发出委托的方式来实现。考虑目前vn.trader的用户群中最常见的情景，本文中使用Windows系统和CTP接口来进行测试。</p><p>为了实现这种精度比较高的延时测试，需要在底层的C++ API相关的封装中加入计时相关的代码，这里选择用Windows系统提供的QueryPerformanceCounter和QueryPerformanceFrequency函数，具体可以参考<a href=\"http://blog.csdn.net/nancy_m/article/details/9621221\" data-editable=\"true\" data-title=\"这篇文章\">这篇文章</a>。</p><h3>在MdApi中测量tick_time</h3><p>当行情接口MdApi的行情推送回调函数被触发时，需要立即记录下当前的时间戳。</p><br><code lang=\"cpp\">void MdApi::OnRtnDepthMarketData(CThostFtdcDepthMarketDataField *pDepthMarketData)\n{\n    Task task = Task();\n\n    LARGE_INTEGER t;\n    QueryPerformanceCounter(&amp;t);\n    task.task_time = t.QuadPart;\n    //task.task_time = std::clock();\n\n    task.task_name = ONRTNDEPTHMARKETDATA;\n\n    if (pDepthMarketData)\n    {\n        task.task_data = *pDepthMarketData;\n    }\n    else\n    {\n        CThostFtdcDepthMarketDataField empty_data = CThostFtdcDepthMarketDataField();\n        memset(&amp;empty_data, 0, sizeof(empty_data));\n        task.task_data = empty_data;\n    }\n    this-&gt;task_queue.push(task);\n};\n</code><p>然后在处理C++行情结构体并生成Python字典时，把时间戳和计时频率作为额外的数据放入字典中。</p><br><code lang=\"cpp\">void MdApi::processRtnDepthMarketData(Task task)\n{\n    PyLock lock;\n    CThostFtdcDepthMarketDataField task_data = any_cast&lt;CThostFtdcDepthMarketDataField&gt;(task.task_data);\n    dict data;\n    data[\"HighestPrice\"] = task_data.HighestPrice;\n    data[\"BidPrice5\"] = task_data.BidPrice5;\n    data[\"BidPrice4\"] = task_data.BidPrice4;\n    data[\"BidPrice1\"] = task_data.BidPrice1;\n    data[\"BidPrice3\"] = task_data.BidPrice3;\n    data[\"BidPrice2\"] = task_data.BidPrice2;\n    data[\"LowerLimitPrice\"] = task_data.LowerLimitPrice;\n    data[\"OpenPrice\"] = task_data.OpenPrice;\n    data[\"AskPrice5\"] = task_data.AskPrice5;\n    data[\"AskPrice4\"] = task_data.AskPrice4;\n    data[\"AskPrice3\"] = task_data.AskPrice3;\n    data[\"PreClosePrice\"] = task_data.PreClosePrice;\n    data[\"AskPrice1\"] = task_data.AskPrice1;\n    data[\"PreSettlementPrice\"] = task_data.PreSettlementPrice;\n    data[\"AskVolume1\"] = task_data.AskVolume1;\n    data[\"UpdateTime\"] = task_data.UpdateTime;\n    data[\"UpdateMillisec\"] = task_data.UpdateMillisec;\n    data[\"AveragePrice\"] = task_data.AveragePrice;\n    data[\"BidVolume5\"] = task_data.BidVolume5;\n    data[\"BidVolume4\"] = task_data.BidVolume4;\n    data[\"BidVolume3\"] = task_data.BidVolume3;\n    data[\"BidVolume2\"] = task_data.BidVolume2;\n    data[\"PreOpenInterest\"] = task_data.PreOpenInterest;\n    data[\"AskPrice2\"] = task_data.AskPrice2;\n    data[\"Volume\"] = task_data.Volume;\n    data[\"AskVolume3\"] = task_data.AskVolume3;\n    data[\"AskVolume2\"] = task_data.AskVolume2;\n    data[\"AskVolume5\"] = task_data.AskVolume5;\n    data[\"AskVolume4\"] = task_data.AskVolume4;\n    data[\"UpperLimitPrice\"] = task_data.UpperLimitPrice;\n    data[\"BidVolume1\"] = task_data.BidVolume1;\n    data[\"InstrumentID\"] = task_data.InstrumentID;\n    data[\"ClosePrice\"] = task_data.ClosePrice;\n    data[\"ExchangeID\"] = task_data.ExchangeID;\n    data[\"TradingDay\"] = task_data.TradingDay;\n    data[\"PreDelta\"] = task_data.PreDelta;\n    data[\"OpenInterest\"] = task_data.OpenInterest;\n    data[\"CurrDelta\"] = task_data.CurrDelta;\n    data[\"Turnover\"] = task_data.Turnover;\n    data[\"LastPrice\"] = task_data.LastPrice;\n    data[\"SettlementPrice\"] = task_data.SettlementPrice;\n    data[\"ExchangeInstID\"] = task_data.ExchangeInstID;\n    data[\"LowestPrice\"] = task_data.LowestPrice;\n    data[\"ActionDay\"] = task_data.ActionDay;\n\n    //保存测试时间\n    data[\"tick_time\"] = task.task_time;\n    data[\"frequency_time\"] = this-&gt;t.QuadPart;\n    this-&gt;onRtnDepthMarketData(data);\n};\n</code><h3>在TdApi中测量trade_time</h3><p>行情进入Python环境中处理完毕，会调用底层API发送委托，委托发送成功后需要立即记录当时的时间戳trade_time，并返回到Python环境中从而实现测量tick_time和trade_time之间的延时。</p><br><code lang=\"cpp\">LONGLONG TdApi::reqOrderInsert(dict req, int nRequestID)\n{\n    CThostFtdcInputOrderField myreq = CThostFtdcInputOrderField();\n    memset(&amp;myreq, 0, sizeof(myreq));\n    getChar(req, \"ContingentCondition\", &amp;myreq.ContingentCondition);\n    getStr(req, \"CombOffsetFlag\", myreq.CombOffsetFlag);\n    getStr(req, \"UserID\", myreq.UserID);\n    getDouble(req, \"LimitPrice\", &amp;myreq.LimitPrice);\n    getInt(req, \"UserForceClose\", &amp;myreq.UserForceClose);\n    getChar(req, \"Direction\", &amp;myreq.Direction);\n    getInt(req, \"IsSwapOrder\", &amp;myreq.IsSwapOrder);\n    getInt(req, \"VolumeTotalOriginal\", &amp;myreq.VolumeTotalOriginal);\n    getChar(req, \"OrderPriceType\", &amp;myreq.OrderPriceType);\n    getChar(req, \"TimeCondition\", &amp;myreq.TimeCondition);\n    getInt(req, \"IsAutoSuspend\", &amp;myreq.IsAutoSuspend);\n    getDouble(req, \"StopPrice\", &amp;myreq.StopPrice);\n    getStr(req, \"InstrumentID\", myreq.InstrumentID);\n    getStr(req, \"ExchangeID\", myreq.ExchangeID);\n    getInt(req, \"MinVolume\", &amp;myreq.MinVolume);\n    getChar(req, \"ForceCloseReason\", &amp;myreq.ForceCloseReason);\n    getStr(req, \"BrokerID\", myreq.BrokerID);\n    getStr(req, \"CombHedgeFlag\", myreq.CombHedgeFlag);\n    getStr(req, \"GTDDate\", myreq.GTDDate);\n    getStr(req, \"BusinessUnit\", myreq.BusinessUnit);\n    getStr(req, \"OrderRef\", myreq.OrderRef);\n    getStr(req, \"InvestorID\", myreq.InvestorID);\n    getChar(req, \"VolumeCondition\", &amp;myreq.VolumeCondition);\n    getInt(req, \"RequestID\", &amp;myreq.RequestID);\n\n    int i = this-&gt;api-&gt;ReqOrderInsert(&amp;myreq, nRequestID);\n\n    //延时测试相关\n    LARGE_INTEGER order_time;\n    QueryPerformanceCounter(&amp;order_time);\n    return order_time.QuadPart;\n};\n</code><p>感谢Boost.Python的强大封装功能，可以自动实现long long(LONGLONG)类型到Python整数类型的转换，用户无需另外处理。</p><h3>在Python环境中计算tick-to-trade延时</h3><p>在Python环境中，我们已经通过行情推送的tick字典获取了tick_time，又通过调用发送委托请求后的返回数值获取了trade_time，此时在Python环境中计算两者之间的差值即我们需要的tick_to_trade延时。</p><br><code lang=\"python\">#----------------------------------------------------------------------\ndef orderTest(self, event):\n    \"\"\"\"\"\"\n    tick = event.dict_['data']\n\n    req = VtOrderReq()\n    req.symbol = tick.symbol\n    req.price = tick.lastPrice\n    req.direction = DIRECTION_LONG\n    req.offset = OFFSET_OPEN\n    req.priceType = PRICETYPE_LIMITPRICE\n    req.volume = 1\n\n    order_time = self.sendOrder(req, tick.gatewayName)\n\n    print u'耗时：', (order_time - tick.tick_time)*1000/tick.frequency_time, u'毫秒'\n</code><p>在主引擎MainEngine中添加该事件处理函数，监听所有的EVENT_TICK类型的事件，收到事件推送后立即发送一个开多1手的限价委托。需要注意的是通过QueryPerformanceCounter获取的tick_time和trade_time是系统时间的计数，需要除以计时频率才能转换成具体的时间（秒），乘以1000后转化为毫秒时间。</p><p>以上函数在主引擎初始化时注册到了事件引擎中。</p><br><code lang=\"python\">########################################################################\nclass MainEngine(object):\n    \"\"\"主引擎\"\"\"\n\n    #----------------------------------------------------------------------\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        # 创建事件引擎\n        self.eventEngine = EventEngine2()\n        self.eventEngine.start()\n\n        # 创建数据引擎\n        self.dataEngine = DataEngine(self.eventEngine)\n\n        # MongoDB数据库相关\n        self.dbClient = None    # MongoDB客户端对象\n\n        # 调用一个个初始化函数\n        self.initGateway()\n\n        # 扩展模块\n        self.ctaEngine = CtaEngine(self, self.eventEngine)\n        self.drEngine = DrEngine(self, self.eventEngine)\n        self.rmEngine = RmEngine(self, self.eventEngine)\n\n        self.eventEngine.register(EVENT_TICK, self.orderTest)\n</code><p>注意需要手动在TradingWidget中订阅一些合约来收到tick推送。</p><h3>测试结果</h3><p>作者测试机器配置：Core i7-6700K 4.0G/16G/Windows 7</p><p>测试结果：228个数据点，平均tick_to_trade延时22.6毫秒</p><p>当vn.trader底层的行情接口收到一个新的行情数据推送后，最快差不多只需要百分之二秒的时间就可以完成事件引擎处理，并调用交易接口发出委托。这个速度对于追求微秒级交易延时的超高频策略而言可能无法满足，但对于大部分目标延时在毫秒级以上的常规高频策略应该说是基本没有问题。</p><p>同时考虑到测试时使用的是Windows系统，且带GUI图形界面的形式，其实还存在着相当大的提升空间，有兴趣的朋友不妨自己试试看，欢迎把测试结果分享给我。</p><h3>文章中的所有测试代码可以在<a href=\"https://github.com/vnpy/vnpy/tree/dev/vn.how/tick2trade\" data-editable=\"true\" data-title=\"vn.py项目的Github仓库\">vn.py项目的Github仓库</a>下载。</h3>","updated":"2016-12-07T14:45:09.000Z","canComment":false,"commentPermission":"anyone","commentCount":29,"likeCount":52,"state":"published","isLiked":false,"slug":"24242972","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2016-12-07T22:45:09+08:00","links":{"comments":"/api/posts/24242972/comments"},"url":"/p/24242972","titleImage":"https://pic2.zhimg.com/v2-84ac033596bcd5522b14facd127c19a9_r.jpg","summary":"","href":"/api/posts/24242972","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":29,"likesCount":52},"24662087":{"title":"vnpy接收行情数据性能测试与改进优化","author":"jerry-he-20","content":"近来，量化交易平台vnpy因其开源、功能强大、开发容易、可定制性强的特点，目前已经被广泛应用在量化交易中。 行情数据落地是量化交易平台必须解决的一个基础问题，它有两个方面的作用：一是供策略开发时进行分析、回测；二是为实盘程序时提供近期的历史数据。前者可以通过传统效率更高的实现方式（比如我们有基于C++和leveldb实现的行情数据接收、转发、历史数据获取程序）实现，也可以通过向数据提供方购买获取。但是对于后者，直接基于vnpy落地近期的数据更为简易的方式。<br><p>vnpy包含行情落地模块dataRecorder，已经实现了tick数据、分钟bar数据保存功能。 本工作主要包括：</p><ul><li>vnpy原落地函数的性能考查</li><li>针对CTP接口，原落地函数的修正与优化</li></ul><p>以下所有性能测试时间单位均为毫秒。</p><p>测试基于windows 7, i7 3.4GHz.</p><br>In [1]:<br><code lang=\"text\">from datetime import datetime, time\nimport time as gtime\nimport pymongo\nfrom dateutil.parser import parse\n</code><br><h2>重构vnpy接收行情数据代码，以用于测试</h2><br>In [2]:<br><code lang=\"text\">TICK_DB_NAME='Test'\n\nEMPTY_STRING = ''\nEMPTY_UNICODE = u''\nEMPTY_INT = 0\nEMPTY_FLOAT = 0.0\n\nclass DrTickData(object):\n    \"\"\"Tick数据\"\"\"\n\n    #----------------------------------------------------------------------\n    def __init__(self):\n        \"\"\"Constructor\"\"\"       \n        self.vtSymbol = EMPTY_STRING            # vt系统代码\n        self.symbol = EMPTY_STRING              # 合约代码\n        self.exchange = EMPTY_STRING            # 交易所代码\n\n        # 成交数据\n        self.lastPrice = EMPTY_FLOAT            # 最新成交价\n        self.volume = EMPTY_INT                 # 最新成交量\n        self.openInterest = EMPTY_INT           # 持仓量\n        \n        self.upperLimit = EMPTY_FLOAT           # 涨停价\n        self.lowerLimit = EMPTY_FLOAT           # 跌停价\n        \n        # tick的时间\n        self.date = EMPTY_STRING            # 日期\n        self.time = EMPTY_STRING            # 时间\n        self.datetime = None                # python的datetime时间对象\n        \n        # 五档行情\n        self.bidPrice1 = EMPTY_FLOAT\n        self.bidPrice2 = EMPTY_FLOAT\n        self.bidPrice3 = EMPTY_FLOAT\n        self.bidPrice4 = EMPTY_FLOAT\n        self.bidPrice5 = EMPTY_FLOAT\n        \n        self.askPrice1 = EMPTY_FLOAT\n        self.askPrice2 = EMPTY_FLOAT\n        self.askPrice3 = EMPTY_FLOAT\n        self.askPrice4 = EMPTY_FLOAT\n        self.askPrice5 = EMPTY_FLOAT        \n        \n        self.bidVolume1 = EMPTY_INT\n        self.bidVolume2 = EMPTY_INT\n        self.bidVolume3 = EMPTY_INT\n        self.bidVolume4 = EMPTY_INT\n        self.bidVolume5 = EMPTY_INT\n        \n        self.askVolume1 = EMPTY_INT\n        self.askVolume2 = EMPTY_INT\n        self.askVolume3 = EMPTY_INT\n        self.askVolume4 = EMPTY_INT\n        self.askVolume5 = EMPTY_INT    \n        \ndef insertData(db,collection,data):\n    client[db][collection].insert(data.__dict__)\n\ndef procecssTickEvent(tick, insertDB=False):\n    \"\"\"处理行情推送\"\"\"\n    vtSymbol = tick.vtSymbol\n\n    # 转化Tick格式\n    drTick = DrTickData()\n    d = drTick.__dict__\n    for key in d.keys():\n        if key != 'datetime':\n            d[key] = tick.__dict__[key]\n    drTick.datetime = datetime.strptime(' '.join([tick.date, tick.time]), '%Y%m%d %H:%M:%S.%f')  \n    \n    # 更新Tick数据\n    if insertDB:\n        insertData(TICK_DB_NAME, vtSymbol, drTick)        \n</code><br><h2>创建一个用于测试的Tick数据</h2><br>In [3]:<br><code lang=\"text\">client=pymongo.MongoClient()\ndata=client['VnTrader_Tick_Db']['rb1705'].find_one({})\ndel data['_id']\n\nclass InputTick: pass\ntick=InputTick()\ntick.__dict__.update(data)\nprint tick.__dict__\n</code><br><code lang=\"text\">{u'askPrice2': 0.0, u'lastPrice': 2977.0, u'exchange': u'UNKNOWN', u'bidVolume5': 0, u'bidVolume4': 0, u'bidVolume3': 0, u'bidVolume2': 0, u'bidVolume1': 1551, u'datetime': datetime.datetime(2016, 12, 28, 21, 27, 36, 500000), u'askVolume1': 120, u'askVolume3': 0, u'askVolume2': 0, u'askVolume5': 0, u'askVolume4': 0, u'date': u'20161228', u'askPrice5': 0.0, u'volume': 392068, u'lowerLimit': 2725.0, u'bidPrice5': 0.0, u'bidPrice4': 0.0, u'bidPrice1': 2976.0, u'bidPrice3': 0.0, u'bidPrice2': 0.0, u'vtSymbol': u'rb1705', u'time': u'21:27:36.5', u'openInterest': 2304294.0, u'askPrice4': 0.0, u'askPrice3': 0.0, u'symbol': u'rb1705', u'askPrice1': 2977.0, u'upperLimit': 3136.0}\n</code><br><h2>测试原版函数性能</h2><br>In [4]:<br><code lang=\"text\">def profiling(count,func=None):\n    if func==None: func=lambda: procecssTickEvent(tick)\n    t0=gtime.time()\n    for i in range(count):\n        func()\n    total_time=(gtime.time()-t0)\n    return total_time*1000/count\n\ntest_count=10000\n</code>In [5]:<br><code lang=\"text\">original_nodb=profiling(test_count)\nclient.drop_database(TICK_DB_NAME)\noriginal_db=profiling(test_count,func=lambda: procecssTickEvent(tick,insertDB=True))\nprint '原版不保存数据到mongodb单次耗时：%.4f' %original_nodb\nprint '原版含保存数据到mongodb单次耗时：%.4f' %original_db\n</code><br><code lang=\"text\">原版不保存数据到mongodb单次耗时：0.0255\n原版含保存数据到mongodb单次耗时：0.2334\n</code><br><h2>改进版本</h2><p>原版程序使用CTP接口保存期货数据时，存在几个问题：</p><ul><li>非交易时间收到的野数据没有被过滤掉</li><li>当前各交易所提供的date字段混乱，有的使用真实日期，有的使用交易日，导致计算的datetime字段也是有问题的</li></ul><p>针对以上问题的改进版本如下：</p><br>In [6]:<br><code lang=\"text\">#过滤掉的时间区间，注意集合竞价tick被过滤了。\ninvalid_sections=[(time(2,30,59),time(9,0,0)),\n          (time(11,30,59),time(13,0,0)),\n          (time(15,15,0),time(21,0,0))]\n\n#本地时间在此区间时对收到的Tick数据不处理，避免有时期货公司会抽风把数据重推一次。\ninvalid_local_section=(time(5,0,0),time(8,30,0))\n\ndef procecssTickEvent(tick, insertDB=False):\n    \"\"\"处理行情推送\"\"\"\n    # 1. 本地时间检查\n    local_datetime=datetime.now()\n    local_time=local_datetime.time()\n    if local_time&gt;invalid_local_section[0] and local_time&lt;invalid_local_section[1]:\n        return\n\n    # 2. 转化Tick格式\n    drTick = DrTickData()\n    d = drTick.__dict__\n    for key in d.keys():\n        if key != 'datetime':\n            d[key] = tick.__dict__[key]\n\n    #防御时间格式变为 ”9:00:00.5\"\n    if tick.time[2] != ':': \n        tick.time = '0' + tick.time\n        \n    tick_hour = int(tick.time[0:2])  \n    local_hour = local_time.hour\n    real_date=local_datetime\n    if tick_hour == 23 and local_hour == 0:#行情时间慢于系统时间\n        real_date+=timedelta(-1)\n    elif tick_hour == 0 and local_hour == 23:#系统时间慢于行情时间\n        real_date+=timedelta(1)\n\n    tick.time = tick.time.ljust(12,'0')\n    drTick.datetime = datetime(real_date.year,real_date.month,real_date.day,\n        int(tick.time[0:2]), int(tick.time[3:5]), int(tick.time[6:8]), int(tick.time[9:12])*1000)\n\n    tmpTime=drTick.datetime.time()\n    for sec in invalid_sections:\n        if tmpTime&gt;sec[0] and tmpTime&lt;sec[1]:\n            return\n    \n    # 3. 更新Tick数据\n    if insertDB:\n        insertData(TICK_DB_NAME, tick.vtSymbol, drTick)        \n\nprocecssTickEvent(tick)\n</code>In [7]:<br><code lang=\"text\">new_nodb=profiling(test_count)\nclient.drop_database(TICK_DB_NAME)\nnew_db=profiling(test_count,func=lambda: procecssTickEvent(tick,insertDB=True))\nprint '新版不保存数据到mongodb单次耗时：%.4f' %original_nodb\nprint '新版含保存数据到mongodb单次耗时：%.4f' %original_db\n</code><br><code lang=\"text\">新版不保存数据到mongodb单次耗时：0.0255\n新版含保存数据到mongodb单次耗时：0.2334\n</code><br><h2>保存为文本文件效率</h2><br>In [8]:<br><code lang=\"text\">def insertData(db,collection,data):\n    for key in data.__dict__:\n        fout.write(str(data.__dict__[key])+',')\n</code>In [9]:<br><code lang=\"text\">fout=open('D:/test.txt','w')\nnew_db_text=profiling(test_count,func=lambda: procecssTickEvent(tick,insertDB=True))\nprint '新版含保存数据到text file单次耗时：%.4f' %original_db\nfout.close()\n</code><br><code lang=\"text\">新版含保存数据到text file单次耗时：0.2334\n</code><br><h2>时间类型转化效率</h2><p>注意到不保存数据到数据的版本中，新版相比老版耗时反而降低了，这主要是由于时间转化函数的改写。</p><p>如下三种时间转化方法效率差别巨大：</p><br>In [10]:<br><code lang=\"text\">time_convert1=profiling(10000,lambda:parse('20161212 21:21:21.5'))\ntime_convert2=profiling(10000,lambda:datetime.strptime('20161212 21:21:21.5', '%Y%m%d %H:%M:%S.%f'))\ndef customized_parse(s):\n    s=s.ljust(21,'0')\n    return datetime(int(s[0:4]),int(s[4:6]),int(s[6:8]),int(s[9:11]), int(s[12:14]), int(s[15:17]), int(s[18:21])*1000 )\ntime_convert3=profiling(10000,lambda:customized_parse('20161212 21:21:21.5'))      \nprint '转化方法1耗时：%.4f' %time_convert1\nprint '转化方法2耗时：%.4f' %time_convert2\nprint '转化方法3耗时：%.4f' %time_convert3\n</code><br><code lang=\"text\">转化方法1耗时：0.0560\n转化方法2耗时：0.0122\n转化方法3耗时：0.0032\n</code><br><h1>总结</h1><br>In [11]:<br><code lang=\"text\">import pandas as pd\ndf=pd.DataFrame([{u'无数据写入':original_nodb,u'mongodb写入':original_db},\n                 {u'无数据写入': new_nodb, u'mongodb写入': new_db, u'text文件写入':new_db_text}\n                ],index=['原版','新版'])\ndf\n</code>Out[11]:<br>mongodb写入text文件写入无数据写入原版0.2334NaN0.0255新版0.21740.03620.0160<br><br><p>总的来看，行情数据落地原版与新版一次落地耗时都为0.2ms左右。函数中，耗时主要来源于mongodb的插入，占约为90%的耗时。通过尝试简单的text写入作为数据存储方式，耗时得到了大幅降低，获得了单次0.04ms耗时的效果，采取其它更高效的格式有望进一步降低耗时。但考虑到无数据写入时的耗时为约0.02ms，所以期望的最优耗时也就在0.02ms左右。</p><p>总的来说，基于mongodb的方案能够实时存储的条目数在每秒几百条量级；进一步优化可能达到几千条量级。此水平应该己能满足绝大多数的需求。</p>","updated":"2016-12-31T15:46:05.000Z","canComment":false,"commentPermission":"anyone","commentCount":13,"likeCount":38,"state":"published","isLiked":false,"slug":"24662087","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2016-12-31T23:46:05+08:00","links":{"comments":"/api/posts/24662087/comments"},"url":"/p/24662087","titleImage":"","summary":"","href":"/api/posts/24662087","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":13,"likesCount":38},"24759330":{"title":"vn.py项目开通捐赠","author":"traderusingpython","content":"vn.py项目两岁啦，感谢社区一直以来的热情支持，没有你们就没有今天的vn.py！<p>最近提出希望捐赠的朋友挺多，决定开始接受捐赠。现阶段计划将收到的全部捐赠资金都投入到vn.py项目基金，用于支持后续的项目开发和各项活动。</p><p>在此先强调一下：<b><u>vn.py是开源项目，可以永久免费使用，并没有强制捐赠的要求！！！</u></b><br></p><p><u>捐赠方式</u><br>支付宝：3216630132@qq.com（陈晓优）<br>计划长期维护一份捐赠清单，所以请在留言中注明是项目捐赠以及捐赠人的名字（当然想匿名的用户就随意了）。</p>","updated":"2017-01-06T15:50:47.000Z","canComment":false,"commentPermission":"anyone","commentCount":20,"likeCount":61,"state":"published","isLiked":false,"slug":"24759330","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-01-06T23:50:47+08:00","links":{"comments":"/api/posts/24759330/comments"},"url":"/p/24759330","titleImage":"https://pic2.zhimg.com/v2-32a469aa0d5a4a298b453edc9a071e59_r.png","summary":"","href":"/api/posts/24759330","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":20,"likesCount":61},"24772031":{"title":"2017年vn.py项目计划","author":"traderusingpython","content":"<p>去年初写2016年项目计划的情景还历历在目，眨眼就一年过去了，vn.py项目在2016年的成长速度远远超出了我的预期。截止写这篇文章的2017年1月7日，vn.py项目在Github上收获了2244个Star以及1276个Fork，比起2016年初几乎翻了四倍，代码贡献者的数量超过了20人（其中17人是在Github上直接提交了代码），机构用户的数量也已经超过了50家。</p><h3>首先回顾2016年项目计划的完成情况</h3><p>整体上去年计划的完成情况还不错，只有一个期权的CTA策略因为标的波动太小没有去做。</p><p><strong>代码方面：</strong></p><ol><li><p>完善飞创、易盛等相对小众接口的添加，这块将由社区驱动，作者主要负责代码检查和管理（增加了vn.xspeed、vn.sgit、vn.okcoin、vn.shzd等接口，易盛暂时还未有计划）</p></li><li><p>整理vn.py项目中API的具体版本号，保证封装接口的对应，这点已经有多位用户提起过，项目初期没有做详细记录所以很多API的版本号一时都较难对上（已完成）</p></li><li><p>Linux上API的编译以及vn.trader支持（已完成）</p></li><li><p>基于VirtualBox的vn.py开发环境镜像，解决部分用户反映项目初期不知该如何搭建开发环境的问题，这个镜像会由官方长期维护下去（已完成）</p></li></ol><p><strong>文章方面：</strong></p><ol><li><p>作者自己作为交易员的成长经历（通过知乎LIVE完成）</p></li><li><p>vn.trader的使用教程（已完成）</p></li><li><p>将ta-lib（技术分析）和quantlib（金融工程和量化）整合到vn.trader中应用的教程，解决目前策略开发过程中技术指标和量化函数缺乏的问题（已完成）</p></li><li><p>一套关于开发基于股指交易ETF期权的CTA策略的教程（未完成，上证50指数波动太小，准备在2017年基于商品期权来开发）</p></li></ol><p><strong>社区方面：</strong></p><ol><li><p>重新建设官方网站，目前使用的是托管在Github Pages上的Hexo静态博客，一来功能比较有限，二来有些用户反映Github时不时会被墙，考虑基于Flask重建一个托管在国内的官网（已完成，基于Pelican的新官网）</p></li><li><p>有用户提出建设互动性更强的网站作为交流平台（如论坛或者知乎Q&amp;A类似的模式），这点在考虑中，主要制约因素是作者参与的时间，可能考虑和更多的资深用户合作是个好主意？（已完成，维恩的派论坛）</p></li></ol><h3>然后展望一下2017年的项目计划</h3><p>2015年是vn.py项目的诞生年，主要在打基础和完善架构；2016年基于社区的反馈，增加了很多新的接口和扩展模块；2017年准备集中在上层应用的开发，进一步解决量化交易员在实盘交易中的痛点。</p><p><strong>Spread Trading价差交易模块</strong></p><p>这个应该是目前呼声最高的应用，还有个名字叫做Pair Trading（配对交易），主要用于实现各种套利类的交易策略，如跨期套利、跨品种套利、跨市场套利等。</p><p>在设计vn.trader中的CTA策略模块时，为了给策略开发者提供最大的自由度，选择把所有的交易委托细节都暴露给策略逻辑来管理。和CTA策略不同的是，价差交易策略一般只给出开平仓的信号，而不会直接去负责交易委托的细节管理。因此整个模块的实现上需要提供额外的一层功能：Spreading Algo价差委托算法，用于接受策略给出的交易信号，并自动管理各条套利腿的委托挂撤。</p><p><strong>Web界面</strong></p><p>越来越多的量化交易员开始拥有自己的交易服务器，无论是成本较低的云服务器还是机构比较常用的经纪商托管服务器。</p><p>当前vn.trader的GUI界面开发使用的是PyQt4，只能在提供图形界面的操作系统上使用（Windows或者启动了X11服务的Linux）。而很多交易服务器考虑到系统稳定性和性能延时等因素，使用的都是纯命令行工作模式的Linux，在这种情况下Web界面就成为了比较合理的选择。</p><p>外观上准备参考AlgoTrader的<a href=\"http://html5.algotrader.ch/\" data-editable=\"true\" data-title=\"Web界面\">Web界面</a>，技术方面初步考虑使用Flask、Websocket、Bootstrap和Vue.js（已经有人提醒这个可能是大坑），后续开发过程中如果发现不合适再更换。</p><p><strong>Docker支持</strong></p><p>相信不少vn.py项目的用户在刚上手使用时都掉过各种各样Python环境配置方面的坑：弄错Anaconda的版本、弄错vcredist的版本、不知道如何使用pip安装三方包等。为了解决这个问题，之前打包制作了一个VirtualBox的Ubuntu镜像，实现了用户的开箱即用，但存在几个问题：镜像过大下载缓慢、打包复杂没有时间长期维护、只能在虚拟机中使用。</p><p>最近两年诞生了一种新的容器技术Docker，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后用户可以在任何支持Docker的机器上直接使用，无论是虚拟机还是真实服务器。同时Docker的打包过程允许只提供环境搭建的指令，当用户部署Docker时才根据指令去下载和搭建整个环境，因此镜像可以很小（只是个脚本），还提供类似Github的Docker Hub方便镜像资源的分享。</p><p>目前社区已经有用户在Docker中成功运行了vn.trader，但仅实现了CTP接口，同时是纯命令行模式没有GUI界面（使用脚本启动）。接下来官方支持的Docker会实现所有Linux下可用的接口，并提供界面方便使用（Web界面或者X11服务穿透）。</p><p><strong>国际化支持</strong></p><p>准备提供项目的英文支持，计划分为两步：软件界面上的英文翻译和文档的英文翻译。尽管vn.py项目诞生时主要面向的是国内量化交易员，但随着项目的成长，现在感觉也到了可以走出去看看的时候了。同时个人对vn.ib接口无论是API功能支持还是性能方面都挺有信心，想试试看能否超越IbPy。</p><p><strong>文档建设</strong></p><p>有个笑话：程序员最恨的事情之一是别人的项目不写文档，之二就是给自己的项目写文档。之前也是有不少人抱怨过vn.py项目的文档资料太少，只有知乎专栏和<a href=\"http://www.vnpy.org\">http://www.vnpy.org</a>上面不多的文章，文章的抽象程度也比较高，让用户在刚上手时无从下手。</p><p>2017年准备从用户使用的角度来设计一套全面的文档：入门使用、策略开发、扩展模块开发、架构细节、封装原理等，让新手能够循序渐进的学习，不至于一上来掉坑后爬不出来就气馁。</p><p>最近开始接受项目捐赠来维护一个vn.py项目基金，第一个考虑的用途就是支持项目文档的编写。由本人设计好整个文档的目录，并给出几篇示例性质的章节后，鼓励社区成员选择自己擅长的题目章节去编写文档，对于文档作者而言参与的价值包括：</p><ol><li>在编写文档过程中遇到的问题，本人和另外几位社区管理员（资深用户）会提供更加充分的答疑解难，有条件的时候可以线下辅导；</li><li>最终文档在发布后会署名作者的姓名，过去两年Python开发经验在国内量化领域求职时已经慢慢成为了一个重要加分项，有直接的vn.py文档编写经历证明相信可以为简历增色不少；</li><li>一定量的资金回馈（从项目基金中支付），写文档时候的咖啡钱组织总还是出得起的。</li></ol><h1>最后，各种地缘政治因素的动荡注定了2017年不会是平静的一年，祝大家在市场的大幅波动中多多赚钱！</h1>","updated":"2017-01-07T15:56:50.000Z","canComment":false,"commentPermission":"anyone","commentCount":45,"likeCount":205,"state":"published","isLiked":false,"slug":"24772031","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-01-07T23:56:50+08:00","links":{"comments":"/api/posts/24772031/comments"},"url":"/p/24772031","titleImage":"https://pic3.zhimg.com/v2-d9c66747dbb2042d796757dd5554484e_r.jpg","summary":"","href":"/api/posts/24772031","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":45,"likesCount":205},"24994645":{"title":"开箱即用的开源云端量化交易平台 —— 写在vn.py v1.4发布之际","author":"traderusingpython","content":"<h2>开箱即用</h2><p>想想还是在开头声明下：这一段是帮量衍投资做的一个产品广告，一是感谢量衍对于vn.py社区做出的贡献，二是也确实觉得这个产品对于很多用户有价值（尤其是新手）。</p><p><strong>量衍介绍：</strong> 量衍投资的全称是量衍投资咨询，业务范围包括量化交易相关的技术咨询和外包开发服务（主要围绕vn.py项目），同时也是vn.py项目当前唯一的商业支持公司，贡献了大量开源项目中的代码，并赞助运营着社区论坛<a href=\"http://www.vnpie.com\" data-title=\"“维恩的派”\" class=\"\">“维恩的派”</a>。</p><p>之前曾经和量衍合作发布过一个基于VirtualBox的vn.py开箱即用镜像，被社区里的很多新手用户誉为“菜鸟福音”。</p><img src=\"v2-6c0c72f7c351a4330c1bc2b2200cc40a.png\" data-rawwidth=\"1784\" data-rawheight=\"1005\"><p>这次在vn.py发布v1.4版本的同时，量衍也开发完成了一套阿里云上的开箱即用镜像(上图），试用几天后不得不说让我印象非常深刻：</p><ol><li>基于Ubuntu 16.04(LTS) 64位开发，比起14.04更新了很多重要的库（比如boost），比起Windows对服务器配置的要求更低（简单来说就是省钱）。</li><li>提供了基于XFCE + vnc4server的远程桌面，这个太给力了！！！之前用过腾讯云和阿里云的Linux云服务器无一例外都是纯命令行模式，尽管可以跑不带界面的vn.trader，但在策略和系统的监控上非常不方便，最后还是换回了Windows，而有了这个远程桌面后，基本可以和Windows的云服务器say goodbye了。顺道一提量衍还做了桌面美化，平板化的桌面主题比Win7漂亮不少。</li><li>安装并配置好了全套vn.py运行环境：vn.py（v1.4）、Anaconda、MongoDB、IB TWS、相关Python库、API编译，点个图标就能立即启动vn.trader，对于新手而言再也不用一步步研究如何安装环境了。</li><li>提供了量化业务中常用的工具：Atom（代码查看和编辑）、Robomongo（数据库监控）、GitKraken（代码仓库管理）、Terminator（带子窗口终端）。</li></ol><p>镜像支持的接口也比较全面，包括了所有主要的金融资产类别：</p><ul><li>CTP（期货）</li><li>LTS（证券、期权）</li><li>IB（外盘）</li><li>OANDA（外汇）</li><li>OKCOIN（比特币）</li></ul><p>因为是商业公司，量衍的这套镜像是收费的：100元每个用户（不限安装数量）。总的来说，个人觉得对于很多新手而言这是一个性价比相当不错的产品，少量的花费就可以省去踩坑各种环境配置的烦恼，把更多精力放在量化策略上，不过对于技术大神或者喜好折腾的用户而言就没必要了。镜像的购买方式在文章最后。</p><h2>v1.4版本</h2><p>大约5天前刚发布了vn.py的v1.4版本，其中比较重要的几个更新包括：</p><ol><li>增加前后端分离的vn.trader实现：基于vn.rpc模块的vtServer和vtClient</li><li>增加量投科技QDP柜台的接入：vn.qdp和qdpGateway</li><li>增加vn.how目录：用于存放项目应用相关的演示代码</li><li>改进ibGateway的行情和成交推送功能：</li><li>改进vn.okcoin和okcoinGateway的断线重连功能</li></ol><p>这个版本的更新里最值得一提的就是前后端分离的vn.trader。之前发布vn.rpc后，很多人对于如何使用这个模块毫无头绪，这里的前后端分离方案就可以作为使用vn.rpc模块时的一个参考或者说开发模板。</p><p>开发时最重要原则是理清自己的实际业务需求：</p><ol><li>先找到自己程序在某方面的的瓶颈（速度、稳定性、扩展性等）</li><li>然后设计好合理的程序解耦方案（需要几个进程、每个进程里运行什么逻辑）</li><li>最后使用vn.rpc把每个子进程中的逻辑给包装和连接起来</li></ol><p>记住一定要确保自己有实际的需求，不要为了解耦而解耦。</p><h2>未来版本计划</h2><p>为防止自己懒癌发作，先在这里把开发计划给公布了。准备在2017年底前将项目推进到v2.0，每个版本的计划如下：</p><ul><li>v1.5: 中泰证券XTP柜台接入</li><li>v1.6：Spread Trading（价差交易）模块</li><li>v1.7：完整的海龟策略实现（多标的、资金仓位管理、算法交易）</li><li>v1.8: 英文支持（包括vn.ib的文档和vn.trader程序）</li><li>v1.9：Web界面</li><li>v2.0：新的稳定版</li></ul><p>以上版本计划在具体开发的过程中可能有先后顺序的变化，不过既然都公布了相信我还是会全部完成的。</p><h2>镜像购买方式</h2><ol><li>通过支付宝转账100元到sales@vnpie.com</li><li>发送邮件给sales@vnpie.com，告知自己的阿里云aliyunID</li><li>镜像通过共享镜像的形式交付，量衍一般会在第二天之前把买家的aliyunID加入到共享清单中，并回复确认邮件</li><li>用户收到确认邮件后，即可登录阿里云并使用共享镜像中的vn.py镜像来创建自己的云服务器</li><li>有任何问题请直接去“维恩的派”论坛咨询，也可以直接邮件联系</li></ol>","updated":"2017-01-22T16:03:44.000Z","canComment":false,"commentPermission":"anyone","commentCount":40,"likeCount":143,"state":"published","isLiked":false,"slug":"24994645","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-01-23T00:03:44+08:00","links":{"comments":"/api/posts/24994645/comments"},"url":"/p/24994645","titleImage":"https://pic1.zhimg.com/v2-a64fd0d0386b1e128047fe54e961b0a4_r.jpg","summary":"","href":"/api/posts/24994645","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":40,"likesCount":143},"25050658":{"title":"vn.py文档编写计划","author":"traderusingpython","content":"<h1><strong>鸡年的第一篇文章，给各位读者拜个年，祝大家新的一年身体健康，全家幸福～</strong><br></h1><h3>需求</h3><p>之前在vn.py项目2017年计划里面提到，如果对vn.py社区用户们的需求情况做个排序，项目文档绝对可以排在第一位。尤其对于新手而言，目前能找到的文档资料比较零碎，只能自己去看源代码，学习曲线比较陡，也让很多人望而却步。</p><h3>误区</h3><p>之前走入了一个误区，因为自己是作者的关系对整个项目的了解比较全面，所以写文档的时候是从开发者的角度，按照自己一步步开发vn.py项目的顺序在写：CTP接口原理、接口封装、事件引擎、GUI界面、应用模块开发等。直接的后果就是导致用户上来就先接触最难的底层部分，然后才一点点过度到自己实际应用中会用到的上层开发部分，学习效率非常低下。</p><h3>用户</h3><p>接下来新的文档准备从用户的角度来写：先讲安装配置、基本使用，让用户能先把vn.py跑起来，不用再到处问环境怎么配置；然后介绍如何使用CTA模块来开发交易策略，如何结合风控模块来做事前风险管理；下一步讲解基于事件引擎的扩展模块的开发方式，使得用户能够去实现一些比较复杂的功能应用；最后再介绍接口封装、架构细节等内容，让有兴趣的用户来进一步提高。</p><p>不再废话了，直接进入目录。</p><h3>目录</h3><ol><li><p>安装配置</p><ol><li><p>Windows(200)</p><ol><li>Python环境：Anaconda安装</li><li>VS2013运行时：vcredist x86</li><li>数据库：MongoDB、RoboMongo</li><li>Python库：pip安装</li><li>成功运行</li></ol></li><li><p>Ubuntu(200)</p><ol><li>环境安装</li><li>API编译(Linux下的链接问题)</li><li>成功运行</li></ol></li></ol></li><li><p>基本使用(400)</p><ol><li>配置接口的账号、密码、服务器地址等，并测试连接</li><li>日志信息、合约列表查询、行情订阅</li><li>手动下单、撤单，成交和委托的数据监控</li><li>错误、持仓、资金的数据监控</li><li>其他贴士：窗口拖动、还原，一键测试功能</li></ol></li><li><p>CTA策略</p><ol><li><p>模块文件介绍(200)</p><ol><li>每个文件的功能说明</li><li>文件内模块的关系图</li></ol></li><li><p>策略回测(400)</p><ol><li>回测引擎API的使用</li><li>读懂回测报告</li><li>参数优化(普通模式)</li><li>多进程优化</li></ol></li><li><p>策略实盘(200)</p><ol><li>载入策略到CTA引擎</li><li>编写策略实例的json配置文件</li><li>使用CTA监控组件来管理策略的生命周期</li><li>策略实盘过程中的运维细节</li></ol></li><li><p>策略开发(600)</p><ol><li>策略模板CtaTemplate介绍</li><li>委托类型</li><li>时间序列数据结构</li><li>使用talib中的技术指标</li></ol></li></ol></li><li><p>事前风控(200)</p><ol><li>使用风控模块RiskManager</li><li>风控规则配置</li><li>添加自定义规则</li></ol></li><li><p>行情解决方案(200)</p><ol><li>使用行情记录模块DataRecorder</li><li>配置行情记录的规则</li><li>历史数据下载功能ctaHistory.py</li></ol></li><li><p>事件引擎(400)</p><ol><li>事件引擎的结构</li><li>事件引擎的启动和停止</li><li>事件引擎的工作流程</li><li>事件处理函数</li><li>定时器事件</li><li>使用中需要注意的细节</li></ol></li><li><p>应用开发</p><ol><li>应用模块的设计思路(200)<ol><li>监听事件(事件引擎)</li><li>调用功能(主引擎)</li></ol></li><li>使用合理的数据结构来解决问题(200)<ol><li>列表list、字典dict、集合set</li><li>特殊结构collections</li><li>矩阵numpy、时间序列pandas</li></ol></li><li>设计应用的算法逻辑(200)</li><li>开发应用的GUI界面(200)<ol><li>使用表格(TableWidget)</li><li>调整显示方式(GroupBox、TabWidget)</li><li>数据选择工具(ComboBox，SpinBox)</li><li>使用按钮调用功能</li></ol></li><li>将模块加载到vn.trader中</li></ol></li><li><p>RPC(400)</p><ol><li>什么时候应该使用vn.rpc模块</li><li>服务器端RpcServer和客户端RpcClient的介绍</li><li>服务器端的开发</li><li>客户端的开发</li><li>vn.rpc模块的工作原理</li><li>使用中需要注意的细节(如线程安全、心跳等)</li></ol></li><li><p>接口封装</p><ol><li>各种API的介绍和对比(200)</li><li>API类模块的编译和使用(vn.ctp、vn.lts等)(200)</li><li>类CTP交易API(200)<ol><li>工作原理</li><li>封装设计</li></ol></li><li>Interactive Brokers(IB)的API(200)<ol><li>工作原理</li><li>封装设计</li></ol></li><li>其他API(400)<ol><li>oanda</li><li>wind</li><li>shzd</li><li>okcoin</li></ol></li></ol></li></ol><h2>社区协作</h2><p>之前的一些文档编写大多是本人独自在做，接下来打算借助社区的力量来一起完成这个新的项目文档。</p><p>既然涉及到团队协作就需要一套协作流程，每个章节的编写流程如下（初步计划，有不合理的地方欢迎指出）：</p><ol><li>作者（社区成员）选择自己有兴趣编写的章节并联系本人来确定一些细节：是否已有人在编写、内容框架、完成时间和报酬费用（下面会提到）等；</li><li>细节确认无误后，作者就可以开始本章节的编写；</li><li>在编写文档的过程中，遇到技术方面的难题可以直接联系本人，会帮助优先解决；</li><li>作者完成文档的编写后发送给本人，本人会和作者一起对文档内容做回顾和修改；</li><li>本人将最终完成的文档发布到vnpy.org网站上的文档板块，并向作者支付报酬费用；</li><li>之前的目录中，部分章节旁边有一个括号中的数字，就是该章节计划的报酬费用，某些是需要完成一个子章节，某些是需要完成一个完整的章节。</li></ol><p>开始的时候计划自己来写几篇文档作为范例来给社区参考，为了给社区其他作者更多学习实践的机会，我会选择相对较为简单的章节（其实纯粹就是为了偷懒～）。</p><p>综上，社区作者在这个新文档编写工作中才是最重要的角色，本人更多只是扮演一个组织者。相应的，对于社区作者来说，参与文档的编写也能为你的交易和职业生涯带来一些帮助：</p><ol><li>全面了解vn.py框架：除非自己已经弄得非常明白了，否则很难写出能让别人明白的文档；</li><li>遇到技术问题时的优先帮助：现在社区群的规模已经较大，很多用户的提问我没有办法一一解答（QQ未读信息已经积累一堆了），对于文档作者我会提供自己的微信和手机，方便直接联系和保证问题的解答，同时也会分享自己在做量化交易过程中的一些实战经验；</li><li>加入vn.py项目贡献者名单：章节发布后署名，拥有未来社区活动的优先参与资格，同时对于很多招聘Python方向量化职位的金融机构来说，有vn.py的项目经验也是一个不错的加分项；</li><li>报酬费用：金额不多估计只够买买咖啡，更多是表达整个社区对文档作者的一份感谢。</li></ol><h3>有兴趣参与的朋友请直接qq私信我或者发邮件到vn.py@foxmail.com，提前谢过。</h3>","updated":"2017-01-31T02:49:14.000Z","canComment":false,"commentPermission":"anyone","commentCount":27,"likeCount":85,"state":"published","isLiked":false,"slug":"25050658","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-01-31T10:49:14+08:00","links":{"comments":"/api/posts/25050658/comments"},"url":"/p/25050658","titleImage":"https://pic1.zhimg.com/v2-8b2ae150084f341d731cbaade99d612c_r.jpg","summary":"","href":"/api/posts/25050658","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":27,"likesCount":85},"25483770":{"title":"用Python的交易员的Live--阅读：交易员的内功修炼","author":"traderusingpython","content":"我是用 python 的交易员，vn.py 作者，懂点交易，懂点编程。 \n<p>在平时的工作和社交中，经常遇到一些朋友为了如何提高自己在交易方面的内功而烦恼：有些是想要毕业后从事交易相关工作的学生不知道该如何入门，有些则是初入行的交易员苦恼于如何提高自己的交易水平。和很多其他的行业一样，阅读也是交易员修炼内功、自我提高不可或缺的一种方式。 每个交易员在风格上可能有自己的侧重：技术面、基本面、量化分析等等，但在当前国内金融市场飞速发展的时代，如果太过「偏科」，只关心自己眼前的那一亩三分地，无疑很容易坐井观天，错过很多稍纵即逝的交易机会。 \n</p><p>知乎上之前已经有过不少关于金融阅读的 Live ：如理财、并购、量化等等，但交易这一金融市场的核心领域还没有覆盖。在这次的 Live 中，我希望从过来人 的角度来和大家分享一些自己的经验：如何通过阅读一点一滴地修炼自己的内功，从一个完全不懂交易的小白，经历过技术爱好者、巴菲特粉丝、量化矿工等阶段，逐渐成长为能够独当一面负担起公司 PNL 的交易员。<br></p><br>本次 Live 主要包括以下内容： \n<br><ul><li>快速了解交易员这一职业，如何通过阅读来提高自己 <br></li><li>技术面、基本面和量化分析：交易员必修的内功 <br></li><li>各种金融考试，对于交易员是否真的毫无意义 <br></li><li>面对回撤时的痛苦， 哪些书能够帮到你 <br></li><li>哪些销量很大的书其实是名不符实，还容易把人带进坑里 </li></ul>本次的 Live 主要针对希望从事交易员工作的在校大学生和初入职场的新人交易员，因此价格定在 19 元，同时提醒 Live 中的某些观点可能带有强烈的个人偏好。<br><br><p>【传送门】<a href=\"https://www.zhihu.com/lives/819952218865287168\" data-editable=\"true\" data-title=\"知乎 Live - 全新的实时问答\" class=\"\">https://www.zhihu.com/lives/819952218865287168</a></p>","updated":"2017-02-28T09:49:49.000Z","canComment":false,"commentPermission":"anyone","commentCount":4,"likeCount":30,"state":"published","isLiked":false,"slug":"25483770","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-02-28T17:49:49+08:00","links":{"comments":"/api/posts/25483770/comments"},"url":"/p/25483770","titleImage":"https://pic2.zhimg.com/v2-9308b638d8de14aeee4827a60cdc756d_r.jpg","summary":"","href":"/api/posts/25483770","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":4,"likesCount":30},"25709554":{"title":"vn.py发布v1.5","author":"traderusingpython","content":"<p>标题图片里的是本人挺喜欢的一个威士忌牌子：强尼遛弯，而曲折不平的道路挺符合最近几个月开发v1.5时遇到的情况，当协作的团队成员数量上升时你会面对很多原本不存在的挑战。</p>之前计划中的中泰证券XTP接口模块因为种种原因（合规、风控、安全等），无法放到开源项目中了，而是会采取和中泰合作的一款量化交易软件的形式来发布：接口和引擎层面闭源，上层策略模块和vn.py兼容，允许客户基于策略模板来开发各种股票、ETF、债券等证券方面的量化交易策略。<p>不过虽然少了XTP，v1.5的发布中依旧有不少重大更新。</p><br><p>接口方面：</p><ol><li>增加火币的比特币交易接口vn.huobi，以及vn.trader的接入huobiGateway<br></li><li>增加链行的比特币交易接口vn.lhang，以及vn.trader的接入lhangGateway<br></li><li>增加vn.ctp模块的Python 3封装，感谢社区成员bigtan的贡献</li><li>增加了vn.ib模块的英文介绍信息，感谢社区成员wangzhe3224的贡献</li><li>在ctpGateway中，尝试加入了对无效Tick数据的自动过滤（无成交量）</li></ol><br><p>策略模块方面：</p><ol><li>CtaAlgo模块下的策略文件实现自动识别和启动时载入</li><li>增加通达信分钟数据导入MongoDB的功能，感谢社区成员AaronGuan的贡献<br></li><li>增加基于目标持仓来进行交易的策略模板，感谢量衍投资的贡献</li><li>增加King Keltner策略，用来展示OCO（One-Cancel-Other）委托和5分钟K线聚合的写法</li></ol><br><p>风控方面：</p><p>1. 增加风控引擎中关于每日撤单次数的事前风控管理，感谢社区成员sunlit和ares89的贡献</p><br><p>接下来开始进入v1.6的开发，也就是挺多人期待已久的价差套利模块（SpreadingAlgo），终于开始啃今年的硬骨头了。</p>","updated":"2017-03-11T15:04:44.000Z","canComment":false,"commentPermission":"anyone","commentCount":21,"likeCount":80,"state":"published","isLiked":false,"slug":"25709554","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-03-11T23:04:44+08:00","links":{"comments":"/api/posts/25709554/comments"},"url":"/p/25709554","titleImage":"https://pic3.zhimg.com/v2-ce766474ebb11f54178505d690953b32_r.jpg","summary":"","href":"/api/posts/25709554","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":21,"likesCount":80},"26216391":{"title":"什么？有人解决了Python最难的问题GIL！还用来做高频交易？！","author":"traderusingpython","content":"<h2><u>申明</u></h2>事情起源于这篇文章：<a href=\"https://zhuanlan.zhihu.com/p/26212404?group_id=833437537719705600\" class=\"\" data-editable=\"true\" data-title=\"Quicklib对VNPY团队贬低回应和异步IO与传统架构性能对比 - 知乎专栏\">Quicklib对VNPY团队贬低回应和异步IO与传统架构性能对比 - 知乎专栏</a><blockquote>Quicklib利用Python特点，在底层驱动上采用了异步IO来替代多线程，使得底层没有全局锁，性能大大提高。进入应用层后，复杂的耗时计算则采用Python的多进程库。</blockquote><p>对于Quicklib这个项目，过去几个月也是一直有所耳闻，不过一直没有时间去做深入的研究。晚上吃饭的时候收到多位朋友发来的这篇文章，发现作者在文中对于vn.py表现出了诸多不满的情绪（社区和代码），尤其指责vn.py核心开发团队对Quicklib大肆抨击。</p><p>想了半天也记不起来自己或者几个做核心开发的朋友干过相关的事情（最近因为商品期权上市一直忙的不可开交），然后去调查了一圈，发现是社区论坛上有位用户写了若干篇关于Quicklib的分析文章，估计引起了Quicklib作者的不满，在此先告个歉。</p><p>不过同时也想郑重申明下：<b><u>vn.py的核心开发团队基本都是各家大型量化私募的交易负责人，平时一般都忙于从“交易”而非“软件”或者“培训””上赚钱，以后没有弄清楚请不要乱扣帽子。</u></b><br></p><br><h2><u>回应</u></h2><p>本来做完上面的申明后就准备这么算了，不过豆粕期权的隐含波动率从上市日的18%三个交易日不到就跌的接近了最近的实现波动率13%，接下来几天一下子没了什么特别显著的交易机会，闲来无事就多看了点Quicklib相关的信息，不看还好，看了后这下真是有点气不打一处来。</p><p>在多篇文章里，Quicklib的作者都表达了对vn.py性能方面的抨击，指出vn.py在架构方面的各种不合理，并且提出Quicklib则是解决了Python最大的难题GIL全局锁，并且能够直接使用Python来开发超高频交易策略。</p><br><p>“同行是冤家”的道理我明白，也知道不是所有开源项目的作者都对于盈利没有追求，有时抨击下对手抬高下自己本不是什么大不了的事情，只要说的事情符合事实那都可以算作“技术切磋”的范畴，不过从<a href=\"http://www.quicklib.cn/index.htm\" data-editable=\"true\" data-title=\"Quicklib官网\">Quicklib官网</a>下载“内盘期货CTP Python框架”后，解压一看瞬间有点无语：</p><p>首先是一张“QuickLibGUIDemo”的截图：</p><p><img src=\"v2-8cd80647b4c71467aeb100c9504785a7.png\" data-rawwidth=\"1016\" data-rawheight=\"659\">诶，怎么和vn.py早期开发演示模块的vn.demo看着这么像？？可能只是借鉴了一些GUI设计吧......</p><p>然后再打开目录：</p><p><img src=\"v2-c249b91bd2749648253106734317cf29.jpg\" data-rawwidth=\"1395\" data-rawheight=\"633\">怎么连部分文件名都一模一样？？不会这么巧吧。</p><p>不信邪了，打开demoUi.py文件看看：</p><p><img src=\"v2-f1d95d069a85ddafd659a307048c749c.png\" data-rawwidth=\"862\" data-rawheight=\"1012\">我了个CAO！根本就是vn.demo里面的代码啊，类名、变量名就算了，连格式都是WingIDE内置模板自动生成的效果！当然在文件开头Quicklib的作者没有忘记加入一些自己的“原创描述”内容。</p><p><u><b>vn.py项目采用的是授权非常自由的MIT协议，允许任何人用于任何其他的开源或者商业项目，都无需向我或者vn.py社区支付任何费用（其实连招呼都不用打）</b></u>。</p><p>但是Quicklib作者老兄，您一边抨击着vn.py架构的各种不合理，一边还在自己的项目里大量使用着vn.py的代码，我想问问：</p><p>而且抄的时候拜托能不能专业点，哪怕把代码里的格式稍微换换也行啊......</p><p>为了留个证据，我把Quicklib官网下载的代码上传了：<a href=\"https://share.weiyun.com/f939a837ea65708759bbf5a7a1c94efd\" data-editable=\"true\" data-title=\"微云文件\">微云文件</a>。</p><p>另外如果有人质疑以上代码是否属于vn.py项目先写出来的，可以问问vn.py社区早期的用户，几乎所有人都看过这些代码，也可以去<a href=\"www.github.com/vnpy/vnpy\" data-editable=\"true\" data-title=\"vn.py的Github仓库\">vn.py的Github仓库</a>翻commit的历史，没记错这些应该是差不多两年前的代码了。</p><p>另外还有看到Quicklib的仓库里有这么一个文件夹：<a href=\"https://github.com/wdgwz/quicklib/tree/master/%E4%B8%8E%E5%85%B6%E4%BB%96%E5%BC%80%E6%BA%90%E6%A1%86%E6%9E%B6%E5%AF%B9%E6%AF%94%E8%81%8A%E5%A4%A9%E6%88%AA%E5%9B%BE\">与其他开源框架对比聊天截图</a>。我也真是醉了，借用一个朋友的评论：<u><b>做开源用这种方式攻击对手，犯得着么？要是真做商业项目那还得了？</b></u>（我默默补一句：还用了一堆对手的代码......）</p><br><h2>计划</h2><p>对于看到了这里的读者朋友想先道个歉，讲了这么多废话还没有提到和标题相关的内容。</p><p>生气归生气，本人好歹是做交易的，转念一想：Quicklib万一真的是彻底解决了GIL的问题，而且还可以应用于超高频交易，那么这个技术无论是对于我自己的交易策略或者对于vn.py项目本身也完全值得借鉴啊！</p><p>毕竟开源的好处之一不就是可以博览众长，吸收各家的有点么（想到年底的Performance不进口水也流了下来）！</p><p>获得在vn.py社区论坛发布Quicklib相关文章的作者同意后，接下来将会在专栏里发布其写的几篇文章，另外我本人也会再做一个系列关于性能方面的专题内容，一方面是想看看Quicklib是否真的完成了解决GIL痛点的技术（这么言之凿凿估计还是有些干货），另一方面也希望可以激发vn.py社区的灵感和相关讨论，看看有没有其他的办法可以进一步提高vn.py框架的性能。</p><br>不早了，准备睡觉，感谢读者朋友们的耐心~<br><p><u><b>vn.py项目的Github仓库：<a href=\"https://github.com/vnpy/vnpy\" data-editable=\"true\" data-title=\"vnpy/vnpy\">vnpy/vnpy</a>，觉得还不错的话不妨来点个star!</b></u></p>","updated":"2017-04-06T16:44:51.000Z","canComment":false,"commentPermission":"anyone","commentCount":64,"likeCount":219,"state":"published","isLiked":false,"slug":"26216391","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-04-07T00:44:51+08:00","links":{"comments":"/api/posts/26216391/comments"},"url":"/p/26216391","titleImage":"https://pic2.zhimg.com/v2-9cbd6b9efa7c0aed20cac1080847eb49_r.jpg","summary":"","href":"/api/posts/26216391","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":64,"likesCount":219},"26224702":{"title":"突破GIL？！ - 转载 - Quicklib 源码分析 1","author":"traderusingpython","content":"<h2><u>写在前面</u></h2><p>昨天文章中提到过的Quicklib的事情，目前整个情况的发展有点超出我的预期，Quicklib的作者早上很快发出了第二篇文章：<a href=\"https://zhuanlan.zhihu.com/p/26217446\" data-editable=\"true\" data-title=\"Quicklib对VNPY团队贬低回应和异步IO与传统架构性能对比（2） - 知乎专栏\" class=\"\">Quicklib对VNPY团队贬低回应和异步IO与传统架构性能对比（2） - 知乎专栏</a>，同时也在昨天文章下面做了留言提到<u><b>自己并没有说过Quicklib可以用来做高频交易</b></u>，而是本人理解有误。</p><p>又仔细看了一遍之前的文章后，发现Quicklib的作者确实只提到了“Quicklib资金曲线工具，对高频交易的资金曲线进行测试”这么个说法。所以是本人昨天看文章不仔细抱个歉，不过看了“对高频交易的资金曲线进行测试”半天后，还是没能想明白到底在说什么。可能回头Quicklib作者写文章的时候，语言表达方面还是要稍微精炼一下？</p><p>接下来会转载vn.py社区论坛上一位用户写的关于Quicklib的分析文章系列，<b><u>再次强调下文章仅代表他的个人观点，和vn.py核心开发团队无关</u></b>。</p><p>看着豆粕期权波动率横盘了一上午，也是找了个空仔细拜读了一下这位朋友（“金融民工“，下称“民工”）的分析文章。不得不说民工在语言方面有点过激，就算内容方面讲的全都是事实，换了我是Quicklib的作者也肯定开心不起来。而且Coding这件事情谁都难免会有一些疏漏，在此代表vn.py社区向Quicklib的作者再抱个歉，抱歉的次数有点多哈，见谅。后面的讨论我们都会尽量集中在纯粹的技术领域，而不是人身攻击。</p><p>另外也是联系了民工后他表示最近工作比较忙，没时间重写这几篇分析文章了。大家请将就着看吧，<b><u>多关注技术内容，语言方面请包涵下了</u></b>。</p><br><h2><u>正文</u></h2><p>作者：金融民工</p><p>这个世界事变，不是因为坏人作恶，而是因为好人不作为。看着最近有名为quicklib的一个library到处秀智商下限，招摇撞骗，不懂装懂，睁眼说瞎话，这种行径如果是无意为之那就是蠢，如果是蓄意为之就是坏，目前看起来很可能是又蠢又坏。所以鄙人打算在此写一个小的源码分析系列, 让大家看看这个所谓的quicklib究竟是什么玩意。<br><br>可能很多人还不知道quicklib是干嘛的，没关系可以搓这里<a href=\"http://quicklib.cn/index.htm\" class=\"\" data-editable=\"true\" data-title=\"quicklib主页\">quicklib主页</a>。简而言之其作者称其为一个Python的交易框架。以\"高性能\", \"架构美丽\"为宣传点四处发牛皮鲜似的广告。好了带大家一起来看看这个所谓之\"高性能\"，\"架构美丽\"到底如何。</p><p>git clone下来可以看到这样的目录(请原谅我笑点低, 看到红色画框的部分就莫名的想笑.)<br></p><p><img src=\"v2-bca583451ab5ce6d563c0e8eb4905a60.png\" data-rawwidth=\"802\" data-rawheight=\"979\">代码部分主要看 Quicklib/(A)Quicklib CTP期货行情交易接口Python开源框架/Windows/source, 分为行情和交易两个部分：<br></p><p><img src=\"v2-22b6bb531051c721de37fd4a585bbc9a.png\" data-rawwidth=\"457\" data-rawheight=\"80\">先来看看这个这么吊炸天的框架所谓之行情部分如何实现.vs2015打开项目文件之后, 可以看到项目文件结构是这样：<br></p><p><img src=\"v2-031a83e181d35ade45aa9116e2809383.png\" data-rawwidth=\"348\" data-rawheight=\"708\">哟还有AES加密呢，但grep了一下， 似乎没有什么地方用得到AES呢，为了拼行数吗？不知道为何又莫名的笑了一下。同样的CRC32也没发现什么地方用到啊。</p><p>好吧正经一点儿，我们来进入正题。<br><br>先来看QLCTPMDInterface.h这里，好多可以看到extern \"C\"{} 包起来的各式函数声明. 这些函数的定义在QuicklibCtpMD.cpp里面，然后QuicklibCtpMD.cpp里面呢除了这些函数定义之外, 还充斥着大量的杂乱无章的全局变量。为什么会这样呢？因为Python调用C的library非常方便, 那么简单的把CTP的内容用函数都包一下, 就可以了，来看个例子：<br></p><code lang=\"cpp\">// 声明部分\nint QUCIKLIB_MD_API ReqUserLogin();\n\n// 定义部分\nint ReqUserLogin()\n{\n    return gMDSpi.ReqUserLogin();\n}\n</code><p>看gMDSpi变量的声明, 呵呵果不其然是一个全局对象, 在945行：<br></p><code lang=\"cpp\">CMdSpi gMDSpi;\n</code><p>在来看看订阅行情的函数：<br></p><code lang=\"cpp\">// 声明\nvoid QUCIKLIB_MD_API Subscribe(const char *InstrumentID);\n\n// 定义\nvoid Subscribe(const char *InstrumentID)\n{\n        //char * crcvalue = NULL;\n        Add(InstrumentID, NULL);\n        ppInstrumentID[amount] = new TThostFtdcInstrumentIDType;\n        ::strcpy(ppInstrumentID[amount], InstrumentID);\n        //::strcpy_s(ppInstrumentID[amount],sizeof(ppInstrumentID[amount]), contract);\n        gMarket[InstrumentID] = amount;\n        //data[amount] = new CThostFtdcDepthMarketDataField;\n        depthdata[amount] = new CThostFtdcDepthMarketDataField;\n        ++amount;\n        gMDSpi.SubscribeMarketData();\n        \n}\n</code><p>有没有感受到一股浓郁的c with class气息, 仿佛回到了大一初学C++的样子? </p><p>gMDSpi.SubscribeMarketData()；之前几行在准备各种参数, 写在全局变量里面, 然后调用gMDSpi.SubscribeMarketData()；SubscribeMarketData函数：<br></p><code lang=\"cpp\">void CMdSpi::SubscribeMarketData()\n{\n        int iResult = mpUserApi-&gt;SubscribeMarketData( &amp;(ppInstrumentID[amount - 1]), 1);\n        if (iResult != 0)\n            cerr &lt;&lt; \"Failer:订阅[\" &lt;&lt; ppInstrumentID[amount - 1] &lt;&lt; \"]\" &lt;&lt; ((iResult == 0) ? \"成功\" : \"失败(\") &lt;&lt; iResult &lt;&lt; \")\" &lt;&lt; endl;\n        else\n                std::cout &lt;&lt; \"Scuess:订阅[\" &lt;&lt; ppInstrumentID[amount - 1] &lt;&lt; \"]行情成功\" &lt;&lt; std::endl;\n\n}\n</code><p>也不传个参数，则直接取全局对象来用，然后这些随意的随处可见的std::cout，printf， std::cerr，这代码技艺作为一个自称写了10多年C++的人来说真是令人叹为观止! <br><br>MdSpi.h是CThostFtdcMdSpi的派生类CMdSpi声明部分, 而MdSpi.cpp则是对应的实现部分, MdSpi.cpp接近6k行代码, 而下面四个函数, 就4800多行!</p><p>ModifyMap, 1700行+<br>ClearGuestOnlineHash, 300行+<br>InitGuestOnlineHash, 800行+<br>UpdatePriceHash, 1900行+</p><p>看到这里的时候我也是惊掉下巴，是怎么样复杂的代码非要这样实现呢。看到这里的时候一度不想继续看下去，感觉就像一只在吃*一样难受。不过不必细看才也猜得出来这几个函数所实现的逻辑是tick数据生成bar数据的，(上千行的函数, 真心没耐心看下去, 如果猜得不对还望指出)。</p><p>不能光指出问题自己没干货嘛，那么一般来讲tick生成bar应该怎么写呢？bar数据一般来讲包含以下几个信息：high、low、open、close。进入一个周期的第一个tick记录下open，并给high和low赋初值，周期最后一个tick记录下close，并发出bar信息。而1min, 5min, 1day, 1mon的bar除了周期不同，并没有其他不同。好，随手来写一段（徒手写, 请不要在意语法细节问题）：<br></p><code lang=\"cpp\">#include &lt;stdint.h&gt;\n\n#include &lt;vector&gt;\n#include &lt;functional&gt;\n#include &lt;unordered_map&gt;\n\n#include &lt;boost/any.hpp&gt;\n\nclass Bus\n{\npublic:\n    template&lt;class T&gt;\n    void send(const T &amp;t)\n    {\n        //...\n    }\n\n    template&lt;class T&gt;\n    void register_type(const std::function&lt;void (const T &amp;)&gt; &amp;cb)\n    {\n        _callbacks.insert({typeid(T).hash_code(), cb});\n    }\n\n    void run();\n\nprivate:\n    std::unordered_multimap&lt;size_t, boost::any&gt; _callbacks;\n};\n\nstruct Tick\n{\n    double bid;\n    double ask;\n    int32_t bidsize;\n    int32_t asksize;\n\n    double lastprice;\n};\n\n\ntemplate&lt;uint64_t PERIOD&gt;\nstruct Bar\n{\n    double open;\n    double close;\n    double high;\n    double low;\n};\n\nconstexpr uint64_t MIN = 120;    // 1min(500ms一次, 60s有120)\nconstexpr uint64_t HOUR = 7200;\nconstexpr uint64_t DAY = 172800;\n\ntypedef Bar&lt;MIN&gt; bar_1min_t;\ntypedef Bar&lt;HOUR&gt; bar_1hour_t;\ntypedef Bar&lt;DAY&gt; bar_1day_t;\n\ntemplate&lt;uint64_t PERIOD&gt;\nclass Generator\n{\npublic:\n    Generator(Bus &amp;bus)\n        : _bus(bus)\n        , _period(PERIOD)\n        , _ticks(PERIOD)\n        , _index(0)\n    {}\n\n    void init()\n    {\n        _bus.register_type(std::bind(&amp;Generator&lt;PERIOD&gt;::on_tick,\n                                     this));\n    }\n\n    void on_tick(const Tick &amp;tick)\n    {\n        switch(_index)\n        {\n            case 0:\n            {\n                _open = tick.lastprice;\n                _high = tick.lastprice;\n                _low = tick.lastprice;\n                ++index;\n                break;\n            }\n            case PERIOD-1:\n            {\n                _close = tick.lastprice;\n                if(_high &lt; tick.lastprice) _high = tick.lastprice;\n                if(_low &gt; tick.lastprice) _low = tick.lastprice;\n\n                _bus.send(Bar&lt;PERIOD&gt;{\n                              _open,\n                              _close,\n                              _high,\n                              _low\n                          });\n\n                _index = 0;\n                break;\n            }\n            default:\n            {\n                if(_high &lt; tick.lastprice) _high = tick.lastprice;\n                if(_low &gt; tick.lastprice) _low = tick.lastprice;\n                ++index;\n                break;\n            }\n        }\n    }\n\nprivate:\n    Bus &amp;_bus;\n\n    double _open;\n    double _close;\n    double _high;\n    double _low;\n\n    int32_t _index;\n};\n\nvoid on_min(const bar_1min_t &amp;bar)\n{\n    // ...\n}\n\nvoid on_day(const bar_1day_t &amp;bar)\n{\n    // ...\n}\n\n\nint main(int argc, char *argv[])\n{\n    Bus bus;\n    bus.register_type&lt;bar_1min_t&gt;(on_min);\n    bus.register_type&lt;bar_1day_t&gt;(on_day);\n\n    Generator&lt;MIN&gt; gen_1min(bus);\n    gen_1min.init();\n\n    Generator&lt;DAY&gt; gen_1day(bus);\n    gen_1day.init();\n\n    bus.run();\n\n    return 0;\n}\n\n</code><p>算是比较朴素的一段代码，也没使用上什么奇淫奇技。</p><p>所有号称性能比较屌的玩意，我都喜欢看看它的log。我们来看看quicklib的log是怎么实现的：<br></p><code lang=\"cpp\">#define LOG_LENGTH    100\nstruct LOGSTRUCT\n{\n        char log[LOG_LENGTH];\n};\nlist &lt;LOGSTRUCT&gt; loglist;\nlist &lt;LOGSTRUCT&gt;::iterator log_Iter;\n\nvoid LOG(char * msg)\n{\n        LOGSTRUCT tn;\n\n        memset(&amp;tn, 0, sizeof(LOGSTRUCT));\n        _snprintf_s(tn.log, sizeof(tn.log), sizeof(tn.log), \"%s\", msg);\n        EnterCriticalSection(&amp;g_csdata);\n        loglist.push_back(tn);\n        LeaveCriticalSection(&amp;g_csdata);\n        SetEvent(hEvent[EID_OnLog]);\n\n}\n</code><p>真是平淡无奇的log啊，snprintf把指针的内容打印到数组里面存起来, 然后放到全局的数组list里面。因为用的全局的对象(loglist)，这里需要用EnterCriticalSection和EnterCriticalSection把可能存在争用的资源给lock一下。</p><p>然后SetEvent发出个信号.(这个SetEvent会对应OnCmd函数里面的WaitForMultipleObjects, 这部分在讲quicklib的事件驱动机制的时候再详细讲)。</p><p>代码很简单, 问题倒不少, 呢首先功能太鸡肋了, 能接受char *这样的参数。</p><p>然后性能真是太shit了, 表现在几个方面:<br></p><ol><li>snprintf这玩意很慢很慢<br></li><li>其次假如调用是LOG(\"啦啦啦啦\"), 这样的时候, \"啦啦啦啦\"这一串字符常量是存储在特定的区域的, 处理字符常量只需要拷贝一个指针就可以了, 不需要拷贝整窜字符串. <br></li><li>这玩意是同步的, 同步的log你知道io有多慢吗????!!!<br></li><li>除此之外保护全局对象的lock, 为什么不用RAII来管理? 这个问题quicklib的所有全局对象都有。</li></ol><br>短短7行代码就暴露如此多的问题, 说框架性能多屌, 我是一丁点都不信的. 因为论坛字数限制本篇完, 下一篇继续带大家讲解\"神奇\"的quicklib。<br><h2><u>写在后面</u></h2><p>关注vn.py的朋友应该知道之前一直比较集中于新API接口对接、新交易功能开发、文档编写等方面，性能方面的问题因为vn.py项目核心开发团队所在的一些量化大机构中都有自己的低延时算法交易系统，所以没有专门去深入研究。</p><br><p>这次被Quicklib的作者调起了兴趣，也希望借着这个机会能集思广益，一方面彻底研究下vn.py性能方面的瓶颈所在（发现问题），另一方面看看有没有什么好的方法可以突破这个瓶颈（解决方案），毕竟对于一个管钱的交易员来说交易的利润才是最终追求。</p><br><br><p><u><b>vn.py项目的Github仓库：<a href=\"http://link.zhihu.com/?target=https%3A//github.com/vnpy/vnpy\" class=\"\" data-editable=\"true\" data-title=\"vnpy/vnpy\">vnpy/vnpy</a>，觉得还不错的话不妨来点个star!</b></u></p>","updated":"2017-04-07T05:22:20.000Z","canComment":false,"commentPermission":"anyone","commentCount":36,"likeCount":31,"state":"published","isLiked":false,"slug":"26224702","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-04-07T13:22:20+08:00","links":{"comments":"/api/posts/26224702/comments"},"url":"/p/26224702","titleImage":"https://pic1.zhimg.com/v2-967f6ce6a5cb24b004e46ba02578ebe0_r.png","summary":"","href":"/api/posts/26224702","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":36,"likesCount":31},"26254515":{"title":"突破GIL？? - 转载 - Quicklib 源码分析 2","author":"traderusingpython","content":"<p><b>提示：</b><b>干货</b><b>分析在第二段和第三段，想节省时间的朋友可以跳过第一段。</b><br></p><h2><u><b>写在前面</b></u></h2><p>周末陪家人出去玩了一天，回来后看到Quicklib的作者在我的两篇文章下发了不少重复的评论，简单总结下他的观点，也写一下我的回应。<br></p><p>观点1：vn.py的代码写的很烂，完全不屑于看。</p><p>回应1：作为一个非科班出身的程序员，我一直觉得自己代码写的不咋地，高手不屑于看我表示完全理解。</p><br><p>观点2：vn.py采用的是落后的多线程架构，Quicklib采用的异步IO架构性能要高得多。<br></p><p>回应2：才说不屑于看vn.py的代码，这就能知道vn.py采用的是落后的多线程架构，这个我只能表示不明觉厉。另外，和Quicklib作者相反，我正在仔细研究Quicklib的代码，希望可以理解其所谓的“异步IO”架构，受限于较低的代码阅读水平，还没完全看懂，我会继续努力。</p><br><p>观点3：Quicklib是Python的Node.js版本，性能远超PHP（指vn.py）。</p><p>回应3：这个需要靠代码分析和测试结果来说话，否则似乎给人一种“五菱宏光才是秋名山神车”的感觉？</p><br><br><p>观点4：Quicklib中的那部分vn.demo代码，是社区用户贡献的，和作者无关，接下来立即就会删除。<br></p><p>回应4：这点我表示完全理解，早期vn.py代码也有过比较混乱的阶段。不过想要项目未来能够成功，作者还是得看一眼社区的PR内容后再合并吧。</p><br><br><p>观点5：vn.py占据了先发优势，对Quicklib这个有潜在威胁的项目进行提前打压，本质好比2岁的孩子打10个月的孩子一样。</p><p>回应5：感谢对vn.py这么高的评价，不过个人觉得现在的完成度离2岁的孩子还很远。另外感谢社区用户的捧场，我作为嘉宾过去一年受邀参加过几次活动（PyCon2016、中国金融创新峰会等），演讲过程中对于国内其他的一些开源量化项目：tushare、easy trader、at_py、RQAlpha等都做了介绍和推荐，网上也还能找到相关的视频和报道。说我现在专门针对Quicklib进行提前打压，是在暗示所有这些我推荐过的项目都比不上Quicklib？</p><br><p>读者如果觉得有遗漏的观点请在文章下面留言哈，我会在下一篇里继续回应，现在进入正文部分了。</p><br><br><h2><u><b>正文</b></u></h2><p><b>作者：金融民工</b></p><p>上一篇看完log，这一篇我们来看看quicklib一直吹嘘所谓先进的事件驱动机制到底有何神奇之处，先来看看OnCmd这个函数：</p><code lang=\"cpp\">int OnCmd()\n{\nDWORD dw = WaitForMultipleObjects(MAX_EVENTNUM, hEvent, FALSE, INFINITE);\n\nswitch (dw)\n{\ncase WAIT_OBJECT_0 + EID_OnFrontDisconnected:\n\n// The process identified by h[0] (hProcess1) terminated.\nreturn SYSTEM_NETCONNECT_BREAK;\nbreak;\n\ncase WAIT_OBJECT_0 + EID_OnFrontConnected:\n\n// The process identified by h[1] (hProcess2) terminated.\nreturn SYSTEM_NETCONNECT_SCUESS;\nbreak;\n\ncase WAIT_OBJECT_0 + EID_OnRspUserLogin_Failer:\n\n// The process identified by h[2] (hProcess3) terminated.\nreturn SYSTEM_LOGIN_DENIED;\nbreak;\ncase WAIT_OBJECT_0 + EID_OnRspUserLogin_Scuess:\n\n// The process identified by h[2] (hProcess3) terminated.\nreturn SYSTEM_LOGIN_SCUESS;\nbreak;\ncase WAIT_OBJECT_0 + EID_OnRtnDepthMarketData:\n\n// The process identified by h[2] (hProcess3) terminated.\nreturn SYSTEM_NEWTICK;\nbreak;\ncase WAIT_OBJECT_0 + EID_IsErrorRspInfo:\n\n// The process identified by h[2] (hProcess3) terminated.\nreturn SYSTEM_SYSTEM_ERROR;\nbreak;\ncase WAIT_OBJECT_0 + EID_OnRspSubMarketData:\n\n// The process identified by h[2] (hProcess3) terminated.\nreturn SYSTEM_SUBCRIBE_SCUESS;\nbreak;\ncase WAIT_OBJECT_0 + EID_OnRspUnSubMarketData:\n\n// The process identified by h[2] (hProcess3) terminated.\nreturn SYSTEM_UNSUBCRIBE_SCUESS;\nbreak;\ncase WAIT_OBJECT_0 + EID_OnRspUserLogout:\n\n// The process identified by h[2] (hProcess3) terminated.\nreturn SYSTEM_LOGINOUT_SCUESS;\nbreak;\n\ncase WAIT_OBJECT_0 + EID_OnRspForQuote:\n\n// The process identified by h[2] (hProcess3) terminated.\nreturn SYSTEM_QRY_FORQUOTE;\nbreak;\ncase WAIT_OBJECT_0 + EID_OnLog:\n\n// The process identified by h[2] (hProcess3) terminated.\nreturn SYSTEM_LOG;\nbreak;\n\n}\n\nreturn SYSTEM_EMPTY;\n</code><p>不熟悉Windows sdk的同学看得有点懵是把，重点在WaitForMultipleObjects这个函数这里。这个函数详细参考请看<a href=\"https://msdn.microsoft.com/en-us/library/windows/desktop/ms687025(v=vs.85).aspx\" class=\"\" data-editable=\"true\" data-title=\"MSDN对应的词条\">MSDN对应的词条</a>，通俗点说就是它可以等待多个内核对象，直到参数所指定的OBJECT成为发射信号状态(SetEvent函数则是设置发射状态)才返回。那么也就是说可以使用SetEvent与WaitForMultipleObjects来做同步。明白了这一点剩下的事情就简单了。来看一个OnFrontConnected的例子：<br></p><code lang=\"cpp\">void CMdSpi::OnFrontConnected()\n{\nstd::cout &lt;&lt; \"---&gt;&gt;&gt; \" &lt;&lt; __FUNCTION__ &lt;&lt; std::endl;\n\nSetEvent(hEvent[EID_OnFrontConnected]);\n///用户登录请求\nReqUserLogin();\n}\n</code><p>OnFrontConnected回调被调用后，SetEvent(hEvent[EID_OnFrontConnected]); 设置一个信号。这时候OnCmd里面的WaitForMultipleObjects等待到该信号，返回<br>落在case WAIT_OBJECT_0 + EID_OnFrontConnected:这个分支，然后返回了SYSTEM_NETCONNECT_SCUESS(8005)。<br><br>那么OnCmd的调用者是在哪呢? 在Python这边, 我们来看一段TDThread(交易线程)的代码<br></p><code lang=\"text\">def TD_OnUserLoginDenied():\n    # 登录被拒绝\n    print \"---------------TD_OnUserLoginDenied---------------\"\n\n\ndef TD_OnUserLoginErrPassword():\n    # 登录密码错误\n    print \"---------------TD_OnUserLoginErrPassword---------------\"\n\n\ndef TD_OnUserLogout():\n    # 登出成功\n    print \"---------------TD_OnUserLogout---------------\"\n\n\ndef TD_OnFrontConnected():\n    # 连接成功\n    print \"---------------TD_OnFrontConnected---------------\"\n...\n\ntddict = {\n    TD_EMPTY: TD_OnEmptyCmd,\n    TD_LOGIN_SCUESS: TD_OnUserLogin,\n    TD_LOGIN_DENIED: TD_OnUserLoginDenied,\n    TD_LOGIN_ERRORPASSWORD: TD_OnUserLoginErrPassword,\n    TD_LOGINOUT_SCUESS: TD_OnUserLogout,\n    TD_NETCONNECT_SCUESS: TD_OnFrontConnected,\n    TD_NETCONNECT_BREAK: TD_OnFrontDisconnected,\n    TD_NETCONNECT_FAILER: TD_OnFrontConnectedFailer,\n    TD_ERROR: TD_OnError,\n    TD_ORDER_INFO: TD_OnOrder,\n    TD_SETTLEMENTINFOCONFIRM: TD_OnSettlementInfoConfirm,\n    TD_MAXORDERVOLUME: TD_OnMaxOrderVolume\n}\n\nwhile (1):  # 死循环，反复执行\n    tddict[trader.OnCmd()]()\n\n</code><p>代码逻辑也很简单，tddict这个dict存了信号的编号到对应回调函数的映射关系。然后当OnCmd等待到信号返回的时候，对应的callback得到调用。也是平淡无奇的代码，和对外宣传的效果可是相差甚远啊。用什么滤镜美颜都达不到对外宣称的效果啊......</p><p><br>对外宣传大概是这样的:<br></p><ul><li>quicklib架构很棒, 吊打vnpy<br></li><li>quicklib性能很屌, 吊打vnpy<br></li><li>quicklib是10年+经营的资深程序员写的各种棒, vnpy是做交易的人写的(言下之意在讲不是专业写代码的外门汉, 代码写不利索)各种屎<br></li><li>quicklib没有GIL(哈哈哈, 请允许我又笑一下), vnpy有GIL<br></li><li>quicklib是正途, 用vnpy的都是脑残. (哈哈哈, 请允许我又笑一下)<br></li><li>quicklib可以接受10w个链接(哈哈哈, 请允许我又笑一下)<br></li><li>quicklib写了大量底层(哈哈哈, 请允许我又笑一下)<br></li></ul><br><br>而实际上呢?<br><br><p>先说架构，quicklib充其量算封装个CTP，这样也能称之为框架，吹架构了......且先不说质量(没办法讲质量, 真是太差劲了)，就功能上实际上离一个交易框架还相差甚远。这还是回到是蠢还是坏，或者又蠢又坏的问题上。</p><p><br>然后是性能，这里的事件驱动用各种list+SetEvent和WaitForMultipleObjects，在原理上和用个queue没什么本质区别。不明白有什么好吹嘘的，而实际上也并不能避免GIL(你以为GIL只有显示的调用才有?)，log也是同步阻塞的。不明白吹嘘的资本在哪。</p><p><br>包装了个CTP就是写了大量的底层??!!!(想到那4800行的四个函数, 又想笑一下)<br></p><p> 好吧我笑抽了, 明天有兴趣再继续写交易的部分吧.<br></p><br><br><h2><u><b>写在后面</b></u></h2><p>看第一篇分析的时候还有点懵，看完第二篇对Quicklib的运行方式大概有个概念了：</p><ol><li>Python环境下的主线程中启动一个死循环（主事件循环），运行OnCmd函数，等待C++环境下的WaitForMultipleObjects信号被触发；<br></li><li>底层CTP API收到数据后，调用原生SPI的回调函数并设置事件（SetEvent），触发上一步的信号，通过一个Swtich来返回本次回调函数触发类型的信息；</li><li>Python环境下收到这个触发类型的信息后，去字典中查询对应的Python回调处理函数，并立即调用</li></ol><br>在这个模式下，Python环境中只需要一个主线程而无需启动其他的线程，Python虚拟机确实也就没有创建全局锁GIL对象。不过感觉似乎这个运行方式只能算是没有用到GIL，谈不上解决了GIL的问题（当然可能Quick作者压根就没这么说过，又是我理解错了他的意思），而且对于交易程序而言还有几个的问题：<ol><li>数据无法从C++环境中到达Python环境中，OnCmd()返回的只有底层接口回调函数通知的类型，而没有具体的数据，也就无法使用Python开发策略，这里猜测可能Quicklib是选择开发了一些用于在Python中主动调用的函数来实现数据获取；</li><li>对于只连接一个CTP接口的交易程序而言是用不着GIL了，但是如果要同时连接多个CTP接口（分账户）或者同时连接其他市场的接口（跨市套利），这个架构就无能为力了，否则为每个接口开启一个死循环必然要用到多线程，并创建GIL；</li><li>因为Python中只能有一个线程，所以这个交易程序就无法和外部通讯了，GUI界面也好，运行Web服务器也好，都需要另外的线程。</li></ol><p>以上只是截止目前我对Quicklib项目的理解，应该还有很多不足的地方，读完民工的分析文章后我会再深入的看下Quicklib的源代码。</p><br><p><b><u>vn.py项目的Github仓库：<a href=\"http://link.zhihu.com/?target=https%3A//github.com/vnpy/vnpy\" class=\"\" data-editable=\"true\" data-title=\"vnpy/vnpy\">vnpy/vnpy</a>，觉得还不错的话不妨来点个star!</u></b></p>","updated":"2017-04-09T03:45:31.000Z","canComment":false,"commentPermission":"anyone","commentCount":40,"likeCount":17,"state":"published","isLiked":false,"slug":"26254515","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-04-09T11:45:31+08:00","links":{"comments":"/api/posts/26254515/comments"},"url":"/p/26254515","titleImage":"https://pic2.zhimg.com/v2-53b98e137d81f725cd2941da956f05c1_r.jpg","summary":"","href":"/api/posts/26254515","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":40,"likesCount":17},"26262572":{"title":"突破GIL...... - 转载 - Quicklib 源码分析 3、4","author":"traderusingpython","content":"<h2><b><u>写在前面</u></b></h2><p>星期天又快结束了，好久没有一个周末的情绪如此跌宕起伏，从开始对于技术研究方面的期待，到目前对于Quicklib作者一些行为的懵逼.</p><p>这次直接合并发完金融民工对于Quicklib源代码的分析文章的3和4。</p><br><h2><b><u>正文</u></b></h2><p><b>作者：金融民工</b></p><p><b><u>原文3</u></b></p><p>今天继续带大家一起来看看神奇的quicklib。来看看它的交易部分。</p><p>vs打开之后是这样。<br></p><img src=\"v2-7d10bfa9974b57587ea1ab21d028f18e.png\" data-rawwidth=\"367\" data-rawheight=\"386\"><p> 从目录结构上看，交易部分就是包装CTP，外加一个gzip(鬼知道gzip有没有用到?)， 在加一个共享内存(鬼知道有没有用到)。<br></p><br>习惯性的grep一下，咦似乎也没什么地方用到gzip啊....然后又grep了一下，发现也没什么地方用共享内存啊......无伤大雅我们继续。<br><br>交易这边的套路和行情那边是一致的，CTPTradeSpi对应的头文件和源文件对应CThostFtdcTraderSpi的派生类QLCTPTraderSpi的声明和实现。<p>QLCTPInterface.h 和QLCTPTradeAgenter.cpp对应把各种函数包装一次然后提供给Python那边调用。</p><p>这一篇具体讲代码之前先来设定几个阅读的小目标：<br></p><ol><li>Python怎么调用C++的代码?</li><li>CTP里面C++的结构体是怎么暴露给Python这边用的?<br></li><li>Quicklib对外宣传那么屌, 有什么黑科技吗?<br></li><li>这玩意能上实盘使用吗?</li></ol><p>好了正式开始，<u>先看看quicklib里面是怎么样用Python调用C++的</u>。在此之前我们得现有一些前置知识，Python可以使用ctypes很方便的调用C的动态链接库，举个例子：</p><code lang=\"cpp\">//add.c\nint add(int a, int b)\n{\n    return a+b;\n}\n</code><p>compile成动态库，以gcc为例：<br></p><code lang=\"text\">gcc -o libadd.so -shared -fPIC add.c\n</code><p>如果是用g++来编译，那么add.c里面需要用extern \"C\"包起来，类似这样，至于为什么需要用这个extern \"C\"，问题太基础，就不在这里浪费唇舌了，有兴趣可以看看<a href=\"http://stackoverflow.com/questions/1041866/in-c-source-what-is-the-effect-of-extern-c\" class=\"\" data-editable=\"true\" data-title=\"这里\">这里</a>。<br></p><code lang=\"cpp\">extern \"C\"\n{\n    int add(int a, int b)\n    {\n        return a+b;\n    }\n}\n</code><p>然后python里面通过ctypes来调用：<br></p><code lang=\"cpp\">import ctypes\nlib = ctypes.cdll.LoadLibrary(\"./libadd.so\")\nprint lib.add(1, 2)\n</code><p>好了，这是调用C的那么调用C++呢? 很简单啊，再给包一层C函数，来个例子：<br></p><code lang=\"cpp\">class Test\n{\npublic:\n    int add(int a, int b)\n    {\n        return a+b;\n    }\n}\n\nextern \"C\"\n{\n    int add(int a, int b)\n    {\n        Test t;\n        return t.add(a, b);\n    }\n}\n</code><p>g++来编译一下：<br></p><code lang=\"text\">g++ -o libtest.so -shared -fPIC test.cpp\n</code><p>Python这边同样是使用ctypes来加载就可以用了：<br></p><code lang=\"text\">import ctypes\nlib = ctypes.cdll.LoadLibrary(\"./libtest.so\")\nprint lib.add(1, 2)\n</code><p>一切都很简单对吧，没什么黑科技，quicklib里面也是这么做的，只是写起来就丑了很多。</p><p>第二个问题，<u>CTP里面C++的struct，怎么传递给Python里面使用呢</u>，还是用的ctypes啊。可以看它的CTPTradeType.py这里，没什么黑科技。那么Quicklib使用这一种方式来让Python调用C++存在哪些槽点呢? 来理一下从C++到Python都经历了哪些内容：</p><ol><li>CTP代码是C++的，为了让ctpyes调用，必须把类的成员函数都重新用C包了一层，变成一个个普通的c函数。因为load动态库都是一个一个函数，所以在Python这边又把这一个一个函数拼成一个类(代码在CTPTrader.py这里)；<br></li><li>听起来感觉没有哪里不对是吧，但实际上这里是又非常多的重复性工作。如果quicklib的作者懂boost::python，懂pybind11这样的东西的话，我相信代码不会是这样，作为一个自称写了十多年C++的所谓\"资深\"程序员，不懂boost感觉怎么都说不过去呐......传闻中一年经验用十年，大抵便是如此吧。</li></ol><br>第三个问题，<u>我觉得不应该在回答这个问题了</u>......<br><br>第四个问题，<u>号称多家机构在用啊</u>，不知道是这些机构蠢呢，还是作者坏呢。test都没有的玩意(我尽力找了，一段类似test之类的代码都没有，有人找到了的话能告诉我吗......)，真有人敢拿来实盘？当真金白银不是钱啊......<br><br>这几个问题之后想必对quicklib应该有一个比较初步的了解了，了解了大概的轮廓就可以详细的看代码了。先来看C++派生CTPCThostFtdcTraderSpi的这部分。<p>QLCTPTraderSpi这个类里面，包含两方面的内容：<br></p><ol><li>override CThostFtdcTraderSpi的几个virtual函数, 这几个函数都是回调函数(OnRsp*, OnRtn*)</li><li>调用CThostFtdcTraderApi的几个对外请求的函数<br></li></ol><br>正准备讲下单函数, 咦貌似没有定义：<img src=\"v2-b3a0cbd0ca73dd1db97afc77c060b500.png\" data-rawwidth=\"532\" data-rawheight=\"164\"><p> 好吧，到对应的源文件搜索reqorderinsert也没搜到，下单都没有啊......还交易框架呢，没关系看看其他的，来看一下撤单的逻辑(DeleteOrder)：<br></p><code lang=\"cpp\">int QLCTPTraderSpi::DeleteOrder(char *InstrumentID, DWORD orderRef)\n{\n        //错误返回-1是和正常冲突的吗？\n        if (!InstrumentID)\n        {\n                return -1;\n        }\n        std::cout &lt;&lt; __FUNCTION__ &lt;&lt; std::endl;\n        CThostFtdcInputOrderActionField ReqDel;\n        ::ZeroMemory(&amp;ReqDel, sizeof(ReqDel));\n        strcpy(ReqDel.BrokerID, gBrokerID.c_str());\n        strcpy(ReqDel.InvestorID, gUserID.c_str());\n        strcpy(ReqDel.InstrumentID, InstrumentID);\n        ::sprintf(ReqDel.OrderRef, \"%012d\", orderRef);\n        ReqDel.FrontID = FRONT_ID;\n        ReqDel.SessionID = SESSION_ID;\n        ReqDel.ActionFlag = THOST_FTDC_AF_Delete;\n        int iResult = mpUserApi-&gt;ReqOrderAction(&amp;ReqDel, ++(iRequestID));\n\n        if (iResult != 0)\n                cerr &lt;&lt; \"Failer: 撤单 : \" &lt;&lt; ((iResult == 0) ? \"成功\" : \"失败(\") &lt;&lt; iResult &lt;&lt; \")\" &lt;&lt; endl;\n        else\n                cerr &lt;&lt; \"Scuess: 撤单 : 成功\" &lt;&lt; endl;\n\n        return iResult;\n}\n</code><p>之前就吐槽过这种随意的，随处可见的cout，cerr，就这样的代码你吹高性能，不知道那种对此深信不疑的萌新到底有没有最基本的辨识能力。</p><p>槽点太多, 挑个重点讲。iRequestID这个是个int，请自行补脑一下，以下语句多线程下会出现什么：<br></p><code lang=\"cpp\">int iResult = mpUserApi-&gt;ReqOrderAction(&amp;ReqDel, ++(iRequestID));\n</code><p>作者基础还是很欠缺火候啊...<br><br>再来看看查询持仓，OnRspQryInvestorPosition这里。代码太长就不全贴出来，入眼第一眼就有问题啊，这个函数第二个参数CThostFtdcRspInfoField *pRspInfo直接就略过不用了，然而作者不知道即便是返回错误信息的时候pInvestorPosition也有可能不为nullptr吗。这个地方得加一段：<br></p><code lang=\"cpp\">if(pRsoInfo != nullptr &amp;&amp; pRsoInfo.ErrorID != 0) return;\n</code><p>然后下面的具体查询仓位的代码，粗略看一遍就发现，这里根本没有考虑不同交易所对昨仓的处理。这是一个很严重的问题啊，请自行补脑一下，当自己的程序化交易软件认为的仓位和实际的仓位不符的时候，是多麽容易照成交易事故的。</p><p>这又暴露了另外一个问题，作者对业务逻辑了解得也很差啊...... 技术不行，业务也不行，这又的产物有人敢实盘，单就这份勇气，也是值得赞赏的。</p><p>看点简单的好了，来看看OnRspUserLogin，用户login后产生的回调：<br></p><code lang=\"text\">CThostFtdcRspUserLoginField tn;\n            memset(&amp;tn, 0, sizeof(CThostFtdcRspUserLoginField));\n</code><p>咦，这里用memset，之前DeleteOrder的时候用的是ZeroMemory呢：<br></p><code lang=\"cpp\">CThostFtdcInputOrderActionField ReqDel;\n    ::ZeroMemory(&amp;ReqDel, sizeof(ReqDel));\n</code><p>突然让我回忆起以前读中学的时候，英文老师总说多用高级词汇不要整天but，but，but要用however!</p><p>然后下面的：<br></p><code lang=\"text\">EnterCriticalSection(&amp;g_csdata);\n            loginlist.push_back(tn);\n            LeaveCriticalSection(&amp;g_csdata);\n            SetEvent(hEvent[EID_OnRspUserLogin_Scuess]);\n</code><p>lock一下，再弄个信号，这部分在讲行情的时候讲过了。再接下来：<br></p><code lang=\"text\">ReqSettlementInfoConfirm();\n            Sleep(3000);\n</code><p>这个Sleep(3000)是何意...不是说好了和nodejs一样全异步吗<br></p><p>再来看看init函数, 其中注册柜台前置<br></p><code lang=\"text\">    mpUserApi-&gt;RegisterFront((char *)gTDFrontAddr[0].c_str());\n    mpUserApi-&gt;RegisterFront((char *)gTDFrontAddr[1].c_str());\n    mpUserApi-&gt;RegisterFront((char *)gTDFrontAddr[2].c_str());\n</code><p>擦这个gTDFrontAddr不能是一个set吗, 然后for一下, 非要这样写.<br><br>再来看看OnRtnOrder：<br></p><code lang=\"cpp\">void QLCTPTraderSpi::OnRtnOrder(CThostFtdcOrderField *pOrder)\n{\n    if (!pOrder)\n    {\n        return;\n    }\n\n    std::cout &lt;&lt; __FUNCTION__ &lt;&lt; std::endl;\n    int orderRef = ::atoi(pOrder-&gt;OrderRef);\n    ::WaitForSingleObject(ghTradedVolMutex, INFINITE);\n    gOrderRef2TradedVol[orderRef] = pOrder-&gt;VolumeTraded;\n    ::ReleaseMutex(ghTradedVolMutex);\n\n    CThostFtdcOrderField tn;\n    memset(&amp;tn, 0, sizeof(CThostFtdcOrderField));\n    memcpy_s(&amp;tn, sizeof(tn), pOrder, sizeof(CThostFtdcOrderField));\n\n    EnterCriticalSection(&amp;g_csdata);\n    orderlist.push_back(tn);\n    LeaveCriticalSection(&amp;g_csdata);\n    SetEvent(hEvent[EID_OnRspOrder]);\n}\n</code><p>gOrderRef2TradedVol[orderRef] = pOrder-&gt;VolumeTraded; 这个地方看着就有点奇怪，点到定义发现是这样的：<br></p><code lang=\"text\">std::map&lt;int, int&gt; gOrderRef2TradedVol;\n</code><p>使用到的地方主要在这里QryTradedVol这个函数：<br></p><code lang=\"text\">int QryTradedVol(int OrderRef)\n{\n        int ret = -1;\n        ::WaitForSingleObject(ghTradedVolMutex, INFINITE);\n        if (gOrderRef2TradedVol.find(OrderRef) != gOrderRef2TradedVol.end())\n        {\n                ret = gOrderRef2TradedVol[OrderRef];\n        }\n        ::ReleaseMutex(ghTradedVolMutex);\n        return ret;\n}\n</code><p>看逻辑是根据orderRef查询成交数量的。那么这么写有什么问题呢? 问题大大的有，我们下一个单的数量可能是大于1的，而大于1的时候，是又可能出现部分成交的情况，<b><u>而这里的代码丝毫没有考虑部分成交的情况的处理，这里只是处理了上一次成交，这有事一个会使程序认为的仓位和实际仓位不匹配的情况。</u></b></p><p>哎......我已经无力吐槽了。<br><br>这代码问题层出不穷，漏洞百出，真是看不下去了，今天先到这里吧，太恶心了.....<br></p><p><b><u>原文4</u></b></p><p>出门运动了一圈，缓了一下，决定还是继续写......讲代码之前说一些无关技术的东西吧。<br><br>也许有人想问，这个源码分析系列的写作动机是什么？是为了黑同行露个脸蹭热度吗？</p><p>不不，一切只为了心中那股浩然正气，金融圈子到处充斥着各类骗子，私以为出了传销之外，骗子最多的行业非金融行业莫属，然作为一个有正气的社会主义接班人，实在没有办法眼睁睁的看着这种骗子到处坑蒙拐骗。<br><br>虽然厌恨骗子，但是为了尊重个人隐私，QQ已经涂抹掉了。<br></p><img src=\"v2-70b059cea17b228670e5e3137c9452f6.png\" data-rawwidth=\"635\" data-rawheight=\"100\"><p> 做人就不能脚踏实地吗......去年赚300亿啊，比进去的徐总还屌呢。编笑话能认真严肃一点吗? 类似的言论挺多的，就不一一列举了。现在九年义务教育都普及了，为什么还那么多毫无辨识能力的脑残粉啊......<br></p><br>另外有人私信我说：<p>\"你屌为什么你不fork帮人家改改? 为什么只嘴炮不做实事?\"</p><p>\"你屌为什么自己不开源个东西? \"</p><p>这类问题我原本是拒绝回答的，结果这样问的人还挺多，就在这里统一回答一下。</p><p>不是太明白，为什么要帮个骗子改代码呢，帮他我岂不是共犯? 帮凶? 助纣为虐? 我不理解问这种问题的人到底是怎么想的，所以无论如何，鄙人都不会帮这类骗子改代码的，提这种问题的人也是搞笑!<br><br>而对于自己为什么不开源个东西，保密协议在身，是不会有什么金融相关的开源项目的，大家也别期待。</p><p>好了继续来撸代码，C++部分看不下去了，换个口味看看Python部分好了。</p><p>同样的, 开始之前先设几个小目标：</p><ol><li>对外宣传的低cpu占用是什么原理?</li><li>低cpu占用就是所谓的高性能吗?<br></li></ol><br>这同学经常吹说quicklib订阅多少多少个行情才占用百分之多少的cpu，我们来一探究竟代码里面是如何实现的，期货行情/Release/QuickLibDemo.py这里。<br><p>直接看main函数好了，删除了注释后，剩余代码如下：<br></p><code lang=\"python\">def main():   \n    #除了从配置文件读取注册服务器地址外，还可用RegisterFront添加注册多个行情服务器IP地址。稍后给出不读配置文件，只使用RegisterFront注册行情服务器地址的例子\n    if False:\n        #已从配置文件读取3个服务器地址，这里可以不添加注册了\n        market.RegisterFront(u\"tcp://180.168.146.187:10031\") #添加注册行情服务器地址1\n        market.RegisterFront(u\"tcp://180.168.146.187:10031\") #添加注册行情服务器地址2\n        market.RegisterFront(u\"tcp://180.168.146.187:10031\") #添加注册行情服务器地址3\n    \n    if True:\n        #订阅品种zn1610，接收Tick数据,不根据Tick生成其他周期价格数据,但可根据AddPeriod函数添加周期价格数据的设置            \n        market.Subcribe('zn1705')\n        market.Subcribe('ag1706')\n\n    else:\n        #配置文件订阅函数下个版本修复，本例暂时采用Subcribe方法订阅\n        market.ReadInstrumentIni()\n    \n    #给au1612添加根据tick生成的周期，尽量避免添加不适用的周期数据，可以降低CPU和内存占用\n    market.AddPeriod('ag1706',YT_M1)   #添加M3周期（未在Subcribe、Subcribe1~Subcribe8函数中指定的周期，可以在本函数补充该品种周期，可多次调用函数设置同时保存多个周期）\n    market.AddPeriod('ag1706',YT_M3)   #添加M3周期（未在Subcribe、Subcribe1~Subcribe8函数中指定的周期，可以在本函数补充该品种周期，可多次调用函数设置同时保存多个周期）\n\n    print ('number:',  market.InstrumentNum)\n   \n    #字典保存各个合约tick计数，用于判断多少次tick计算1次策略，默认为0，从0开始计数\n    perdealdict={\"zn1701\":0,\"cu1701\":0,\"rb1706\":0}\n    while(1):  #死循环  \n        #打印自动生成的1分钟周期的数据\n        \n        print u'最近5个1分钟周期值'\n        print u'-----------begin--------------'\n        #打印该品种显示3分钟周期最近5个周期的收盘价格，若价格&gt;0表示已接收到数据，否则还未接收到足够的Tick生成周期K线的数据\n    \n        for i in range(0, 5):\n            tempclose=market.GetPeriodData('ag1706',YT_M1,YT_CLOSE,i)\n            if tempclose&gt;0:\n                print tempclose\n        print u'-----------end----------------'\n        time.sleep(5)\n</code><p>其他内容先别看了cpu占用之谜在于time.sleep(5)这一句，这里是sleep 5s啊......什么都不做5s啊，500ms一次tick数据，这其中你错过了10次啊。cpu占用低说明cpu没事干，这一点从来就不是评判性能高低的凭据。我们来搜索一下sleep有多少地方用呢?<br></p><img src=\"v2-af85bc6843eac3c315de7f4f524162f2.png\" data-rawwidth=\"1085\" data-rawheight=\"465\"><p> 基本上所有地方都有在用呢，就问你怕不怕.。<br></p><br>那么cpu占用率低就是所谓的高性能吗?<p>不! 这从来就不是一个充要条件，倘若你的处理逻辑时耗足够低，调用次数不频繁的时候，那么是可以看到较低的cpu占用的，而quicklib这里用sleep是几个意思呢？sleep后thread挂起，这期间什么都干不了，而时间再流逝，行情在发过来，你遗漏掉了那么多行情没有处理，却在鼓吹高性能？ 妈的真是又蠢又坏啊......<br><br>再来看看期货行情的example/读两种下单交易例子/QuickLibDemo.py这里的main.py：</p><code lang=\"python\">def main():\n    retLogin = trader.Login()  #调用交易接口元素，通过 “ 接口变量.元素（接口类内部定义的方法或变量） ” 形式调用\n    if retLogin==0:\n       print u'登陆交易成功'\n    else:\n       print u'登陆交易失败'\n\n    #读取合约订阅的配置文件\n    market.ReadInstrumentIni()\n    \n    #设置拒绝接收行情服务器数据的时间，有时候（特别是模拟盘）在早晨6-8点会发送前一天的行情数据，若不拒收的话，会导致历史数据错误，本方法最多可以设置4个时间段进行拒收数据\n    market.SetRejectdataTime(0.0400, 0.0840, 0.1530, 0.2030, NULL, NULL, NULL, NULL)\n\n    print ('number:',  market.InstrumentNum)\n\n    while(1):  #死循环，反复执行\n           print(u\"Wait for a New Cmd(MD)\\n\")\n           #判断是否有新Tick数据，while循环不需要Sleep,当没有新Tick时，会处在阻塞状态\n           mddict[market.OnCmd()]()\n           print(u\"Get A New cmd(MD)\\n\")\n           #                                品种代码    多空方向    开仓还是平仓  市价或现价   价格  下单数量\n           #下单函数原型 InsertOrder(self, instrumentID, direction,  offsetFlag, priceType,  price,   num):              \n           OrderRef = trader.InsertOrder('zn1705', QL_D_Buy, QL_OF_Open, QL_OPT_LimitPrice, market.LastPrice('zn1705')+10, 1)\n           #交易记录写日志文件\n           #market.LogFile(u'traderecord.csv',u'交易下单  zn1705  QL_D_Buy')\n           time.sleep(1)\n           #撤销所有未成交的委托单\n           ret = trader.DeleteOrder('zn1705', OrderRef) \n           OrderRef = trader.InsertOrderByRate('zn1705', QL_D_Buy, QL_OF_Open, QL_OPT_LimitPrice, market.LastPrice('zn1705')+10, 0.25,QL_Dynamic_Capital,5)\n           #交易记录写日志文件\n           #market.LogFile(u'traderecord.csv',u'交易下单  zn1705  QL_D_Buy')\n           time.sleep(1)\n           #撤销所有未成交的委托单\n           ret = trader.DeleteOrder('zn1705', OrderRef)\n</code><p>这里有一个挺有趣的设置时间的函数：</p><code lang=\"text\">market.SetRejectdataTime(0.0400, 0.0840, 0.1530, 0.2030, NULL, NULL, NULL, NULL)\n</code><p>真棒，用double来表示时间......真是天马行空的设计啊。</p><p>这一段代码存在的问题，其他示例里面都存在，比如没有个正经的timer，只会一股脑sleep。到处sleep的代码同步的log，到处都有的std::cout, prinf, std::cerr竟然对外宣传说\"最大的特点就是采用异步式 I/O 与事件驱动的架构设计\"...真是挺可怕的，你当std::cout这些就不是io了吗? 为什么人能够厚颜无耻到这般地步, 又蠢又坏啊......</p><br><p><img src=\"v2-083ae627e5591afb9c0130ea7dd220ee.png\" data-rawwidth=\"580\" data-rawheight=\"327\">挣扎了一下, 还是没有办法继续看下去......<br></p><br><h2><b><u>写在后面</u></b></h2><p>看到这里，我首先必须对金融民工表示一下感谢：<b><u>这种质量的代码都看完了，还写了非常全面的4篇分析文章，要是我自己全看完估计得吐了，这种毅力不服不行！</u></b></p><p>之前虽然对Quicklib作者的行为感觉挺Low，但他一直信誓旦旦坚称Quicklib的性能显著超过vn.py的自信，让我一度以为人家只是一位性格上比较怪的“技术大神”，希望自己可以通过一个系列的分析文章能取到点经，也来改进下vn.py。</p><p>不过到现在我基本已经绝望了，浪费了包括一个周末在内前后4天的时间，可能得不到什么有价值的技术改进。从民工的分析中可以很明显看出Quicklib作者的两个情况：</p><p>1. 没有实盘交易经验，程序内大量的代码存在交易业务逻辑上的错误，这还是相对比较简单的CTP期货接口而已；</p><p>2. 没有写过生产环境中的量化交易系统，代码逻辑稳健性很低，最多是业余爱好者的范畴，弄了个map来根据委托号查询成交数量的逻辑我真是醉了。</p><p>同时这几天社区用户和量化圈内的一些朋友，也通过各种渠道告诉了我Quicklib作者以前的一些黑历史，结合自己这几天见识到的他的行为，基本也有了个数。本着专业性的原则就不在我的专栏里说了，有兴趣的朋友可以在这个问题下的回答里看到一些情况：<a href=\"https://www.zhihu.com/question/58183367\" data-title=\"如何评价最近vn.py作者和Quicklib作者关于Python量化交易系统在架构设计方面的争论？\" class=\"\" data-editable=\"true\">如何评价最近vn.py作者和Quicklib作者关于Python量化交易系统在架构设计方面的争论？</a></p><p>之前已经有不少人提醒我Quicklib作者搞的整个事情是想蹭热度给自己增加曝光度，我开始还觉得不至于。vn.py项目从一开始的时候我就已经表达过会永久保持开源做下去，现在项目的成熟度我觉得也就算上路而已，谈不上有什么成就。但是Quicklib的作者这几天在我的专栏文章和问题回答下面，发一些高度重复的评论，今天已经让人无语到开始直接复制粘贴刷屏，我还真是不得不信了。也懒得在这件事情上再浪费时间，决定直接加黑了事。</p>","updated":"2017-04-10T05:24:40.000Z","canComment":false,"commentPermission":"anyone","commentCount":21,"likeCount":64,"state":"published","isLiked":false,"slug":"26262572","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-04-10T13:24:40+08:00","links":{"comments":"/api/posts/26262572/comments"},"url":"/p/26262572","titleImage":"https://pic3.zhimg.com/v2-3ffefff735196f0f80864cd66fc73982_r.jpg","summary":"","href":"/api/posts/26262572","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":21,"likesCount":64},"26382004":{"title":"vn.py发布v1.6","author":"traderusingpython","content":"之前v1.6预定的是Spread Trading模块的开发，不过因为两个商品期权上市的关系最近比较忙，就选择在v1.6里提前了英文版翻译的开发，接下来的v1.7将会是Spread Trading。<p>目前完成的主要英文翻译内容包括：</p><p>1. vn.py的英文介绍<a href=\"https://github.com/vnpy/vnpy/blob/master/README-en.md\" data-editable=\"true\" data-title=\"README-en.md\">README-en.md</a></p><p>2. vn.trader的英文翻译，可以通过VT_settting.json来进行配置，已经翻译的部分包括：</p><ul><li>主界面</li><li>风控模块、合约查询模块、CTA策略模块</li><li>ctpGateway和ibGateway的相关输出</li><li>vtConstant中的常量</li></ul><p>基本上实现了对于英文用户来说可以开箱即用，放个截图：<img src=\"v2-19edabd0f1316f1dc5ef0857a8a2b4d4.jpg\" data-rawwidth=\"1936\" data-rawheight=\"1048\"></p><br><p>其他更新包括：</p><p><u>功能部分</u></p><ol><li>增加合约查询组件的过滤功能</li><li>重新整理了项目的文件夹配置，所有的API都放到了vn.api目录下，所有vn.trader的接口都放到了gateway目录下</li></ol><p><u>接口方面</u></p><ol><li>修复CTP接口认证部分的bug</li><li>增加委托拒单状态STATUS_REJECTED</li><li>修改ctpGateway的onRspQryInvestorPosition为更加简洁的实现</li></ol><p><u>策略模块方面</u></p><ol><li>增加TradeBlazer数据导入，感谢社区cooooo的贡献</li><li>增加对重复成交推送的过滤</li><li>增加KingKeltner策略的移动止损出场功能</li><li>增加回测和实盘时对最小合约价格变动的取整</li><li>增加退出策略模块时询问是否要保存持仓到数据库</li><li>增加回测时对于涨跌停情况的无法成交过滤</li><li>增加seaborn优化回测显示效果，感谢社区armtt的贡献</li></ol>","updated":"2017-04-15T08:01:08.000Z","canComment":false,"commentPermission":"anyone","commentCount":22,"likeCount":36,"state":"published","isLiked":false,"slug":"26382004","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-04-15T16:01:08+08:00","links":{"comments":"/api/posts/26382004/comments"},"url":"/p/26382004","titleImage":"https://pic3.zhimg.com/v2-ed1c5feefaf71ad6206e999a3e389606_r.png","summary":"","href":"/api/posts/26382004","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":22,"likesCount":36},"27296132":{"title":"vn.py发布v1.6.2","author":"traderusingpython","content":"过去两个月发布的v1.6和v1.6.1给大家带来了很多困扰，主要是因为项目规模扩大后模块间依旧采用的Python隐式相对引用的Import方式，对运行时的目录很敏感，对于不熟悉Python细节的用户很容易发生运行vn.py时找不到某个模块的问题。<p>试了不少打补丁的方式效果都不怎么样，狠下心花了一个多月的时间将原来计划放在v2.0的重构提前，将整个项目结构进行了重新设计，并将所有的py文件间采用绝对引用的Import方式，并且将vn.py项目安装到Python的site-package目录下，使得用户现在可以采用更加灵活的方式来管理自己的多个量化交易应用程序。</p><p>其他的一些更新包括：</p><ol><li>提供build.bat一键安装和pip快速安装两种安装方式，大幅降低入门时的痛苦程度（相信我真的效果很明显）</li><li>新增中信证券期权接口cshshlp，这个对于一些和中信有较多战略合作的私募机构会比较有用<br></li><li>使用qtpy模块来代替PyQt4，实现项目中的GUI代码对PyQt4和PyQt5的兼容性<br></li><li>将底层接口模块gateway和上层应用模块app对外暴露的API部分标准化，方便用户根据自己的需求自行加载需要的模块，构建自己定制化的VnTrader<br></li><li>将一些逐步淘汰的代码移到archive目录下</li><li>修复了一些大大小小的bug<br></li></ol><br><p>这次v1.6.2的更新对vn.py项目来说算是个比较大的结构调整，对于用户来说vn.py的使用方式将会从以前接近Spyder的单一应用程序，逐渐过渡到接近Flask的开发框架，更多的鼓励用户根据自己的需求来使用vn.py构建定制化的量化交易程序。</p><p>最后终于也算是解决了长期以来的一个心头刺，离承诺完成v1.7 SpreadTrading模块的时间不到一个月了，加紧干活。</p>","updated":"2017-06-07T14:39:47.000Z","canComment":false,"commentPermission":"anyone","commentCount":52,"likeCount":93,"state":"published","isLiked":false,"slug":"27296132","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-06-07T22:39:47+08:00","links":{"comments":"/api/posts/27296132/comments"},"url":"/p/27296132","titleImage":"https://pic3.zhimg.com/v2-0785e9fd85263736e4190ef0107a8f3a_r.jpg","summary":"","href":"/api/posts/27296132","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":52,"likesCount":93},"27580485":{"title":"用Python的交易员的Live--vn.py的过去、现在和将来","author":"traderusingpython","content":"我是用 python 的交易员，知乎Python和量化交易话题的优秀回答者，金融工程硕士，目前在均直资产担任期权业务主管。同时我也是开源量化交易框架vn.py的作者，项目目前是国内用户最多的量化交易开源项目之一。 \n<p>vn.py项目在Github上的Star数量已经突破3287，我本人在知乎上前后加起来也已经开过4次Live了，终于有信心来讲一讲自己最为得意的作品vn.py。 \n</p><p>过去两年Python在国内的量化投资领域经历了一波飞速的发展，涌现出了一系列的开源和商业软件。不同软件在设计定位上有着较大的区别，有的侧重于数据分析，有的侧重于策略研究，而vn.py则是以量化交易的最后一步环节实盘交易作为切入点构建的全套架构。</p><p>作为项目的作者，在之前的Live中和知乎私信里也经常被问到一些关于vn.py的设计、使用、未来计划等等问题，因为时间的关系大多只能简单回答，所以希望通过这场Live让大家可以对vn.py有个比较全面的了解。</p><br><p>本次Live的内容会围绕vn.py展开： </p><ol><li>过去 </li><ol><li>项目的设计理念 </li><li>早期开发过程 </li><li> 针对的用户群体（交易员） </li></ol><li>现在 </li><ol><li>目前的开发进度 </li><li>如何一步步来学习整个框架 </li><li>如何通过社区获取帮助 \t</li><li>基于vn.py的实盘策略应用：CTA、波动率交易、价差交易、算法交易等 </li></ol><li>将来</li><ol><li>项目的开源可持续性 </li><li>和金融机构的战略合作 </li><li>未来一年的社区活动计划</li></ol></ol><br><p>【传送门】<a href=\"https://www.zhihu.com/lives/863030558513573888?utm_source=qq&amp;utm_medium=social\" data-editable=\"true\" data-title=\"知乎 Live - 全新的实时问答\" class=\"\">知乎 Live - 全新的实时问答</a></p>","updated":"2017-06-27T06:38:54.000Z","canComment":false,"commentPermission":"anyone","commentCount":9,"likeCount":32,"state":"published","isLiked":false,"slug":"27580485","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-06-27T14:38:54+08:00","links":{"comments":"/api/posts/27580485/comments"},"url":"/p/27580485","titleImage":"https://pic3.zhimg.com/v2-a4a4d4b5ac269948b4496c35bb8c9dee_r.jpg","summary":"","href":"/api/posts/27580485","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":9,"likesCount":32},"27939358":{"title":"华尔街见闻成为vn.py项目的战略合作伙伴","author":"traderusingpython","content":"<p>随着vn.py项目的快速发展，社区成员变得越来越多样，也逐渐出现了一些全新的需求，例如项目学习培训、历史行情数据、特定策略的专用交易通道、文档的编写和维护等等。但是因为个人能力的关系（交易员出身的我主要也就擅长做做交易和写写Python程序），挺多的需求都处于一种悬而未决的状态。</p><br><p>参考其他一些成功开源项目的发展历史后，意识到现在vn.py项目需要开始寻找战略合作上的伙伴，来更好的满足社区不断增长的需求。幸运的是在过去两年多的时间里，vn.py项目也吸引到了一部分国内金融机构的注意，并且这些机构有兴趣参与到项目的开源维护中来。</p><p>在今天，2017年7月17日，华尔街见闻宣布正式加入vn.py开源量化交易社区，与vn.py在量化投资领域共同合作，支持全面推进与开拓量化投资在国内金融领域的健康发展，致力于聚集和培养更多量化投资领域的人才（原文链接：<a href=\"https://wallstreetcn.com/articles/3020402\" class=\"\" data-editable=\"true\" data-title=\"华尔街见闻正式加入vn.py开源量化交易社区 - 华尔街见闻\">华尔街见闻正式加入vn.py开源量化交易社区 - 华尔街见闻</a>）。</p><br><p>双方计划的合作内容上包括一系列线上和线下的活动，结合vn.py社区在量化技术方面以及华尔街见闻在内容生产方面的优势，为社区成员提供更好的学习材料以及交流渠道。目前已经推出的是《量化投资24小时》专辑，主要面对的读者是希望通过Python在量化交易领域有所建树的初学者，结合视频和图文的形式提供更通俗易懂的学习效果，并通过由华尔街见闻社群运营团队维护的微信群来为读者提供一个高效的学习和交流渠道（专辑链接：<a href=\"https://wallstreetcn.com/premium/topics/1000157\" data-editable=\"true\" data-title=\"华尔街见闻Premium - 华尔街见闻Premium\" class=\"\">华尔街见闻Premium - 华尔街见闻Premium</a>）。</p><p>未来vn.py项目也会继续寻找其他的战略合作伙伴来更好的满足开源量化社区的各种需求，同时也计划在每个具体的领域只考虑和一家机构建立合作关系（为了双方都能全心全意的投入在合作上），有兴趣的朋友欢迎联系我。</p>","updated":"2017-07-17T13:30:48.000Z","canComment":false,"commentPermission":"anyone","commentCount":5,"likeCount":51,"state":"published","isLiked":false,"slug":"27939358","isTitleImageFullScreen":false,"rating":"none","sourceUrl":"","publishedTime":"2017-07-17T21:30:48+08:00","links":{"comments":"/api/posts/27939358/comments"},"url":"/p/27939358","titleImage":"https://pic2.zhimg.com/v2-42109361e961fc22d99400bd1bd26865_r.jpg","summary":"","href":"/api/posts/27939358","meta":{"previous":null,"next":null},"snapshotUrl":"","commentsCount":5,"likesCount":51}},"User":{"traderusingpython":{"isFollowed":false,"name":"用python的交易员","headline":"","avatarUrl":"https://pic4.zhimg.com/f947c2d9776a605d61860db2a7556a17_s.jpg","isFollowing":false,"type":"people","slug":"traderusingpython","bio":"期权 波动率交易","hash":"3538c663bcd2356726fa2995c855e24e","uid":36781449805824,"isOrg":false,"description":"","profileUrl":"https://www.zhihu.com/people/traderusingpython","avatar":{"id":"f947c2d9776a605d61860db2a7556a17","template":"https://pic4.zhimg.com/{id}_{size}.jpg"},"isOrgWhiteList":false},"jerry-he-20":{"isFollowed":false,"name":"Jerry He","headline":"","avatarUrl":"https://pic1.zhimg.com/da8e974dc_s.jpg","isFollowing":false,"type":"people","slug":"jerry-he-20","bio":"学力学的里面会IT的，学力学会IT里面会金融的，学力学会IT会金融里面乐观生活的","hash":"c34bd480aae79bf000d845771d7b7db5","uid":46355112263680,"isOrg":false,"description":"","profileUrl":"https://www.zhihu.com/people/jerry-he-20","avatar":{"id":"da8e974dc","template":"https://pic1.zhimg.com/{id}_{size}.jpg"},"isOrgWhiteList":false}},"Comment":{},"favlists":{}},"me":{},"global":{},"columns":{"vn-py":{"pins":[],"followersCount":19635,"creator":{"bio":"期权 波动率交易","isFollowing":false,"hash":"3538c663bcd2356726fa2995c855e24e","uid":36781449805824,"isOrg":false,"slug":"traderusingpython","isFollowed":false,"description":"","name":"用python的交易员","profileUrl":"https://www.zhihu.com/people/traderusingpython","avatar":{"id":"f947c2d9776a605d61860db2a7556a17","template":"https://pic4.zhimg.com/{id}_{size}.jpg"},"isOrgWhiteList":false},"topics":[{"url":"https://www.zhihu.com/topic/19815465","id":"19815465","name":"量化交易"},{"url":"https://www.zhihu.com/topic/19562746","id":"19562746","name":"开源"},{"url":"https://www.zhihu.com/topic/19552832","id":"19552832","name":"Python"}],"activateState":"activated","href":"/api/columns/vn-py","acceptSubmission":true,"firstTime":false,"postTopics":[{"postsCount":24,"id":90588,"name":"量化交易"},{"postsCount":22,"id":872,"name":"Python"},{"postsCount":22,"id":19800,"name":"金融"},{"postsCount":11,"id":395,"name":"投资"},{"postsCount":11,"id":168687,"name":"vn.py"},{"postsCount":9,"id":11700,"name":"交易"},{"postsCount":2,"id":53926,"name":"高频交易"},{"postsCount":1,"id":113,"name":"阅读"},{"postsCount":1,"id":3307,"name":"阿里云"},{"postsCount":1,"id":5422,"name":"外汇"}],"pendingName":"","avatar":{"id":"cc33c56c5bb7b26c6202b550662443cd","template":"https://pic2.zhimg.com/{id}_{size}.jpg"},"canManage":false,"description":"基于python的开源交易平台开发框架","pendingTopics":[],"nameCanEditUntil":0,"reason":"","banUntil":0,"slug":"vn-py","name":"vn.py","url":"/vn-py","intro":"基于python的开源交易平台开发框架","topicsCanEditUntil":0,"activateAuthorRequested":"none","commentPermission":"anyone","following":false,"postsCount":48,"canPost":false,"FULLINFO":true}},"columnPosts":{"vn-py":{"entity":["27939358","27580485","27296132","26382004","26262572","26254515","26224702","26216391","25709554","25483770","25050658","24994645","24772031","24662087","24759330","24242972","24168485","23678646","23399539","22713839"],"next":{"rel":"next","href":"/api/columns/vn-py/posts?limit=20&offset=20","query":{"limit":"20","offset":"20"}}}},"postComments":{},"postReviewComments":{"comments":[],"newComments":[],"hasMore":true},"favlistsByUser":{},"favlistRelations":{},"promotions":{},"switches":{"couldAddVideo":false},"draft":{"titleImage":"","titleImageSize":{},"isTitleImageFullScreen":false,"canTitleImageFullScreen":false,"title":"","titleImageUploading":false,"error":"","content":"","draftLoading":false,"globalLoading":false,"pendingVideo":{"resource":null,"error":null}},"drafts":{"draftsList":[]},"config":{"userNotBindPhoneTipString":{}},"recommendPosts":{"articleRecommendations":[],"columnRecommendations":[]},"env":{"isAppView":false,"appViewConfig":{"content_padding_top":128,"content_padding_bottom":56,"content_padding_left":16,"content_padding_right":16,"title_font_size":22,"body_font_size":16,"is_dark_theme":false,"can_auto_load_image":true,"app_info":"OS=iOS"},"isApp":false},"sys":{}}