量化交易

你的浏览器禁用了JavaScript, 请开启后刷新浏览器获得更好的体验!

目前支持量化接口的万一免五的券商有哪些？

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 3573 次浏览 • 2023-07-04 22:52 • 来自相关话题

支持量化交易的券商如下：

其中能够股票免五的有国金证券，国盛证券，国信证券，安信证券。

其中，国金证券，国盛证券支持QMT、MiniQMT、Ptrade。

国信证券，安信证券支持QMT。

东莞证券支持Ptrade

可转债默认免五。

开户后可加入量化技术交流群，可获得编程技术指导。
【提问者需要把问题描述清楚即可,PS: 有些人动不动就说：“Ptrade不行呀”，“QMT垃圾呀”，结果让他贴代码上来瞅瞅，是他本身代码写的拉垮，目前贴出来的已知的问题，90%是个人代码问题。】

扫码添加微信咨询开户：

查看全部

支持量化交易的券商如下：

其中能够股票免五的有国金证券，国盛证券，国信证券，安信证券。

其中，国金证券，国盛证券支持QMT、MiniQMT、Ptrade。

国信证券，安信证券支持QMT。

东莞证券支持Ptrade

可转债默认免五。

开户后可加入量化技术交流群，可获得编程技术指导。
【提问者需要把问题描述清楚即可,PS: 有些人动不动就说：“Ptrade不行呀”，“QMT垃圾呀”，结果让他贴代码上来瞅瞅，是他本身代码写的拉垮，目前贴出来的已知的问题，90%是个人代码问题。】

扫码添加微信咨询开户：

qmt的升级有点拉胯，居然不能一次到位？

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 1527 次浏览 • 2022-07-04 10:37 • 来自相关话题

最近有点时间没等qmt，登录的时候提示有更新，当前版本是v25（举例说明），
好的，点击确认，显示下载，即将更新到的版本为v26 , 等待几分钟后，更新完毕，需要自己重启。

结果重启后，提示系统需要更新，要更新到v27，什么？居然现在还要这样迭代更新？

终于更新了2次之后，登录上系统了。
查看全部

最近有点时间没等qmt，登录的时候提示有更新，当前版本是v25（举例说明），
好的，点击确认，显示下载，即将更新到的版本为v26 , 等待几分钟后，更新完毕，需要自己重启。

结果重启后，提示系统需要更新，要更新到v27，什么？居然现在还要这样迭代更新？

终于更新了2次之后，登录上系统了。

获取可转债历史分时tick数据【python】

可转债 • 李魔佛发表了文章 • 0 个评论 • 3424 次浏览 • 2022-06-25 12:29 • 来自相关话题

可转债的历史分时tick数据，基本在很多大平台，优矿，聚宽，米宽等平台都没有提供。

对于想做日内回测的朋友，是一件很痛苦的事情。

那么，接下来，本文结束一种通过第三方平台的数据，来把可转债的分时tick数据获取下来，并保存到本地数据库。

2022-07-05 更新：

如果直接拿历史数据，可以拿到1分钟级别的数据，如上图所示。

如果要拿秒级别的，需要实时采集。

笔者使用sqlite做为内存缓存，盘后统一入到mysql中。

如果盘中每隔3秒使用mysql储存，显然会造成不必要的io阻塞（开个线程存数据也是一个方案）。

使用sqlite的时候，设置为memeory模式，速度比存文件要快很多倍。

待续查看全部

可转债的历史分时tick数据，基本在很多大平台，优矿，聚宽，米宽等平台都没有提供。

对于想做日内回测的朋友，是一件很痛苦的事情。

那么，接下来，本文结束一种通过第三方平台的数据，来把可转债的分时tick数据获取下来，并保存到本地数据库。

2022-07-05 更新：

如果直接拿历史数据，可以拿到1分钟级别的数据，如上图所示。

如果要拿秒级别的，需要实时采集。

笔者使用sqlite做为内存缓存，盘后统一入到mysql中。

如果盘中每隔3秒使用mysql储存，显然会造成不必要的io阻塞（开个线程存数据也是一个方案）。

使用sqlite的时候，设置为memeory模式，速度比存文件要快很多倍。

待续

Ptrade、QMT如何在虚拟机下运行？

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 4582 次浏览 • 2022-01-12 19:38 • 来自相关话题

QMT在阿里云的虚拟机上无法运行的，QMT会检测到当前的环境是虚拟机，会阻止你登录。

那是不是只能在本地的物理机上执行的呢？

不过有办法解决：
使用阿里云的云服务中的无影云。

关键它价格也不贵，一年的2核4G的价格也就是139元，支持windows

https://www.aliyun.com/minisite/goods?userCode=nebb965s

无影云桌面 (Elastic Desktop Service），是一种易用、安全、高效的云上桌面服务。它支持快速便捷的桌面环境创建、部署、统一管控与运维。无需前期传统硬件投资，帮您快速构建安全、高性能、低成本的企业桌面办公体系。可广泛应用于具有高数据安全管控、高性能计算等要求的安全办公、金融、设计、影视、教育等领域。

其实就是一个windows的远程桌面，里面可以按照各种应用程序，比如同花顺，东方财富，QQ等等

连接方式，使用浏览器就可以连上远程桌面了：

我用的谷歌浏览器，现在无论走到那里，只要可以上网，就可以在浏览器里面连接到远程桌面，看到Ptrade里面的情况。

查看全部

QMT在阿里云的虚拟机上无法运行的，QMT会检测到当前的环境是虚拟机，会阻止你登录。

那是不是只能在本地的物理机上执行的呢？

不过有办法解决：
使用阿里云的云服务中的无影云。

关键它价格也不贵，一年的2核4G的价格也就是139元，支持windows

https://www.aliyun.com/minisite/goods?userCode=nebb965s

无影云桌面 (Elastic Desktop Service），是一种易用、安全、高效的云上桌面服务。它支持快速便捷的桌面环境创建、部署、统一管控与运维。无需前期传统硬件投资，帮您快速构建安全、高性能、低成本的企业桌面办公体系。可广泛应用于具有高数据安全管控、高性能计算等要求的安全办公、金融、设计、影视、教育等领域。

其实就是一个windows的远程桌面，里面可以按照各种应用程序，比如同花顺，东方财富，QQ等等

连接方式，使用浏览器就可以连上远程桌面了：

我用的谷歌浏览器，现在无论走到那里，只要可以上网，就可以在浏览器里面连接到远程桌面，看到Ptrade里面的情况。

优矿回测可转债代码教程

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 5712 次浏览 • 2021-12-09 00:44 • 来自相关话题

不少投资者在投资的过程中,都想要回测自己的策略或者验证自己的想法. 不少读者也在后台留言,能否写写入门类的教程.

可是碍于非科班出生, 对于编程的一窍不通, 所以大部分止步于简单的数据统计.

比如采用excel对采集来的数据,手工测试与验证, 高级点的可以应用一些excel函数进行简单回测.

这里会有一个烦人且第一大障碍, 就是需要有采集来的数据. 首先保证这个数据的完整性与准确性. 这一步其实已经过滤掉想要回测的80%的人了. 具体优矿支持的数据。

优矿支持的数据
股票：沪深交易所股票的基本信息以及日/分钟级别的股票行情。财务报表：沪深港上市公司披露的2007年会计准则变更以来的所有财务报表数据，包含三大报表和财报附注等细节。公司行为：沪深上市公司业绩预告，业绩快报，IPO，配股，分红，拆股，股改等信息。基金：场内外各类基金的基本信息，日/分钟级别的场内基金行情，日级别的场外基金净值，以及基金资产配置，收益情况，净值调整等信息。期货：国内四大期货交易所期货合约的基本信息，日/分钟的期货行情，以及国债期货的转换因子等信息。指数：国内外指数基本信息，日/分钟级别的指数行情，以及指数成分构成情况，指数成分股权重情况等信息。港股：香港交易所股票基本信息以及日级别的股票行情。大宗商品：国内各个品种（包括期货合约可交割品种）的大宗商品现货价格行情，以及产销量，库存等信息。债券：债券/回购基本信息，日级别的债券/回购行情，以及发行上市，付息，利率，评级和评级变动，债券发行人评级及变动，担保人评级及变动等信息。期权：上交所期权合约的基本信息，日/分钟级别的期权行情，以及每日盘前静态数据等信息。宏观产业：中国及全球各国宏观指标，行业经济指标等数据。

特色数据
股票/指数等品种的量化因子库雪球、股吧等社交媒体数据主流媒体新闻文本和结构化数据主流渠道公告文本和结构化数据淘宝、天猫等电商数据

其实其他的聚框,米宽,箩筐等等,都是大同小异的,本文只是挑选笔者使用比较多的优矿来介绍. 不过现在优矿并不支持实盘.

本文只是做一个量化平台框架的基本介绍, 后续的文章会有进阶, 加入买卖操作, 计算最大回撤, 以及更为复杂的多因子回测. 只要有的数据,基本都可以拿来加入到你的模型之中.

##################################################################

因为优矿本身并不支持可转债的交易，所以系统内置的order，buy，sell函数是无法应用到可转债上面。

不过只要能够获取到每日的行情数据，那么我们就可以自己构造一个交易系统。

核心就就是每次保存你的持仓信息，等到下一次调仓时，对持仓进行比较，对于调出的转债进行移除，新加的转债进行加入。然后统计一下当前市值，记录下来，就可以得到收益率曲线。

部分代码如下：import datetime

start = '2018-01-01' # 回测起始时间
end = '2021-05-28' # 回测结束时间
benchmark = 'HS300' # 策略参考标准
freq = 'd' # 策略类型，'d'表示日间策略使用日线回测，'m'表示日内策略使用分钟线回测
refresh_rate = 5 # 调仓频率，表示执行handle_data的时间间隔，若freq = 'd' 时间间隔的单位为交易日，
hold_num = 10 # 持有转债的个数

def initialize(context):
global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash
MyPosition = {} #持仓
MyCash = 1000000 #现金
Start_Cash= 1000000
HighValue = MyCash #最高市值
Withdraw = 0 #最大回撤
HoldRank = hold_num #排名多少之后卖出
HoldNum = hold_num #持债支数

def bonds(beginDate=u"20170101",endDate=u"20201215",EB_ENABLE=False):
code_set = set()
df = DataAPI.MktConsBondPremiumGet(SecID=u"",
tickerBond=u"",
beginDate=beginDate,
endDate=endDate,
field=u"",
pandas="1")

cb_df = df.tickerBond.str.startswith(('12', '11'))
df = df[cb_df]
cb_df = df.tickerBond.str.startswith('117')
df = df[~cb_df]
if not EB_ENABLE:
eb = df.secShortNameBond.str.match('\d\d.*?E[123B]') # TODO 判断EB是否过滤
df = df[~eb]

ticker_list =
for _, row in df[['tickerBond', 'secShortNameBond', 'tickerEqu']].iterrows():
if row['tickerBond'] not in code_set:
ticker_list.append((row['tickerBond'], row['secShortNameBond'], row['tickerEqu']))
code_set.add(row['tickerBond'])
return list(code_set)

def handle_data(context):
global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash

today_date = context.now.strftime('%Y%m%d')

#每天重新计算双低排名
ticker_list=bonds(today_date,today_date)
data = DataAPI.MktConsBondPerfGet(beginDate=today_date,endDate=today_date,secID='',tickerBond=ticker_list,
tickerEqu=u"",field=u"",pandas="1")
data['secID']=data['tickerBond']
data.set_index('secID',inplace=True)
data['DoubleLow'] = data['closePriceBond'] + data['bondPremRatio']
data = data.sort_values(by="DoubleLow" , ascending=True)
PosValue = MyCash

#抛出不在持有排名HoldRank的
for stock in MyPosition.keys():
try:
CurPrice = data.loc[stock]['closePriceBond']
except:
last_date = (context.now + datetime.timedelta(days=-7)).strftime('%Y%m%d')
CurPrice=get_last_price(stock,last_date,today_date)

PosValue += MyPosition[stock] * CurPrice * 10 #计算当前市值

if stock not in data.index[:HoldRank]:
# 省略若干

log.info('{} 卖出{},{},价格：{}'.format(today_date,stock,name,CurPrice))

if PosValue > HighValue:HighValue = PosValue
if (HighValue - PosValue) / HighValue > Withdraw:Withdraw = (HighValue - PosValue) / HighValue

#买入排在HoldRank内的，总持有数量HoldNum
min_hold = min(HoldRank,len(data.index))
for i in range(min_hold):
if len(MyPosition) >= HoldNum:break
if data.index[i] not in MyPosition.keys():
# 省略若干
log.info('{} 买入{}, {}, 价格{}, 溢价率{}'.format(today_date,data.index[i],name,price,cb_ration))

ratio = (PosValue-Start_Cash)/Start_Cash*100
log.info(today_date + ': 最高市值 ' + str(HighValue) + ' , 当前市值 ' + str(PosValue) + '收益率： '
+str(ratio)+'% , 最大回撤 ' + str(round(Withdraw*100,2))+'%') [/i][/i]
[i]欢迎讨论探索，星球里面有更多的完整策略与代码，回测数据，结论资源。

[/i] 查看全部

优矿支持的数据

股票：沪深交易所股票的基本信息以及日/分钟级别的股票行情。
财务报表：沪深港上市公司披露的2007年会计准则变更以来的所有财务报表数据，包含三大报表和财报附注等细节。
公司行为：沪深上市公司业绩预告，业绩快报，IPO，配股，分红，拆股，股改等信息。
基金：场内外各类基金的基本信息，日/分钟级别的场内基金行情，日级别的场外基金净值，以及基金资产配置，收益情况，净值调整等信息。
期货：国内四大期货交易所期货合约的基本信息，日/分钟的期货行情，以及国债期货的转换因子等信息。
指数：国内外指数基本信息，日/分钟级别的指数行情，以及指数成分构成情况，指数成分股权重情况等信息。
港股：香港交易所股票基本信息以及日级别的股票行情。
大宗商品：国内各个品种（包括期货合约可交割品种）的大宗商品现货价格行情，以及产销量，库存等信息。
债券：债券/回购基本信息，日级别的债券/回购行情，以及发行上市，付息，利率，评级和评级变动，债券发行人评级及变动，担保人评级及变动等信息。
期权：上交所期权合约的基本信息，日/分钟级别的期权行情，以及每日盘前静态数据等信息。
宏观产业：中国及全球各国宏观指标，行业经济指标等数据。

特色数据

股票/指数等品种的量化因子库
雪球、股吧等社交媒体数据
主流媒体新闻文本和结构化数据
主流渠道公告文本和结构化数据
淘宝、天猫等电商数据

其实其他的聚框,米宽,箩筐等等,都是大同小异的,本文只是挑选笔者使用比较多的优矿来介绍. 不过现在优矿并不支持实盘.

本文只是做一个量化平台框架的基本介绍, 后续的文章会有进阶, 加入买卖操作, 计算最大回撤, 以及更为复杂的多因子回测. 只要有的数据,基本都可以拿来加入到你的模型之中.

##################################################################

因为优矿本身并不支持可转债的交易，所以系统内置的order，buy，sell函数是无法应用到可转债上面。

不过只要能够获取到每日的行情数据，那么我们就可以自己构造一个交易系统。

核心就就是每次保存你的持仓信息，等到下一次调仓时，对持仓进行比较，对于调出的转债进行移除，新加的转债进行加入。然后统计一下当前市值，记录下来，就可以得到收益率曲线。

部分代码如下：

import datetime



start = '2018-01-01'                       # 回测起始时间

end = '2021-05-28'                         # 回测结束时间

benchmark = 'HS300'                        # 策略参考标准

freq = 'd'                                 # 策略类型，'d'表示日间策略使用日线回测，'m'表示日内策略使用分钟线回测            

refresh_rate = 5 # 调仓频率，表示执行handle_data的时间间隔，若freq = 'd' 时间间隔的单位为交易日，

hold_num = 10 # 持有转债的个数



    

def initialize(context):

    global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash

    MyPosition = {}  #持仓

    MyCash = 1000000  #现金

    Start_Cash= 1000000

    HighValue = MyCash  #最高市值

    Withdraw = 0  #最大回撤

    HoldRank = hold_num  #排名多少之后卖出

    HoldNum = hold_num  #持债支数

    

def bonds(beginDate=u"20170101",endDate=u"20201215",EB_ENABLE=False):

    code_set = set()

    df = DataAPI.MktConsBondPremiumGet(SecID=u"",

                                       tickerBond=u"",

                                       beginDate=beginDate,

                                       endDate=endDate,

                                       field=u"",

                                       pandas="1")



    cb_df = df.tickerBond.str.startswith(('12', '11'))

    df = df[cb_df]

    cb_df = df.tickerBond.str.startswith('117')

    df = df[~cb_df]

    if not EB_ENABLE:

        eb = df.secShortNameBond.str.match('\d\d.*?E[123B]')  # TODO 判断EB是否过滤

        df = df[~eb]



    ticker_list = 

    for _, row in df[['tickerBond', 'secShortNameBond', 'tickerEqu']].iterrows():

        if row['tickerBond'] not in code_set:

            ticker_list.append((row['tickerBond'], row['secShortNameBond'], row['tickerEqu']))

            code_set.add(row['tickerBond'])

    return list(code_set)





def handle_data(context):    

    global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash

    

    today_date = context.now.strftime('%Y%m%d')

    

    #每天重新计算双低排名

    ticker_list=bonds(today_date,today_date)

    data = DataAPI.MktConsBondPerfGet(beginDate=today_date,endDate=today_date,secID='',tickerBond=ticker_list,

                                      tickerEqu=u"",field=u"",pandas="1")

    data['secID']=data['tickerBond']

    data.set_index('secID',inplace=True)

    data['DoubleLow'] = data['closePriceBond'] + data['bondPremRatio']

    data = data.sort_values(by="DoubleLow" , ascending=True)

    PosValue = MyCash

    

    #抛出不在持有排名HoldRank的

    for stock in MyPosition.keys():

        try:

            CurPrice = data.loc[stock]['closePriceBond']

        except:

            last_date = (context.now + datetime.timedelta(days=-7)).strftime('%Y%m%d')

            CurPrice=get_last_price(stock,last_date,today_date)



        PosValue += MyPosition[stock] * CurPrice * 10 #计算当前市值

        

        if stock not in data.index[:HoldRank]:

            # 省略若干

                

            log.info('{} 卖出{},{},价格：{}'.format(today_date,stock,name,CurPrice))

  

            

    if PosValue > HighValue:HighValue = PosValue

    if (HighValue - PosValue) / HighValue > Withdraw:Withdraw = (HighValue - PosValue) / HighValue

    

    #买入排在HoldRank内的，总持有数量HoldNum

    min_hold = min(HoldRank,len(data.index))

    for i in range(min_hold):

        if len(MyPosition) >= HoldNum:break

        if data.index[i] not in MyPosition.keys():

            # 省略若干

            log.info('{} 买入{}, {}, 价格{}, 溢价率{}'.format(today_date,data.index[i],name,price,cb_ration))



    ratio = (PosValue-Start_Cash)/Start_Cash*100

    log.info(today_date + ': 最高市值 ' + str(HighValue) + ' , 当前市值 ' + str(PosValue) + '收益率 ： '

             +str(ratio)+'% , 最大回撤 ' + str(round(Withdraw*100,2))+'%') [/i][/i]

[i]欢迎讨论探索，星球里面有更多的完整策略与代码，回测数据，结论资源。

[/i]

开通Ptrade Python量化接口国金证券/国盛证券

股票 • 绫波丽发表了文章 • 0 个评论 • 20782 次浏览 • 2021-07-06 08:40 • 来自相关话题

目前不少在A股做量化的大部分使用tushare，优矿，米筐，聚宽等等，无论教程，还是实际操作，基本没见有教怎么用程序下单，实盘交易的。

而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用tushare或者新浪接口数据，扫描一次全市场的行情用时很久且不稳定，等扫描结束，再下单，此时价格可能已经是几分钟前的了，且此类接口调用次数多是会被封IP的。

笔者使用的是券商提供的量化软件：Ptrade。是恒生电子研发的提供给机构使用的程序化交易软件。提供策略回测，下单API接口，实时行情获取，并且使用的开发语言python，易于上手。

策略回测与实盘交易

研究页面

研究页面，熟悉python jupyter notebook的朋友对这个界面肯定很熟悉。

研究的页面实际就运行你逐行输出调试程序，了解每个函数的具体使用，或者你策略的中途结果调试。

回测策略

实际代码需要在回测策略里面写，写完后确定无误，就可以放在仿真环境下真实运行。如果你运行得到的结果很满意，那么就可以直接部署到实盘服务器上。实盘服务器是在券商那边，不需要个人购买服务器，也不需要本地开着这个Ptrade，就是说不需要在个人电脑上一直开着跑，你的最终代码和程序是在券商服务器上部署与运行，除非有报错异常停止，不然在你不暂停或者停止的前提下，可以一直运行下去。

条件满足后下单

可视化量化

同时也提供一些常见的现成的量化策略，选中后只要鼠标点点点也能够自动化跑这些策略了，当然里面很多参数都可以用鼠标点点点修改。

接口文档也非常详细：

一些常见策略代码：

集合竞价追涨停策略def initialize(context):
# 初始化此策略
# 设置我们要操作的股票池, 这里我们只操作一支股票
g.security = '600570.SS'
set_universe(g.security)
#每天9:23分运行集合竞价处理函数
run_daily(context, aggregate_auction_func, time='9:23')

def aggregate_auction_func(context):
stock = g.security
#最新价
snapshot = get_snapshot(stock)
price = snapshot[stock]['last_px']
#涨停价
up_limit = snapshot[stock]['up_px']
#如果最新价不小于涨停价，买入
if float(price) >= float(up_limit):
order(g.security, 100, limit_price=up_limit)

def handle_data(context, data):
pass
双均线策略def initialize(context):
# 初始化此策略
# 设置我们要操作的股票池, 这里我们只操作一支股票
g.security = '600570.SS'
set_universe(g.security)
pass

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出
def handle_data(context, data):
security = g.security

#得到十日历史价格
df = get_history(10, '1d', 'close', security, fq=None, include=False)

# 得到五日均线价格
ma5 = round(df['close'][-5:].mean(), 3)

# 得到十日均线价格
ma10 = round(df['close'][-10:].mean(), 3)

# 取得昨天收盘价
price = data[security]['close']

# 得到当前资金余额
cash = context.portfolio.cash

# 如果当前有余额，并且五日均线大于十日均线
if ma5 > ma10:
# 用所有 cash 买入股票
order_value(security, cash)
# 记录这次买入
log.info("Buying %s" % (security))

# 如果五日均线小于十日均线，并且目前有头寸
elif ma5 < ma10 and get_position(security).amount > 0:
# 全部卖出
order_target(security, 0)
# 记录这次卖出
log.info("Selling %s" % (security))

tick级别均线策略

通俗点就是按照秒级别进行操作。def initialize(context):
# 初始化此策略
# 设置我们要操作的股票池, 这里我们只操作一支股票
g.security = '600570.SS'
set_universe(g.security)
#每3秒运行一次主函数
run_interval(context, func, seconds=3)

#盘前准备历史数据
def before_trading_start(context, data):
history = get_history(10, '1d', 'close', g.security, fq='pre', include=False)
g.close_array = history['close'].values

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出
def func(context):

stock = g.security

#获取最新价
snapshot = get_snapshot(stock)
price = snapshot[stock]['last_px']

# 得到五日均线价格
days = 5
ma5 = get_MA_day(stock, days, g.close_array[-4:], price)
# 得到十日均线价格
days = 10
ma10 = get_MA_day(stock, days, g.close_array[-9:], price)

# 得到当前资金余额
cash = context.portfolio.cash

# 如果当前有余额，并且五日均线大于十日均线
if ma5 > ma10:
# 用所有 cash 买入股票
order_value(stock, cash)
# 记录这次买入
log.info("Buying %s" % (stock))

# 如果五日均线小于十日均线，并且目前有头寸
elif ma5 < ma10 and get_position(stock).amount > 0:
# 全部卖出
order_target(stock, 0)
# 记录这次卖出
log.info("Selling %s" % (stock))

#计算实时均线函数
def get_MA_day(stock,days,close_array,current_price):
close_sum = close_array[-(days-1):].sum()
MA = (current_price + close_sum)/days
return MA

def handle_data(context, data):
pass

macd策略def f_expma(N,m,EXPMA1,price):
a = m/(N+1)
EXPMA2 = a * price + (1 - a)*EXPMA1
return EXPMA2 #2为后一天值

#定义macd函数，输入平滑系数参数、前一日值，输出当日值
def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):
EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)
EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)
DIF2 = EXPMA12_2 - EXPMA26_2
a = m/(N3+1)
DEA2 = a * DIF2 + (1 - a)*DEA1
BAR2=2*(DIF2-DEA2)
return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2

def initialize(context):
global init_price
init_price = None
# 获取沪深300股票
g.security = get_index_stocks('000300.SS')
#g.security = ['600570.SS']
# 设置我们要操作的股票池, 这里我们只操作一支股票
set_universe(g.security)

def handle_data(context, data):
# 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取
# 从股票上市至今的所有历史数据，即增加获取的天数
close_price = get_history(2, '1d', field='close', security_list=g.security)
#如果是停牌不进行计算
for security in g.security:
if data[security].is_open >0:
global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2
if init_price is None:
init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值
EXPMA12_1 = init_price
EXPMA26_1 = init_price
DIF1 = init_price
DEA1 = init_price
# m用于计算平滑系数a=m/(N+1)
m = 2.0
#设定指数平滑基期数
N1 = 12
N2 = 26
N3 = 9
EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])
# 取得当前价格
current_price = data[security].price
# 取得当前的现金
cash = context.portfolio.cash
# DIF、DEA均为正，DIF向上突破DEA，买入信号参考
if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:
# 计算可以买多少只股票
number_of_shares = int(cash/current_price)
# 购买量大于0时，下单
if number_of_shares > 0:
# 以市单价买入股票，日回测时即是开盘价
order(security, +number_of_shares)
# 记录这次买入
log.info("Buying %s" % (security))
# DIF、DEA均为负，DIF向下突破DEA，卖出信号参考
elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:
# 卖出所有股票,使这只股票的最终持有量为0
order_target(security, 0)
# 记录这次卖出
log.info("Selling %s" % (security))
# 将今日的值赋给全局变量作为下一次前一日的值
DEA1 = DEA2
DIF1 = DIF2
EXPMA12_1 = EXPMA12_2
EXPMA26_1 = EXPMA26_2

软件与交易接口开通条件：

开通该券商后，存入资金指定资金即可开通。开通后股票交易费率万一

本身券商的交易费率为股票万一，可转债沪百万分之五，深十万分之五，基金万0.5，非常厚道。

不太了解量化行业的可以了解下，不少面向机构的量化交易软件的佣金是万2.5的，且开户门槛高，基本是500W以上，比如华泰的matic量化的门槛是1千万元起步。

所以笔者还是很推荐目前该券商的量化交易接口。

需要开通咨询了解的朋友可以扫码联系：

开通券商账户后可以可以先试用，再考虑是否开通量化接口权限查看全部

研究页面

研究页面，熟悉python jupyter notebook的朋友对这个界面肯定很熟悉。

研究的页面实际就运行你逐行输出调试程序，了解每个函数的具体使用，或者你策略的中途结果调试。

回测策略

实际代码需要在回测策略里面写，写完后确定无误，就可以放在仿真环境下真实运行。如果你运行得到的结果很满意，那么就可以直接部署到实盘服务器上。实盘服务器是在券商那边，不需要个人购买服务器，也不需要本地开着这个Ptrade，就是说不需要在个人电脑上一直开着跑，你的最终代码和程序是在券商服务器上部署与运行，除非有报错异常停止，不然在你不暂停或者停止的前提下，可以一直运行下去。

条件满足后下单

可视化量化

同时也提供一些常见的现成的量化策略，选中后只要鼠标点点点也能够自动化跑这些策略了，当然里面很多参数都可以用鼠标点点点修改。

接口文档也非常详细：

一些常见策略代码：

集合竞价追涨停策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')  



def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

    

def handle_data(context, data):

    pass

双均线策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    pass

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def handle_data(context, data):

    security = g.security



    #得到十日历史价格

    df = get_history(10, '1d', 'close', security, fq=None, include=False)

	

    # 得到五日均线价格

    ma5 = round(df['close'][-5:].mean(), 3)

    

    # 得到十日均线价格

    ma10 = round(df['close'][-10:].mean(), 3)



    # 取得昨天收盘价

    price = data[security]['close']



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(security, cash)

        # 记录这次买入

        log.info("Buying %s" % (security))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(security).amount > 0:

        # 全部卖出

        order_target(security, 0)

        # 记录这次卖出

        log.info("Selling %s" % (security))

tick级别均线策略

通俗点就是按照秒级别进行操作。

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每3秒运行一次主函数

    run_interval(context, func, seconds=3)

      

#盘前准备历史数据

def before_trading_start(context, data):

    history = get_history(10, '1d', 'close', g.security, fq='pre', include=False)

    g.close_array = history['close'].values

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def func(context):

    

    stock = g.security

    

    #获取最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    

    # 得到五日均线价格

	days = 5

    ma5 = get_MA_day(stock, days, g.close_array[-4:], price)   

    # 得到十日均线价格

	days = 10

    ma10 = get_MA_day(stock, days, g.close_array[-9:], price)



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(stock, cash)

        # 记录这次买入

        log.info("Buying %s" % (stock))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(stock).amount > 0:

        # 全部卖出

        order_target(stock, 0)

        # 记录这次卖出

        log.info("Selling %s" % (stock))    



#计算实时均线函数

def get_MA_day(stock,days,close_array,current_price):

    close_sum = close_array[-(days-1):].sum()

    MA = (current_price + close_sum)/days

    return MA



def handle_data(context, data):

    pass

macd策略

def f_expma(N,m,EXPMA1,price):

    a = m/(N+1)

    EXPMA2 = a * price + (1 - a)*EXPMA1

    return EXPMA2 #2为后一天值



#定义macd函数，输入平滑系数参数、前一日值，输出当日值

def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):

    EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)

    EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)

    DIF2 = EXPMA12_2 - EXPMA26_2

    a = m/(N3+1)

    DEA2 = a * DIF2 + (1 - a)*DEA1

    BAR2=2*(DIF2-DEA2)

    return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2



def initialize(context):

    global init_price

    init_price = None

    # 获取沪深300股票

    g.security = get_index_stocks('000300.SS')

    #g.security = ['600570.SS']

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    set_universe(g.security)



def handle_data(context, data):

    # 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取

    # 从股票上市至今的所有历史数据，即增加获取的天数

    close_price = get_history(2, '1d', field='close', security_list=g.security)

    #如果是停牌不进行计算

    for security in g.security:

        if data[security].is_open >0:

            global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2

            if init_price is None:

                init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值

                EXPMA12_1 = init_price

                EXPMA26_1 = init_price

                DIF1 = init_price

                DEA1 = init_price

            # m用于计算平滑系数a=m/(N+1)

            m = 2.0

            #设定指数平滑基期数

            N1 = 12

            N2 = 26

            N3 = 9

            EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])

            # 取得当前价格

            current_price = data[security].price

            # 取得当前的现金

            cash = context.portfolio.cash

            # DIF、DEA均为正，DIF向上突破DEA，买入信号参考

            if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:

                # 计算可以买多少只股票

                number_of_shares = int(cash/current_price)

                # 购买量大于0时，下单

                if number_of_shares > 0:

                    # 以市单价买入股票，日回测时即是开盘价

                    order(security, +number_of_shares)

                    # 记录这次买入

                    log.info("Buying %s" % (security))

            # DIF、DEA均为负，DIF向下突破DEA，卖出信号参考

            elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:

                # 卖出所有股票,使这只股票的最终持有量为0

                order_target(security, 0)

                # 记录这次卖出

                log.info("Selling %s" % (security))

            # 将今日的值赋给全局变量作为下一次前一日的值

            DEA1 = DEA2

            DIF1 = DIF2

            EXPMA12_1 = EXPMA12_2

            EXPMA26_1 = EXPMA26_2

软件与交易接口开通条件：

开通该券商后，存入资金指定资金即可开通。开通后股票交易费率万一

本身券商的交易费率为股票万一，可转债沪百万分之五，深十万分之五，基金万0.5，非常厚道。

不太了解量化行业的可以了解下，不少面向机构的量化交易软件的佣金是万2.5的，且开户门槛高，基本是500W以上，比如华泰的matic量化的门槛是1千万元起步。

所以笔者还是很推荐目前该券商的量化交易接口。

需要开通咨询了解的朋友可以扫码联系：

开通券商账户后可以可以先试用，再考虑是否开通量化接口权限

量化交易接口python A股

股票 • 绫波丽发表了文章 • 0 个评论 • 7990 次浏览 • 2021-07-01 11:22 • 来自相关话题

不少在A股做量化的基本千篇一律tushare，优矿，米筐，聚宽等等，无论教程也好。

实际操作也好，几乎没见几个人教你怎么用程序下单，实盘交易。

稍微好点的easytrader使用的是模拟点击交易软件进行点击下单，基本无法判断下单后是否成交，也无法实时获取行情数据。别跟我说用tushare或者新浪这些接口数据，除非你做的是低频交易。

试试扫描一次全市场的行情看看用时多少？等得到满足条件了，再下单，此时价格可能已经在涨停板上封住了。

笔者使用的是券商提供的量化软件：Ptrade。

是恒生电子研发的提供给券商机构使用的程序化交易软件。提供策略回测，自动下单功能，使用的开发语言python。

策略回测与实盘交易

研究页面

研究页面，熟悉python jupyter notebook的朋友对这个界面肯定很熟悉。

研究的页面实际就运行你逐行输出调试程序，了解每个函数的具体使用，或者你策略的中途结果调试。

回测策略

实际代码需要在回测策略里面写，写完后确定无误，就可以放在仿真环境下真实运行。

如果你运行得到的结果很满意，那么就可以直接部署到实盘服务器上。

实盘服务器是在券商那边，不需要个人购买服务器，也不需要本地开着这个Ptrade，就是说不需要在个人电脑上一直开着跑，你的最终代码和程序是在券商服务器上部署与运行，除非有报错异常停止，不然在你不暂停或者停止的前提下，可以一直运行下去。

条件满足后下单

可视化量化

同时也提供一些常见的现成的量化策略，选中后只要鼠标点点点也能够自动化跑这些策略了，当然里面很多参数都可以用鼠标点点点修改。

接口文档也非常详细：

一些常见策略代码：

双均线策略 def initialize(context):
2 # 初始化此策略
3 # 设置我们要操作的股票池, 这里我们只操作一支股票
4 g.security = '600570.SS'
5 set_universe(g.security)
6 pass
7
8 #当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出
9 def handle_data(context, data):
10 security = g.security
11
12 #得到十日历史价格
13 df = get_history(10, '1d', 'close', security, fq=None, include=False)
14
15 # 得到五日均线价格
16 ma5 = round(df['close'][-5:].mean(), 3)
17
18 # 得到十日均线价格
19 ma10 = round(df['close'][-10:].mean(), 3)
20
21 # 取得昨天收盘价
22 price = data[security]['close']
23
24 # 得到当前资金余额
25 cash = context.portfolio.cash
26
27 # 如果当前有余额，并且五日均线大于十日均线
28 if ma5 > ma10:
29 # 用所有 cash 买入股票
30 order_value(security, cash)
31 # 记录这次买入
32 log.info("Buying %s" % (security))
33
34 # 如果五日均线小于十日均线，并且目前有头寸
35 elif ma5 < ma10 and get_position(security).amount > 0:
36 # 全部卖出
37 order_target(security, 0)
38 # 记录这次卖出
39 log.info("Selling %s" % (security))
macd策略
指数平滑均线函数，以price计算，可以选择收盘、开盘价等价格，N为时间周期，m用于计算平滑系数a=m/(N+1)，EXPMA1为前一日值 def f_expma(N,m,EXPMA1,price):
2 a = m/(N+1)
3 EXPMA2 = a * price + (1 - a)*EXPMA1
4 return EXPMA2 #2为后一天值
5
6 #定义macd函数，输入平滑系数参数、前一日值，输出当日值
7 def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):
8 EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)
9 EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)
10 DIF2 = EXPMA12_2 - EXPMA26_2
11 a = m/(N3+1)
12 DEA2 = a * DIF2 + (1 - a)*DEA1
13 BAR2=2*(DIF2-DEA2)
14 return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2
15
16 def initialize(context):
17 global init_price
18 init_price = None
19 # 获取沪深300股票
20 g.security = get_index_stocks('000300.SS')
21 #g.security = ['600570.SS']
22 # 设置我们要操作的股票池, 这里我们只操作一支股票
23 set_universe(g.security)
24
25 def handle_data(context, data):
26 # 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取
27 # 从股票上市至今的所有历史数据，即增加获取的天数
28 close_price = get_history(2, '1d', field='close', security_list=g.security)
29 #如果是停牌不进行计算
30 for security in g.security:
31 if data[security].is_open >0:
32 global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2
33 if init_price is None:
34 init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值
35 EXPMA12_1 = init_price
36 EXPMA26_1 = init_price
37 DIF1 = init_price
38 DEA1 = init_price
39 # m用于计算平滑系数a=m/(N+1)
40 m = 2.0
41 #设定指数平滑基期数
42 N1 = 12
43 N2 = 26
44 N3 = 9
45 EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])
46 # 取得当前价格
47 current_price = data[security].price
48 # 取得当前的现金
49 cash = context.portfolio.cash
50 # DIF、DEA均为正，DIF向上突破DEA，买入信号参考
51 if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:
52 # 计算可以买多少只股票
53 number_of_shares = int(cash/current_price)
54 # 购买量大于0时，下单
55 if number_of_shares > 0:
56 # 以市单价买入股票，日回测时即是开盘价
57 order(security, +number_of_shares)
58 # 记录这次买入
59 log.info("Buying %s" % (security))
60 # DIF、DEA均为负，DIF向下突破DEA，卖出信号参考
61 elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:
62 # 卖出所有股票,使这只股票的最终持有量为0
63 order_target(security, 0)
64 # 记录这次卖出
65 log.info("Selling %s" % (security))
66 # 将今日的值赋给全局变量作为下一次前一日的值
67 DEA1 = DEA2
68 DIF1 = DIF2
69 EXPMA12_1 = EXPMA12_2
70 EXPMA26_1 = EXPMA26_2

同时也支持可转债T+0交易，笔者平时也主要是进行的可转债的交易。

软件与交易接口开通条件，

开通改券商后，存入资金50W放2周即可开通，开通后可取出。

本身券商的交易费率为股票万一免五，可转债百万分之二，非常厚道，因为不少面向机构的量化交易软件的佣金是万2.5的，笔者之前在国金渠道开的就是，坑的一比。所以笔者还是很推荐目前该券商的量化交易接口。

需要可以关注公众号获取开通链接：查看全部

不少在A股做量化的基本千篇一律tushare，优矿，米筐，聚宽等等，无论教程也好。

实际操作也好，几乎没见几个人教你怎么用程序下单，实盘交易。

稍微好点的easytrader使用的是模拟点击交易软件进行点击下单，基本无法判断下单后是否成交，也无法实时获取行情数据。别跟我说用tushare或者新浪这些接口数据，除非你做的是低频交易。

试试扫描一次全市场的行情看看用时多少？等得到满足条件了，再下单，此时价格可能已经在涨停板上封住了。

笔者使用的是券商提供的量化软件：Ptrade。

是恒生电子研发的提供给券商机构使用的程序化交易软件。提供策略回测，自动下单功能，使用的开发语言python。

策略回测与实盘交易

回测策略

实际代码需要在回测策略里面写，写完后确定无误，就可以放在仿真环境下真实运行。

如果你运行得到的结果很满意，那么就可以直接部署到实盘服务器上。

实盘服务器是在券商那边，不需要个人购买服务器，也不需要本地开着这个Ptrade，就是说不需要在个人电脑上一直开着跑，你的最终代码和程序是在券商服务器上部署与运行，除非有报错异常停止，不然在你不暂停或者停止的前提下，可以一直运行下去。

条件满足后下单

可视化量化

同时也提供一些常见的现成的量化策略，选中后只要鼠标点点点也能够自动化跑这些策略了，当然里面很多参数都可以用鼠标点点点修改。

接口文档也非常详细：

一些常见策略代码：

双均线策略

    def initialize(context):

 2    # 初始化此策略

 3    # 设置我们要操作的股票池, 这里我们只操作一支股票

 4    g.security = '600570.SS'

 5    set_universe(g.security)

 6    pass

 7

 8 #当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

 9 def handle_data(context, data):

10    security = g.security

11

12    #得到十日历史价格

13    df = get_history(10, '1d', 'close', security, fq=None, include=False)

14

15    # 得到五日均线价格

16    ma5 = round(df['close'][-5:].mean(), 3)

17

18    # 得到十日均线价格

19    ma10 = round(df['close'][-10:].mean(), 3)

20

21    # 取得昨天收盘价

22    price = data[security]['close']

23

24    # 得到当前资金余额

25    cash = context.portfolio.cash

26

27    # 如果当前有余额，并且五日均线大于十日均线

28    if ma5 > ma10:

29        # 用所有 cash 买入股票

30        order_value(security, cash)

31        # 记录这次买入

32        log.info("Buying %s" % (security))

33

34    # 如果五日均线小于十日均线，并且目前有头寸

35    elif ma5 < ma10 and get_position(security).amount > 0:

36        # 全部卖出

37        order_target(security, 0)

38        # 记录这次卖出

39        log.info("Selling %s" % (security))

macd策略
指数平滑均线函数，以price计算，可以选择收盘、开盘价等价格，N为时间周期，m用于计算平滑系数a=m/(N+1)，EXPMA1为前一日值

    def f_expma(N,m,EXPMA1,price):

 2    a = m/(N+1)

 3    EXPMA2 = a * price + (1 - a)*EXPMA1

 4    return EXPMA2 #2为后一天值

 5

 6 #定义macd函数，输入平滑系数参数、前一日值，输出当日值

 7  def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):

 8    EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)

 9    EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)

10    DIF2 = EXPMA12_2 - EXPMA26_2

11    a = m/(N3+1)

12    DEA2 = a * DIF2 + (1 - a)*DEA1

13    BAR2=2*(DIF2-DEA2)

14    return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2

15

16  def initialize(context):

17    global init_price

18    init_price = None

19    # 获取沪深300股票

20    g.security = get_index_stocks('000300.SS')

21    #g.security = ['600570.SS']

22    # 设置我们要操作的股票池, 这里我们只操作一支股票

23    set_universe(g.security)

24

25  def handle_data(context, data):

26    # 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取

27    # 从股票上市至今的所有历史数据，即增加获取的天数

28    close_price = get_history(2, '1d', field='close', security_list=g.security)

29    #如果是停牌不进行计算

30    for security in g.security:

31        if data[security].is_open >0:

32            global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2

33            if init_price is None:

34                init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值

35                EXPMA12_1 = init_price

36                EXPMA26_1 = init_price

37                DIF1 = init_price

38                DEA1 = init_price

39            # m用于计算平滑系数a=m/(N+1)

40            m = 2.0

41            #设定指数平滑基期数

42            N1 = 12

43            N2 = 26

44            N3 = 9

45            EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])

46            # 取得当前价格

47            current_price = data[security].price

48            # 取得当前的现金

49            cash = context.portfolio.cash

50            # DIF、DEA均为正，DIF向上突破DEA，买入信号参考

51            if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:

52                # 计算可以买多少只股票

53                number_of_shares = int(cash/current_price)

54                # 购买量大于0时，下单

55                if number_of_shares > 0:

56                    # 以市单价买入股票，日回测时即是开盘价

57                    order(security, +number_of_shares)

58                    # 记录这次买入

59                    log.info("Buying %s" % (security))

60            # DIF、DEA均为负，DIF向下突破DEA，卖出信号参考

61            elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:

62                # 卖出所有股票,使这只股票的最终持有量为0

63                order_target(security, 0)

64                # 记录这次卖出

65                log.info("Selling %s" % (security))

66            # 将今日的值赋给全局变量作为下一次前一日的值

67            DEA1 = DEA2

68            DIF1 = DIF2

69            EXPMA12_1 = EXPMA12_2

70            EXPMA26_1 = EXPMA26_2

同时也支持可转债T+0交易，笔者平时也主要是进行的可转债的交易。

软件与交易接口开通条件，

开通改券商后，存入资金50W放2周即可开通，开通后可取出。

本身券商的交易费率为股票万一免五，可转债百万分之二，非常厚道，因为不少面向机构的量化交易软件的佣金是万2.5的，笔者之前在国金渠道开的就是，坑的一比。所以笔者还是很推荐目前该券商的量化交易接口。

需要可以关注公众号获取开通链接：

Ptrade策略示例

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 4598 次浏览 • 2021-05-26 19:02 • 来自相关话题

策略示例

集合竞价追涨停策略def initialize(context):
# 初始化此策略
# 设置我们要操作的股票池, 这里我们只操作一支股票
g.security = '600570.SS'
set_universe(g.security)
#每天9:23分运行集合竞价处理函数
run_daily(context, aggregate_auction_func, time='9:23')

def aggregate_auction_func(context):
stock = g.security
#最新价
snapshot = get_snapshot(stock)
price = snapshot[stock]['last_px']
#涨停价
up_limit = snapshot[stock]['up_px']
#如果最新价不小于涨停价，买入
if float(price) >= float(up_limit):
order(g.security, 100, limit_price=up_limit)

def handle_data(context, data):
pass
tick级别均线策略def initialize(context):
# 初始化此策略
# 设置我们要操作的股票池, 这里我们只操作一支股票
g.security = '600570.SS'
set_universe(g.security)
#每3秒运行一次主函数
run_interval(context, func, seconds=3)

#盘前准备历史数据
def before_trading_start(context, data):
history = get_history(10, '1d', 'close', g.security, fq='pre', include=False)
g.close_array = history['close'].values

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出
def func(context):

stock = g.security

#获取最新价
snapshot = get_snapshot(stock)
price = snapshot[stock]['last_px']

# 得到五日均线价格
days = 5
ma5 = get_MA_day(stock, days, g.close_array[-4:], price)
# 得到十日均线价格
days = 10
ma10 = get_MA_day(stock, days, g.close_array[-9:], price)

# 得到当前资金余额
cash = context.portfolio.cash

# 如果当前有余额，并且五日均线大于十日均线
if ma5 > ma10:
# 用所有 cash 买入股票
order_value(stock, cash)
# 记录这次买入
log.info("Buying %s" % (stock))

# 如果五日均线小于十日均线，并且目前有头寸
elif ma5 < ma10 and get_position(stock).amount > 0:
# 全部卖出
order_target(stock, 0)
# 记录这次卖出
log.info("Selling %s" % (stock))

#计算实时均线函数
def get_MA_day(stock,days,close_array,current_price):
close_sum = close_array[-(days-1):].sum()
MA = (current_price + close_sum)/days
return MA

def handle_data(context, data):
pass
双均线策略def initialize(context):
# 初始化此策略
# 设置我们要操作的股票池, 这里我们只操作一支股票
g.security = '600570.SS'
set_universe(g.security)
pass

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出
def handle_data(context, data):
security = g.security

#得到十日历史价格
df = get_history(10, '1d', 'close', security, fq=None, include=False)

# 得到五日均线价格
ma5 = round(df['close'][-5:].mean(), 3)

# 得到十日均线价格
ma10 = round(df['close'][-10:].mean(), 3)

# 取得昨天收盘价
price = data[security]['close']

# 得到当前资金余额
cash = context.portfolio.cash

# 如果当前有余额，并且五日均线大于十日均线
if ma5 > ma10:
# 用所有 cash 买入股票
order_value(security, cash)
# 记录这次买入
log.info("Buying %s" % (security))

# 如果五日均线小于十日均线，并且目前有头寸
elif ma5 < ma10 and get_position(security).amount > 0:
# 全部卖出
order_target(security, 0)
# 记录这次卖出
log.info("Selling %s" % (security))
macd策略

指数平滑均线函数，以price计算，可以选择收盘、开盘价等价格，N为时间周期，m用于计算平滑系数a=m/(N+1)，EXPMA1为前一日值def f_expma(N,m,EXPMA1,price):
a = m/(N+1)
EXPMA2 = a * price + (1 - a)*EXPMA1
return EXPMA2 #2为后一天值

#定义macd函数，输入平滑系数参数、前一日值，输出当日值
def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):
EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)
EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)
DIF2 = EXPMA12_2 - EXPMA26_2
a = m/(N3+1)
DEA2 = a * DIF2 + (1 - a)*DEA1
BAR2=2*(DIF2-DEA2)
return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2

def initialize(context):
global init_price
init_price = None
# 获取沪深300股票
g.security = get_index_stocks('000300.SS')
#g.security = ['600570.SS']
# 设置我们要操作的股票池, 这里我们只操作一支股票
set_universe(g.security)

def handle_data(context, data):
# 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取
# 从股票上市至今的所有历史数据，即增加获取的天数
close_price = get_history(2, '1d', field='close', security_list=g.security)
#如果是停牌不进行计算
for security in g.security:
if data[security].is_open >0:
global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2
if init_price is None:
init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值
EXPMA12_1 = init_price
EXPMA26_1 = init_price
DIF1 = init_price
DEA1 = init_price
# m用于计算平滑系数a=m/(N+1)
m = 2.0
#设定指数平滑基期数
N1 = 12
N2 = 26
N3 = 9
EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])
# 取得当前价格
current_price = data[security].price
# 取得当前的现金
cash = context.portfolio.cash
# DIF、DEA均为正，DIF向上突破DEA，买入信号参考
if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:
# 计算可以买多少只股票
number_of_shares = int(cash/current_price)
# 购买量大于0时，下单
if number_of_shares > 0:
# 以市单价买入股票，日回测时即是开盘价
order(security, +number_of_shares)
# 记录这次买入
log.info("Buying %s" % (security))
# DIF、DEA均为负，DIF向下突破DEA，卖出信号参考
elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:
# 卖出所有股票,使这只股票的最终持有量为0
order_target(security, 0)
# 记录这次卖出
log.info("Selling %s" % (security))
# 将今日的值赋给全局变量作为下一次前一日的值
DEA1 = DEA2
DIF1 = DIF2
EXPMA12_1 = EXPMA12_2
EXPMA26_1 = EXPMA26_2
如果需要开通Ptrade量化接口，只需资金50W存放一周即可。
交易费率也很便宜，股票万一，基金万0.6，可转债百万分之二。
量化接口不需要收取任何费用。
有意者可以扫码开户：查看全部

策略示例

集合竞价追涨停策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')  



def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

    

def handle_data(context, data):

    pass

tick级别均线策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每3秒运行一次主函数

    run_interval(context, func, seconds=3)

      

#盘前准备历史数据

def before_trading_start(context, data):

    history = get_history(10, '1d', 'close', g.security, fq='pre', include=False)

    g.close_array = history['close'].values

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def func(context):

    

    stock = g.security

    

    #获取最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    

    # 得到五日均线价格

    days = 5

    ma5 = get_MA_day(stock, days, g.close_array[-4:], price)   

    # 得到十日均线价格

    days = 10

    ma10 = get_MA_day(stock, days, g.close_array[-9:], price)



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(stock, cash)

        # 记录这次买入

        log.info("Buying %s" % (stock))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(stock).amount > 0:

        # 全部卖出

        order_target(stock, 0)

        # 记录这次卖出

        log.info("Selling %s" % (stock))    



#计算实时均线函数

def get_MA_day(stock,days,close_array,current_price):

    close_sum = close_array[-(days-1):].sum()

    MA = (current_price + close_sum)/days

    return MA



def handle_data(context, data):

    pass

双均线策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    pass

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def handle_data(context, data):

    security = g.security



    #得到十日历史价格

    df = get_history(10, '1d', 'close', security, fq=None, include=False)

    

    # 得到五日均线价格

    ma5 = round(df['close'][-5:].mean(), 3)

    

    # 得到十日均线价格

    ma10 = round(df['close'][-10:].mean(), 3)



    # 取得昨天收盘价

    price = data[security]['close']



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(security, cash)

        # 记录这次买入

        log.info("Buying %s" % (security))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(security).amount > 0:

        # 全部卖出

        order_target(security, 0)

        # 记录这次卖出

        log.info("Selling %s" % (security))

macd策略

指数平滑均线函数，以price计算，可以选择收盘、开盘价等价格，N为时间周期，m用于计算平滑系数a=m/(N+1)，EXPMA1为前一日值

def f_expma(N,m,EXPMA1,price):

    a = m/(N+1)

    EXPMA2 = a * price + (1 - a)*EXPMA1

    return EXPMA2 #2为后一天值



#定义macd函数，输入平滑系数参数、前一日值，输出当日值

def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):

    EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)

    EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)

    DIF2 = EXPMA12_2 - EXPMA26_2

    a = m/(N3+1)

    DEA2 = a * DIF2 + (1 - a)*DEA1

    BAR2=2*(DIF2-DEA2)

    return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2



def initialize(context):

    global init_price

    init_price = None

    # 获取沪深300股票

    g.security = get_index_stocks('000300.SS')

    #g.security = ['600570.SS']

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    set_universe(g.security)



def handle_data(context, data):

    # 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取

    # 从股票上市至今的所有历史数据，即增加获取的天数

    close_price = get_history(2, '1d', field='close', security_list=g.security)

    #如果是停牌不进行计算

    for security in g.security:

        if data[security].is_open >0:

            global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2

            if init_price is None:

                init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值

                EXPMA12_1 = init_price

                EXPMA26_1 = init_price

                DIF1 = init_price

                DEA1 = init_price

            # m用于计算平滑系数a=m/(N+1)

            m = 2.0

            #设定指数平滑基期数

            N1 = 12

            N2 = 26

            N3 = 9

            EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])

            # 取得当前价格

            current_price = data[security].price

            # 取得当前的现金

            cash = context.portfolio.cash

            # DIF、DEA均为正，DIF向上突破DEA，买入信号参考

            if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:

                # 计算可以买多少只股票

                number_of_shares = int(cash/current_price)

                # 购买量大于0时，下单

                if number_of_shares > 0:

                    # 以市单价买入股票，日回测时即是开盘价

                    order(security, +number_of_shares)

                    # 记录这次买入

                    log.info("Buying %s" % (security))

            # DIF、DEA均为负，DIF向下突破DEA，卖出信号参考

            elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:

                # 卖出所有股票,使这只股票的最终持有量为0

                order_target(security, 0)

                # 记录这次卖出

                log.info("Selling %s" % (security))

            # 将今日的值赋给全局变量作为下一次前一日的值

            DEA1 = DEA2

            DIF1 = DIF2

            EXPMA12_1 = EXPMA12_2

            EXPMA26_1 = EXPMA26_2

如果需要开通Ptrade量化接口，只需资金50W存放一周即可。
交易费率也很便宜，股票万一，基金万0.6，可转债百万分之二。
量化接口不需要收取任何费用。
有意者可以扫码开户：

python判断可转债是否强赎

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 2732 次浏览 • 2021-04-02 13:41 • 来自相关话题

占坑，后期把代码整理下放上来。

更新：

制作好了一个接口，用户可以直接调用。
数据来源与集思录。
获取排除满足强赎天数剩余N天的可转债，排除强赎可转债。

比如：DAY=4 ，那么假设强赎满足天数为15天，那么返回市场上强赎强赎倒数天数大于4天的可转债，即返回小于或者等于11天以下的转债。把满足条件还差4天的转债排除掉了，当然，已经公告强赎的也会被排除。

import requests

URL = 'http://11.11.11.11/api/redeem/'
# DAY 强赎倒数剩余天数小于 DAY （4）天，已经公告强赎的也是被排除的
DAY = 4

SIGN = '私信星主获取' # sign和以前一致

data = {'day': DAY,
'sign': SIGN}
r = requests.post(URL, data=data)

print(r.json())
具体用户可以关注知识星球：查看全部

占坑，后期把代码整理下放上来。

更新：

制作好了一个接口，用户可以直接调用。
数据来源与集思录。

获取 排除满足强赎天数剩余N天的可转债，排除强赎可转债。



比如：DAY=4 ，那么假设强赎满足天数为15天，那么返回市场上强赎强赎倒数天数大于4天的可转债，即返回小于或者等于11天以下的转债。把满足条件还差4天的转债排除掉了，当然，已经公告强赎的也会被排除。







import requests



URL = 'http://11.11.11.11/api/redeem/'

# DAY 强赎倒数剩余天数小于 DAY （4）天， 已经公告强赎的也是被排除的

DAY = 4



SIGN = '私信星主获取' # sign和以前一致



data = {'day': DAY,

        'sign': SIGN}

r = requests.post(URL, data=data)



print(r.json())

具体用户可以关注知识星球：

PTrade新手入门教程二

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 4488 次浏览 • 2021-03-29 11:41 • 来自相关话题

1. 执行顺序：
最开始是initialize，然后是before_trading_start，然后handle_data,后来到after_trading_end

2. log.debug 的输出是不在控制台的。难道这个是个bug？？？官方回复：是的，除了log.info 可以输出，其他都无法输出

3. 在中午休息时间，handle_data 是停止不运行的，其他放在run_interval函数里面调用的也是处于停滞状态。

需要开通Ptrade的朋友可以加微信联系：门槛低，只需要30W，存放一周就可以了
交易费率股票万一免5，基金万0.6，转债百万分之二查看全部

PTrade python 第三方模块被禁止使用

股票 • 李魔佛发表了文章 • 0 个评论 • 2329 次浏览 • 2021-03-21 12:00 • 来自相关话题

import os 回测运行失败, 错误码:3 错误信息: os被禁止使用
在研究/回测/交易中都被禁止了。因为要做到系统隔离，不给删除，读取容器内的数据
PTrade使用教程新手入门查看全部

import os 回测运行失败, 错误码:3 错误信息: os被禁止使用
在研究/回测/交易中都被禁止了。因为要做到系统隔离，不给删除，读取容器内的数据
PTrade使用教程新手入门

弘盈A套利总结的经验 --大幅度溢价的不能用拖拉机

股票 • 李魔佛发表了文章 • 0 个评论 • 2125 次浏览 • 2021-03-19 11:31 • 来自相关话题

轻松出货的券商：
华泰，招商

排队的：
华宝，银河

PTrade使用教程新手入门

股票 • 李魔佛发表了文章 • 0 个评论 • 12718 次浏览 • 2021-03-18 08:55 • 来自相关话题

# 更新 Ptrade API 接口文档： http://ptradeapi.com 这样就可以边打开网页，边写代码，不用在ptrade的代码编写和帮助页面来回切换了。
记录一下曾经的入门经验与使用心得：

好像PTrade有几个版本，本人使用的界面如下，基于python写交易策略和回测：

1. 仿真系统的回测可以在交易时间运行，交易系统的回测无法在交易时间运行回测。

2. 在研究板块中，API函数带有研究字样的，可以直接使用，不需要import 导入任何库。比如：#获取当日的股票池
g.stock_list = get_Ashares(g.current_date)可以自己使用。

而get_history(70, '1d', ['close','volume'], g.stock_list, fq='dypre', include=False)
没有带研究字样的，是无法直接在研究板块使用，只能在回测或者实盘使用。

3. 内置的python版本是：
'3.5.1 (default, Nov 1 2016, 01:53:03) \n[GCC 4.8.5 20150623 (Red Hat 4.8.5-4)]'

也就是无法使用fstring的方式格式化字符串
name='jack'
a=f'{name}'

4. log.debug log.error 等调试标记符不会有任何输出，bug！
只能使用log.info 或者print输出，还害我调试了半天，以为程序哪里的问题，导致我的输出不显示。

PTrade新手入门教程二

需要开通Ptrade的朋友，可以扫描二维码开户，并可开通PTrade交易功能。
股票费率万分之一，转债十万分之二。

非诚勿扰。

原创文章，转载请注明出处
http://30daydo.com/article/44151
查看全部

# 更新 Ptrade API 接口文档： http://ptradeapi.com 这样就可以边打开网页，边写代码，不用在ptrade的代码编写和帮助页面来回切换了。
记录一下曾经的入门经验与使用心得：

好像PTrade有几个版本，本人使用的界面如下，基于python写交易策略和回测：

1. 仿真系统的回测可以在交易时间运行，交易系统的回测无法在交易时间运行回测。

2. 在研究板块中，API函数带有研究字样的，可以直接使用，不需要import 导入任何库。比如：

#获取当日的股票池

g.stock_list = get_Ashares(g.current_date)

可以自己使用。

而

get_history(70, '1d', ['close','volume'], g.stock_list, fq='dypre', include=False)

没有带研究字样的，是无法直接在研究板块使用，只能在回测或者实盘使用。

3. 内置的python版本是：
'3.5.1 (default, Nov 1 2016, 01:53:03) \n[GCC 4.8.5 20150623 (Red Hat 4.8.5-4)]'

也就是无法使用fstring的方式格式化字符串
name='jack'
a=f'{name}'

4. log.debug log.error 等调试标记符不会有任何输出，bug！
只能使用log.info 或者print输出，还害我调试了半天，以为程序哪里的问题，导致我的输出不显示。

PTrade新手入门教程二

需要开通Ptrade的朋友，可以扫描二维码开户，并可开通PTrade交易功能。
股票费率万分之一，转债十万分之二。

非诚勿扰。

原创文章，转载请注明出处
http://30daydo.com/article/44151

PTrade当前时间不允许创建回测

股票 • 李魔佛发表了文章 • 0 个评论 • 3640 次浏览 • 2021-03-17 10:35 • 来自相关话题

PTrade在开盘时间是无法跑回测的，估计为了考虑服务器的压力，开盘时间更多的是实盘在运行，所以为的节省点带宽。

如果需要在盘中时间回测，可以使用模拟账户来回测，甚至跟踪实盘。
如果没有模拟账户，需要找对应的券商经理申请。
在这边开户，会一条龙提供服务。

开户福利：
Ptrade低门槛开通，入金1W即可开通，费率股票万一

Ptrade券商开户：门槛低查看全部

PTrade在开盘时间是无法跑回测的，估计为了考虑服务器的压力，开盘时间更多的是实盘在运行，所以为的节省点带宽。

如果需要在盘中时间回测，可以使用模拟账户来回测，甚至跟踪实盘。
如果没有模拟账户，需要找对应的券商经理申请。
在这边开户，会一条龙提供服务。

开户福利：
Ptrade低门槛开通，入金1W即可开通，费率股票万一

Ptrade券商开户：门槛低

a股券商开户万1免五没有最低消费

券商万一免五 • 李魔佛发表了文章 • 0 个评论 • 13357 次浏览 • 2021-03-07 17:51 • 来自相关话题

最近市场上貌似没有几家万一免5的了，之前的银河证券被举报了，免5的费率被取消了。
不过之前还找到一家万一免五的，没有最低费率，用多少算多少，比如买了1000元股票，那么费率只有1000*万分之一，等于1分钱，略等于不用钱哈。
优势杠杆的。

需要的点击下面链接即可开户：注意：当前默认的免五已经取消了，需要开通量化交易权限后可以进行免五操作。

开通ptrade和qmt量化交易接口的条件，入金30万，过3天左右可以开通，开通后可以免五！

交割单：

心动不，赶紧心动吧。

该券商也支持同花顺客户端登录，做量化的使用easytrader也可以友好支持。

如果有疑问，可以扫码咨询。备注：开户

查看全部

心动不，赶紧心动吧。

该券商也支持同花顺客户端登录，做量化的使用easytrader也可以友好支持。

如果有疑问，可以扫码咨询。备注：开户

想用程序自动化交易；大佬们都用哪个lib 提交订单；【比如同花顺；平安证券等】多谢

贡献

股票 • 李魔佛回复了问题 • 1 人关注 • 2 个回复 • 5067 次浏览 • 2021-07-16 21:44 • 来自相关话题

证券etf和券商etf的区别

券商万一免五 • 李魔佛发表了文章 • 0 个评论 • 48682 次浏览 • 2020-02-10 23:48 • 来自相关话题

证券etf是：国泰中证全指证券公司ETF（512880）LOF/ETF

而券商etf是：
华宝中证全指证券公司ETF （512000）LOF/ETF

二者都是指数/lof基金，而且持仓差不多都一样的。

证券etf的持仓：

券商etf的持仓：

不同的是规模，证券ETF的规模要比券商etf的规模要大得多。目前是2倍左右的差距【2019年的数据】。所以如果你关心的是流动性，那么可以买证券ETF。

最新的规模【2020-06】其实二者在缩小，具体数据见文末。

证券ETF的规模是190亿

而券商ETF规模为160亿。(最近增长比较多，笔者在1年前记录的数据为30亿，可以到http://fundf10.eastmoney.com/gmbd_512000.html 查看历史规模。现在券商ETF的规模翻了一番。

更多量化分析，关注公众号：可转债量化分析
券商开户股票万一免5，基金申购一折，拖拉机6+1，关注公众号留言。
可转债手续费百万分之二，一万块手续费才2分钱，没有最低限制（没有最低收1元，1毛这种）

（教你使用python进行量化分析股票，可转债数据）

查看全部

证券etf是：国泰中证全指证券公司ETF（512880）LOF/ETF

而券商etf是：
华宝中证全指证券公司ETF （512000）LOF/ETF

二者都是指数/lof基金，而且持仓差不多都一样的。

证券etf的持仓：

券商etf的持仓：

不同的是规模，证券ETF的规模要比券商etf的规模要大得多。目前是2倍左右的差距【2019年的数据】。所以如果你关心的是流动性，那么可以买证券ETF。

最新的规模【2020-06】其实二者在缩小，具体数据见文末。

证券ETF的规模是190亿

而券商ETF规模为160亿。(最近增长比较多，笔者在1年前记录的数据为30亿，可以到http://fundf10.eastmoney.com/gmbd_512000.html 查看历史规模。现在券商ETF的规模翻了一番。

更多量化分析，关注公众号：可转债量化分析
券商开户股票万一免5，基金申购一折，拖拉机6+1，关注公众号留言。
可转债手续费百万分之二，一万块手续费才2分钱，没有最低限制（没有最低收1元，1毛这种）

（教你使用python进行量化分析股票，可转债数据）

nunpy中的std标准差是样本差吗

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 3728 次浏览 • 2019-07-01 10:08 • 来自相关话题

写个代码测试下：
# 测试一下那个方差
x=[1,2,3,4,5,6,7,8,9,10]
X = np.array(x)
X.mean()
5.5

X.std() # 标准差
2.8722813232690143

手工计算一下：
def my_fangca(X):
l=len(X)
mean=X.mean()
sum_ = 0
sum_std=0
for i in X:
sum_+=(i-mean)**2
var_=sum_/l
std_=(sum_/(l))**0.5
return var_,std_
result = my_fangca(X)
得到的result

(8.25, 2.8722813232690143)

说明numpy的std是标准差，不是样本差查看全部

写个代码测试下：

# 测试一下那个方差

x=[1,2,3,4,5,6,7,8,9,10]

X = np.array(x)

X.mean()
5.5

X.std() # 标准差
2.8722813232690143

手工计算一下：

def my_fangca(X):

    l=len(X)

    mean=X.mean()

    sum_ = 0

    sum_std=0

    for i in X:

        sum_+=(i-mean)**2

    var_=sum_/l

    std_=(sum_/(l))**0.5

    return var_,std_

result = my_fangca(X)
得到的result

(8.25, 2.8722813232690143)

说明numpy的std是标准差，不是样本差

修改easytrader国金证券的默认启动路径

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 5021 次浏览 • 2019-06-17 10:23 • 来自相关话题

如果你的国金证券不是安装在默认路径的话，会无法启动。报错：

pywinauto.application.AppStartError: Could not create the process "C:\全能行证券交易终端\xiadan.exe"
Error returned by CreateProcess: (2, 'CreateProcess', '系统找不到指定的文件。')

看了配置文件，也是没有具体的参数可以修改，只好修改源代码。
别听到改源代码就害怕，只是需要改一行就可以了。

找到文件：
site-package\easytrader\config\client.py

找过这一行：
class GJ(CommonConfig):
DEFAULT_EXE_PATH = "C:\\Tool\\xiadan.exe"只要修改上面的路径就可以了。注意用双斜杠。
查看全部

如果你的国金证券不是安装在默认路径的话，会无法启动。报错：

pywinauto.application.AppStartError: Could not create the process "C:\全能行证券交易终端\xiadan.exe"
Error returned by CreateProcess: (2, 'CreateProcess', '系统找不到指定的文件。')

看了配置文件，也是没有具体的参数可以修改，只好修改源代码。
别听到改源代码就害怕，只是需要改一行就可以了。

找到文件：
site-package\easytrader\config\client.py

找过这一行：

class GJ(CommonConfig):

    DEFAULT_EXE_PATH = "C:\\Tool\\xiadan.exe"

只要修改上面的路径就可以了。注意用双斜杠。

【可转债数据】发行速度趋势

股票 • 李魔佛发表了文章 • 2 个评论 • 3388 次浏览 • 2019-04-08 16:24 • 来自相关话题

随着年后股市一波流，每天涨涨涨，发行可转债的数量也越来越多。
用pyecharts做了一张趋势图，可以显然易见地窥探目前可转债的发行速度。

实现代码也很简单：
（核心部分）
line=Line()
line.add('可转债个数趋势',b,v,mark_line=["average"], mark_point=["max", "min"])
2018年初的时候只有36只可转债，到了今天（2019-04-08），已经有138只，扩容了4倍有多。

不过个人认为随着股市深入回调（具体什么时候我也不知道，小散就不要预测指数跳大神了），发行速度会因为面临破发再次减缓。

上图中曲线较为较为平滑的部分就是股市回调阶段，可转债上市就大面积破发。
目前以较大的斜率保持上升，而且目前上市价格都是20%以上。离破发还很远。
但是不能掉以轻心，一旦行情断崖式暴跌，高价转债会面临动辄超过10个点的跌幅。
所以现阶段还是要远离高价转债。当然艺高人胆大者或者套利纯熟者就无视吧，每个人都有自己模式内的操作方法

上述数据小编会每周更新一次。查看全部

随着年后股市一波流，每天涨涨涨，发行可转债的数量也越来越多。
用pyecharts做了一张趋势图，可以显然易见地窥探目前可转债的发行速度。

实现代码也很简单：
（核心部分）

line=Line()

line.add('可转债个数趋势',b,v,mark_line=["average"], mark_point=["max", "min"])

2018年初的时候只有36只可转债，到了今天（2019-04-08），已经有138只，扩容了4倍有多。

不过个人认为随着股市深入回调（具体什么时候我也不知道，小散就不要预测指数跳大神了），发行速度会因为面临破发再次减缓。

上图中曲线较为较为平滑的部分就是股市回调阶段，可转债上市就大面积破发。
目前以较大的斜率保持上升，而且目前上市价格都是20%以上。离破发还很远。
但是不能掉以轻心，一旦行情断崖式暴跌，高价转债会面临动辄超过10个点的跌幅。
所以现阶段还是要远离高价转债。当然艺高人胆大者或者套利纯熟者就无视吧，每个人都有自己模式内的操作方法

上述数据小编会每周更新一次。

【手把手教你】量价关系分析与Python实现

量化交易-Ptrade-QMT • Python金融量化发表了文章 • 3 个评论 • 6932 次浏览 • 2019-04-01 17:15 • 来自相关话题

如果操作过量，即使对市场判断正确，仍会一败涂地。——索罗斯

引言

成交量是股票市场的温度计，许多股票的疯狂上涨并非基本面发生了实质性的变化，而是短期筹码和资金供求关系造成的。量价关系分析法是一种将价格走势与成交量变化相结合的研究方法，正所谓，大军未动，粮草先行。成交量一直被看为是股票市场的“粮草”，成交量的变化是股价变化的前兆。因此，成交量是分析判断市场行情,并作出投资决策时的重要依据,也是各种技术分析指标应用时不可或缺的参照。

本文延续“手把手教你使用Python的TA-Lib”系列，着重介绍交易量指标（Volume Indicators）及其运用。【手把手教你】股市技术分析利器之TA-Lib（一）主要探讨了重叠指标的相关原理与Python实现，【手把手教你】股市技术分析利器之TA-Lib（二）则着重介绍了TA-Lib中强大的数学运算、数学变换、统计函数、价格变换、周期指标和波动率指标函数及其应用实例。TA-Lib的安装使用可查看以前推文。



01
A/D Line 累积派发线

Chaikin Accumulation/Distribution Line （AD），是Marc Chaikin提出的用来平衡交易量的指标，以当日收盘价、最高价和最低价来估算一段时间内该股票累积的资金流量, 用来确定潜在的趋势以及预测趋势反转。

函数名：AD

调用格式：ta.AD(high,low,close,volume)

计算方法： AD＝前日AD值＋（多空对比*成交量）

多空对比=((收盘价－最低价)－(最高价－收盘价))/(最高价－最低价)；注意：当最高价等于最低价时，多空对比 = （收盘价 / 昨收盘） - 1

运用要点：

AD测量资金流向，AD向上表明多方占优势，反之表明空方占优势；

AD与价格的背离可视为买卖信号：底背离考虑买入，顶背离考虑卖出；

AD指标无需设置参数，但在应用时，可结合均线、MACD、KDJ等指标进行分析；

AD指标忽略了缺口的影响，有时无法真实反映价格与成交量的关系。

02
A/D Oscillator 震荡指标

震荡指标是计算长短周期的AD差，将资金流动情况与价格行为相对比，用来研判市场中资金流入和流出的情况。

函数名：ADOSC

调用格式：ta. ADOSC(high,low,close,volume,

fastperiod=3,slowperiod=10)

计算方法：fastperiod AD - slowperiod AD，AD的计算同上。

运用要点：

交易信号是背离：看涨背离做多，看跌背离做空；

股价与90天移动平均结合，与其他指标结合；

由正变负卖出，由负变正买进。

03
OBV - 能量潮

全称为 On Balance Volume, 由 Joe Granville 提出，通过统计成交量变动的趋势推测股价趋势。

函数名：OBV

调用格式：ta.OBV(close, volume)

计算公式：以某日为基期，逐日累计每日股票总成交量，若隔日指数或股票上涨，则基期OBV加上本日成交量为本日OBV。隔日指数或股票下跌，则基期OBV减去本日成交量为本日OBV。

研判：

以“N”字型为波动单位，一浪高于一浪称“上升潮”，下跌称“跌潮”；

上升潮买进，跌潮卖出；

须配合K线图、股价走势和其他指标。

04
应用实例代码

#先引入后面可能用到的包（package）
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

#正常显示画图时出现的中文和负号
from pylab import mpl
mpl.rcParams['font.sans-serif']=['SimHei']
mpl.rcParams['axes.unicode_minus']=False

#引入TA-Lib库
import talib as ta

#获取交易数据函数，这里使用tushare的老接口，比较方便
import tushare as ts
def get_data(code,start='2018-11-01',end='2019-03-26'):
    df=ts.get_k_data(code,start,end)
    df.index=pd.to_datetime(df.date)
    df=df.sort_index()
    return df[['open','close','high','low','volume']]

#获取当前交易是所有股票代码和名字
basics=ts.get_stock_basics()
print(len(basics))
#basics.head()

3602

index={'上证综指': 'sh','深证成指': 'sz','沪深300': 'hs300',
               '创业板指': 'cyb', '上证50': 'sz50','中小板指': 'zxb'}

#将当前交易的股票和常用指数代码和名称写入字典，方便调用
stock=dict(zip(basics.name,basics.index))
stocks=dict(stock,**index)

计算交易量指标并可视化

#使用matplotlib画k线图以及
import matplotlib.patches as patches
def plot_line(name):
    code=stocks[name]
    data=get_data(code)
    fig = plt.figure(figsize=(12,5))
    ax1 = fig.add_axes([0, 1, 1, 1])
    ax1.set_title(name+"K线图与交易量指标",  fontsize=15)
    ax1.set_xlim(-1, len(data)+1)

    for i in range(len(data)):
        close_price,open_price = data.iloc[i, 1], data.iloc[i, 0]
        high_price, low_price = data.iloc[i,2], data.iloc[i, 3]
        trade_date = data.index[i]
        if close_price > open_price:#画阳线
            ax1.add_patch(patches.Rectangle((i-0.2, open_price), 0.4, close_price-open_price, fill=False, color='r'))
            ax1.plot([i, i], [low_price, open_price], 'r')
            ax1.plot([i, i], [close_price, high_price], 'r')
        else:#画阴线
            ax1.add_patch(patches.Rectangle((i-0.2, open_price), 0.4, close_price-open_price, color='g'))
            ax1.plot([i, i], [low_price, high_price], color='g')
    ax1.set_title("Price", fontsize=15, loc='left', color='r')
    #设置x轴标签
    ax1.set_xticks(range(0,len(data),5))#位置
    ax1.set_xticklabels([(data.index[i]).strftime('%Y-%m-%d') for i in ax1.get_xticks()] , rotation=20)
    high, low, close, volume = np.array(data['high']),np.array(data['low']),np.array(data['close']),np.array(data['volume'])
    #计算AD线
    AD = ta.AD(high, low, close, volume)
    #计算ADOSC线
    ADOSC = ta.ADOSC(high,low, close, volume, fastperiod=3, slowperiod=10)
    #计算OBC线
    OBV = ta.OBV(close, volume)

    ax2 = ax1.twinx()
    ax2.plot(AD, color='r', linewidth=2, label='AD')
    ax2.plot(ADOSC, color='b', linewidth=2, label='ADOSC')
    ax2.plot(OBV, color='y', linewidth=2, label='OBV')
    ax2.legend(loc=0)
plot_line('东方通信')plot_line('上证综指')plot_line('创业板指')plot_line('中国平安')最后，在万矿上使用AD线进行了历史回测，作为演示例子，这里只对东方通信和中国平安股票进行了回测，期间为2018年1月1日至2019年3月25日。从AD线单一指标回测来看，在市场反弹或形成向上趋势时跑赢市场，但是最大回撤也比较大，如东方通信达到43.2%，当然这与回测期间和标的选择有很大的关系。这里只是作为演示例子，深入研究还得待结合其他指标。

东方通信AD线回测结果：

中国平安AD线回测结果：

结语

价量分析系统属于技术分析，而技术分析是股票分析的温度计。温度计无法预测未来的准确温度，更不可能决定温度。因此，技术分析只是告诉你发生了什么，但不能预测未来会发生什么。不要过于依赖技术指标提供的信号，市场总是充满突发性的事件，交易者情绪波动较大，因此股价并不是总是沿着规律运行。在使用量价关系时，不仅要分析量价关系中量的变化对价的影响，还应该分析量变化的原因，更应该知道这些变化之后交易者的情绪或行为，只有这样才能真正体会量价关系的精髓，提高自己预判的准确率。查看全部

可转债如何配债

股票 • 李魔佛发表了文章 • 0 个评论 • 12977 次浏览 • 2019-03-29 16:24 • 来自相关话题

由于还是有很多人不断问我如何配债的问题，这里以歌尔声学为例简单说明下。

1、如果你在登记日也就是12月11日收盘时还持有一定数量歌尔声学正股的话，那么你在配债日也就是12月12日就会看到账户里有相应数量的歌尔配债。注意这里的单位是张，如图，

由于我只有800股歌尔声学，因此获得了13张配债，1张对应100元，这时双击它，左侧出现了卖出菜单，价格和配债代码都自动填好了，输入13张或者点击全部，然后点“卖出”。（需要注意的是：有些券商这里是买入。）

2、不管是卖出还是买入，然后检查下委托情况和扣款情况，如下图：

可以看到我已经被扣款1300元，这样就算成功完成了这次的13张配债.

可转债低佣金开户，沪市转债费率百分之二，全市场最低。
有兴趣的朋友可以扫描开户：

查看全部

由于还是有很多人不断问我如何配债的问题，这里以歌尔声学为例简单说明下。

1、如果你在登记日也就是12月11日收盘时还持有一定数量歌尔声学正股的话，那么你在配债日也就是12月12日就会看到账户里有相应数量的歌尔配债。注意这里的单位是张，如图，

由于我只有800股歌尔声学，因此获得了13张配债，1张对应100元，这时双击它，左侧出现了卖出菜单，价格和配债代码都自动填好了，输入13张或者点击全部，然后点“卖出”。（需要注意的是：有些券商这里是买入。）

2、不管是卖出还是买入，然后检查下委托情况和扣款情况，如下图：

可以看到我已经被扣款1300元，这样就算成功完成了这次的13张配债.

可转债低佣金开户，沪市转债费率百分之二，全市场最低。
有兴趣的朋友可以扫描开户：

可转债价格分布堆叠图绘制可视化 python+pyecharts

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 7914 次浏览 • 2019-01-30 10:59 • 来自相关话题

这一节课带大家学习如何利用可视化，更好的呈现数据。
即使你有很多数据，可是，你无法直观地看到数据的总体趋势。使用可视化的绘图，可以帮助我们看到数据背后看不到的数据。比如我已经有每一个可转债的价格，评级。数据如下：

点击查看大图

如果我用下面的图形就可以看出规律：

点击查看大图

横坐标是价格，纵坐标是落在该价格的可转债数量，不同颜色代表不同评级的可转债。

可以看到大部分AA-评级（浅橙色）的可转债价格都在100元以下，而AA（浅蓝色）的可转债价格分布较为平均，从90到110都有。而AA+和AAA的一般都在100以上。

那么如何使用代码实现呢？from setting import get_mysql_conn,get_engine
import pandas as pd
import pymongo
from pyecharts import Geo,Style,Map
engine = get_engine('db_stock',local='local')
# 堆叠图
from pyecharts import Bar
df = pd.read_sql('tb_bond_jisilu',con=engine)

result ={}
for name,grades in df.groupby('评级'):
# print(name,grades[['可转债名称','可转债价格']])
for each in grades['可转债价格']:
result.setdefault(name,)
result[name].append(each)

# 确定价格的范围

value = [str(i) for i in range(85,140)]
ret = [0]*len(value)
ret1 = dict(zip(value,ret))

ret_A_add = ret1.copy()
for item in result['A+']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
ret_A_add[k]+=1

retAA_ = ret1.copy()
for item in result['']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
retAA_[k]+=1

retAA = ret1.copy()
for item in result['AA']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
retAA[k]+=1

retAA_add = ret1.copy()
for item in result['AA+']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
retAA_add[k]+=1

retAAA = ret1.copy()
for item in result['AAA']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
retAAA[k]+=1

bar = Bar('可转债价格分布')
bar.add('A+',value,list(ret_A_add.values()),is_stack=True,yaxis_max=11)
bar.add('',value,list(retAA_.values()),is_stack=True,yaxis_max=11)
bar.add('AA',value,list(retAA.values()),is_stack=True,yaxis_max=11)
bar.add('AA+',value,list(retAA_add.values()),is_stack=True,yaxis_max=11)
bar.add('AAA',value,list(retAAA.values()),is_stack=True,yaxis_max=11)
如果没有安装pyecharts，需要用pip安装即可。

原创文章
转载请注明出处：
http://30daydo.com/article/400

查看全部

这一节课带大家学习如何利用可视化，更好的呈现数据。
即使你有很多数据，可是，你无法直观地看到数据的总体趋势。使用可视化的绘图，可以帮助我们看到数据背后看不到的数据。比如我已经有每一个可转债的价格，评级。数据如下：

点击查看大图

如果我用下面的图形就可以看出规律：

点击查看大图

横坐标是价格，纵坐标是落在该价格的可转债数量，不同颜色代表不同评级的可转债。

可以看到大部分AA-评级（浅橙色）的可转债价格都在100元以下，而AA（浅蓝色）的可转债价格分布较为平均，从90到110都有。而AA+和AAA的一般都在100以上。

那么如何使用代码实现呢？

from  setting import get_mysql_conn,get_engine

import pandas as pd

import pymongo

from pyecharts import Geo,Style,Map

engine = get_engine('db_stock',local='local')

# 堆叠图

from pyecharts import Bar

df = pd.read_sql('tb_bond_jisilu',con=engine)



result ={}

for name,grades in df.groupby('评级'):

#     print(name,grades[['可转债名称','可转债价格']])

    for each in grades['可转债价格']:

        result.setdefault(name,)

        result[name].append(each)

        

        

# 确定价格的范围



value = [str(i) for i in range(85,140)]

ret = [0]*len(value)

ret1 = dict(zip(value,ret))



ret_A_add = ret1.copy()

for item in result['A+']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            ret_A_add[k]+=1

            

retAA_ = ret1.copy()

for item in result['']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA_[k]+=1



retAA = ret1.copy()

for item in result['AA']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA[k]+=1

            

retAA_add = ret1.copy()

for item in result['AA+']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA_add[k]+=1

            

retAAA = ret1.copy()

for item in result['AAA']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAAA[k]+=1



bar = Bar('可转债价格分布')

bar.add('A+',value,list(ret_A_add.values()),is_stack=True,yaxis_max=11)

bar.add('',value,list(retAA_.values()),is_stack=True,yaxis_max=11)

bar.add('AA',value,list(retAA.values()),is_stack=True,yaxis_max=11)

bar.add('AA+',value,list(retAA_add.values()),is_stack=True,yaxis_max=11)

bar.add('AAA',value,list(retAAA.values()),is_stack=True,yaxis_max=11)

如果没有安装pyecharts，需要用pip安装即可。

原创文章
转载请注明出处：
http://30daydo.com/article/400

python数据分析之 A股上市公司按地区分布与可视化地图显示

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 9181 次浏览 • 2018-12-19 14:07 • 来自相关话题

首先传统方法是使用数据库：SELECT area `地区`,count(*) as `数目` FROM `tb_basic_info` GROUP BY area order by 数目 desc;得到下面的结果：接着我们使用pandas进行数据可视化。
地区数目
浙江 431
江苏 401
北京 316
广东 303
上海 285
深圳 283
山东 196
福建 132
四川 120
湖南 104
安徽 103
湖北 101
河南 79
辽宁 72
河北 56
新疆 54
天津 50
陕西 49
重庆 48
吉林 41
江西 41
山西 38
黑龙江 37
广西 37
云南 33
甘肃 33
海南 31
贵州 29
内蒙 25
西藏 18
宁夏 13
青海 12
看看我们的641主席的功劳，江浙一带的上市公司数量已经超过广东了。

接下来我们使用pandas进行数据可视化：

首先读入数据：# A股上市公司分布：
df = pd.read_sql('tb_basic_info',con=engine)engine为from sqlalchemy import create_engine 中的连接引擎。

然后直接统计：result = df['area'].value_counts()得到的result就是统计结果：

看是不是比mysql语句简单多了？

得到一样的数据。

接下来使用图像来显示我们的数据：

什么？一条命令就可以啦~ 实在太强大了！
从这个柱状图上，可以更加直观地看到A股上市公司的分布情况，东部长三角和珠三角的公司数目最多。而西部只有东部的零头。

接着把数据转化为百分比数据：total = result.sum()
ration = result/total*100

可以看到江浙地区占了22%的数量，体量还是很大的。

接下来，为了数据更加直观，把数据在地图上显示出来：

点击查看大图

颜色越红，表明上市公司越多。现在数据够直观了吧。

实现代码：# 热力图
def create_heatmap(attr,value,name,maptype):
style = Style(title_color="#fff", title_pos="center",
width=1200, height=600, background_color="#696969")

# 可视化
geo = Geo(name,**style.init_style)
geo.add("", attr, value, visual_range=[min(value), max(value)], symbol_size=8,
visual_text_color="#000",
is_visualmap=True, type='effectScatter',effect_scale=7,is_random=True,is_roam=False,is_piecewise = True,visual_split_number= 10,
)

geo.render('{}.html'.format(name)) create_heatmap(attr,value,'公司分布','china')

更多的数据分析，请关注本网站。
不定期更新哦

原创文章
转载请注明出处：
http://30daydo.com/article/388
查看全部

首先传统方法是使用数据库：

SELECT area `地区`,count(*) as `数目` FROM `tb_basic_info` GROUP BY area order by 数目 desc;

得到下面的结果：接着我们使用pandas进行数据可视化。
地区数目
浙江 431
江苏 401
北京 316
广东 303
上海 285
深圳 283
山东 196
福建 132
四川 120
湖南 104
安徽 103
湖北 101
河南 79
辽宁 72
河北 56
新疆 54
天津 50
陕西 49
重庆 48
吉林 41
江西 41
山西 38
黑龙江 37
广西 37
云南 33
甘肃 33
海南 31
贵州 29
内蒙 25
西藏 18
宁夏 13
青海 12
看看我们的641主席的功劳，江浙一带的上市公司数量已经超过广东了。

接下来我们使用pandas进行数据可视化：

首先读入数据：

# A股上市公司分布：

df = pd.read_sql('tb_basic_info',con=engine)

engine为from sqlalchemy import create_engine 中的连接引擎。

然后直接统计：

result = df['area'].value_counts()

得到的result就是统计结果：

看是不是比mysql语句简单多了？

得到一样的数据。

接下来使用图像来显示我们的数据：

什么？一条命令就可以啦~ 实在太强大了！
从这个柱状图上，可以更加直观地看到A股上市公司的分布情况，东部长三角和珠三角的公司数目最多。而西部只有东部的零头。

接着把数据转化为百分比数据：

total = result.sum()

ration = result/total*100

可以看到江浙地区占了22%的数量，体量还是很大的。

接下来，为了数据更加直观，把数据在地图上显示出来：

点击查看大图

颜色越红，表明上市公司越多。现在数据够直观了吧。

实现代码：

# 热力图

def create_heatmap(attr,value,name,maptype):

    style = Style(title_color="#fff", title_pos="center",

              width=1200, height=600, background_color="#696969")



    # 可视化

    geo = Geo(name,**style.init_style)

    geo.add("", attr, value, visual_range=[min(value), max(value)], symbol_size=8,

            visual_text_color="#000",

            is_visualmap=True, type='effectScatter',effect_scale=7,is_random=True,is_roam=False,is_piecewise = True,visual_split_number= 10,

            )



    geo.render('{}.html'.format(name))

create_heatmap(attr,value,'公司分布','china')

更多的数据分析，请关注本网站。
不定期更新哦

原创文章
转载请注明出处：
http://30daydo.com/article/388

想用程序自动化交易；大佬们都用哪个lib 提交订单；【比如同花顺；平安证券等】多谢

股票 • 李魔佛回复了问题 • 1 人关注 • 2 个回复 • 5067 次浏览 • 2021-07-16 21:44 • 来自相关话题

目前支持量化接口的万一免五的券商有哪些？

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 3573 次浏览 • 2023-07-04 22:52 • 来自相关话题

支持量化交易的券商如下：

qmt的升级有点拉胯，居然不能一次到位？

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 1527 次浏览 • 2022-07-04 10:37 • 来自相关话题

终于更新了2次之后，登录上系统了。

获取可转债历史分时tick数据【python】

可转债 • 李魔佛发表了文章 • 0 个评论 • 3424 次浏览 • 2022-06-25 12:29 • 来自相关话题

Ptrade、QMT如何在虚拟机下运行？

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 4582 次浏览 • 2022-01-12 19:38 • 来自相关话题

https://www.aliyun.com/minisite/goods?userCode=nebb965s

无影云桌面 (Elastic Desktop Service），是一种易用、安全、高效的云上桌面服务。它支持快速便捷的桌面环境创建、部署、统一管控与运维。无需前期传统硬件投资，帮您快速构建安全、高性能、低成本的企业桌面办公体系。可广泛应用于具有高数据安全管控、高性能计算等要求的安全办公、金融、设计、影视、教育等领域。

其实就是一个windows的远程桌面，里面可以按照各种应用程序，比如同花顺，东方财富，QQ等等

连接方式，使用浏览器就可以连上远程桌面了：

我用的谷歌浏览器，现在无论走到那里，只要可以上网，就可以在浏览器里面连接到远程桌面，看到Ptrade里面的情况。

优矿回测可转债代码教程

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 5712 次浏览 • 2021-12-09 00:44 • 来自相关话题

优矿支持的数据

股票：沪深交易所股票的基本信息以及日/分钟级别的股票行情。
财务报表：沪深港上市公司披露的2007年会计准则变更以来的所有财务报表数据，包含三大报表和财报附注等细节。
公司行为：沪深上市公司业绩预告，业绩快报，IPO，配股，分红，拆股，股改等信息。
基金：场内外各类基金的基本信息，日/分钟级别的场内基金行情，日级别的场外基金净值，以及基金资产配置，收益情况，净值调整等信息。
期货：国内四大期货交易所期货合约的基本信息，日/分钟的期货行情，以及国债期货的转换因子等信息。
指数：国内外指数基本信息，日/分钟级别的指数行情，以及指数成分构成情况，指数成分股权重情况等信息。
港股：香港交易所股票基本信息以及日级别的股票行情。
大宗商品：国内各个品种（包括期货合约可交割品种）的大宗商品现货价格行情，以及产销量，库存等信息。
债券：债券/回购基本信息，日级别的债券/回购行情，以及发行上市，付息，利率，评级和评级变动，债券发行人评级及变动，担保人评级及变动等信息。
期权：上交所期权合约的基本信息，日/分钟级别的期权行情，以及每日盘前静态数据等信息。
宏观产业：中国及全球各国宏观指标，行业经济指标等数据。

特色数据

股票/指数等品种的量化因子库
雪球、股吧等社交媒体数据
主流媒体新闻文本和结构化数据
主流渠道公告文本和结构化数据
淘宝、天猫等电商数据

import datetime



start = '2018-01-01'                       # 回测起始时间

end = '2021-05-28'                         # 回测结束时间

benchmark = 'HS300'                        # 策略参考标准

freq = 'd'                                 # 策略类型，'d'表示日间策略使用日线回测，'m'表示日内策略使用分钟线回测            

refresh_rate = 5 # 调仓频率，表示执行handle_data的时间间隔，若freq = 'd' 时间间隔的单位为交易日，

hold_num = 10 # 持有转债的个数



    

def initialize(context):

    global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash

    MyPosition = {}  #持仓

    MyCash = 1000000  #现金

    Start_Cash= 1000000

    HighValue = MyCash  #最高市值

    Withdraw = 0  #最大回撤

    HoldRank = hold_num  #排名多少之后卖出

    HoldNum = hold_num  #持债支数

    

def bonds(beginDate=u"20170101",endDate=u"20201215",EB_ENABLE=False):

    code_set = set()

    df = DataAPI.MktConsBondPremiumGet(SecID=u"",

                                       tickerBond=u"",

                                       beginDate=beginDate,

                                       endDate=endDate,

                                       field=u"",

                                       pandas="1")



    cb_df = df.tickerBond.str.startswith(('12', '11'))

    df = df[cb_df]

    cb_df = df.tickerBond.str.startswith('117')

    df = df[~cb_df]

    if not EB_ENABLE:

        eb = df.secShortNameBond.str.match('\d\d.*?E[123B]')  # TODO 判断EB是否过滤

        df = df[~eb]



    ticker_list = 

    for _, row in df[['tickerBond', 'secShortNameBond', 'tickerEqu']].iterrows():

        if row['tickerBond'] not in code_set:

            ticker_list.append((row['tickerBond'], row['secShortNameBond'], row['tickerEqu']))

            code_set.add(row['tickerBond'])

    return list(code_set)





def handle_data(context):    

    global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash

    

    today_date = context.now.strftime('%Y%m%d')

    

    #每天重新计算双低排名

    ticker_list=bonds(today_date,today_date)

    data = DataAPI.MktConsBondPerfGet(beginDate=today_date,endDate=today_date,secID='',tickerBond=ticker_list,

                                      tickerEqu=u"",field=u"",pandas="1")

    data['secID']=data['tickerBond']

    data.set_index('secID',inplace=True)

    data['DoubleLow'] = data['closePriceBond'] + data['bondPremRatio']

    data = data.sort_values(by="DoubleLow" , ascending=True)

    PosValue = MyCash

    

    #抛出不在持有排名HoldRank的

    for stock in MyPosition.keys():

        try:

            CurPrice = data.loc[stock]['closePriceBond']

        except:

            last_date = (context.now + datetime.timedelta(days=-7)).strftime('%Y%m%d')

            CurPrice=get_last_price(stock,last_date,today_date)



        PosValue += MyPosition[stock] * CurPrice * 10 #计算当前市值

        

        if stock not in data.index[:HoldRank]:

            # 省略若干

                

            log.info('{} 卖出{},{},价格：{}'.format(today_date,stock,name,CurPrice))

  

            

    if PosValue > HighValue:HighValue = PosValue

    if (HighValue - PosValue) / HighValue > Withdraw:Withdraw = (HighValue - PosValue) / HighValue

    

    #买入排在HoldRank内的，总持有数量HoldNum

    min_hold = min(HoldRank,len(data.index))

    for i in range(min_hold):

        if len(MyPosition) >= HoldNum:break

        if data.index[i] not in MyPosition.keys():

            # 省略若干

            log.info('{} 买入{}, {}, 价格{}, 溢价率{}'.format(today_date,data.index[i],name,price,cb_ration))



    ratio = (PosValue-Start_Cash)/Start_Cash*100

    log.info(today_date + ': 最高市值 ' + str(HighValue) + ' , 当前市值 ' + str(PosValue) + '收益率 ： '

             +str(ratio)+'% , 最大回撤 ' + str(round(Withdraw*100,2))+'%') [/i][/i]

[i]欢迎讨论探索，星球里面有更多的完整策略与代码，回测数据，结论资源。

[/i]

开通Ptrade Python量化接口国金证券/国盛证券

股票 • 绫波丽发表了文章 • 0 个评论 • 20782 次浏览 • 2021-07-06 08:40 • 来自相关话题

接口文档也非常详细：

一些常见策略代码：

集合竞价追涨停策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')  



def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

    

def handle_data(context, data):

    pass

双均线策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    pass

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def handle_data(context, data):

    security = g.security



    #得到十日历史价格

    df = get_history(10, '1d', 'close', security, fq=None, include=False)

	

    # 得到五日均线价格

    ma5 = round(df['close'][-5:].mean(), 3)

    

    # 得到十日均线价格

    ma10 = round(df['close'][-10:].mean(), 3)



    # 取得昨天收盘价

    price = data[security]['close']



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(security, cash)

        # 记录这次买入

        log.info("Buying %s" % (security))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(security).amount > 0:

        # 全部卖出

        order_target(security, 0)

        # 记录这次卖出

        log.info("Selling %s" % (security))

tick级别均线策略

通俗点就是按照秒级别进行操作。

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每3秒运行一次主函数

    run_interval(context, func, seconds=3)

      

#盘前准备历史数据

def before_trading_start(context, data):

    history = get_history(10, '1d', 'close', g.security, fq='pre', include=False)

    g.close_array = history['close'].values

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def func(context):

    

    stock = g.security

    

    #获取最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    

    # 得到五日均线价格

	days = 5

    ma5 = get_MA_day(stock, days, g.close_array[-4:], price)   

    # 得到十日均线价格

	days = 10

    ma10 = get_MA_day(stock, days, g.close_array[-9:], price)



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(stock, cash)

        # 记录这次买入

        log.info("Buying %s" % (stock))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(stock).amount > 0:

        # 全部卖出

        order_target(stock, 0)

        # 记录这次卖出

        log.info("Selling %s" % (stock))    



#计算实时均线函数

def get_MA_day(stock,days,close_array,current_price):

    close_sum = close_array[-(days-1):].sum()

    MA = (current_price + close_sum)/days

    return MA



def handle_data(context, data):

    pass

macd策略

def f_expma(N,m,EXPMA1,price):

    a = m/(N+1)

    EXPMA2 = a * price + (1 - a)*EXPMA1

    return EXPMA2 #2为后一天值



#定义macd函数，输入平滑系数参数、前一日值，输出当日值

def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):

    EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)

    EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)

    DIF2 = EXPMA12_2 - EXPMA26_2

    a = m/(N3+1)

    DEA2 = a * DIF2 + (1 - a)*DEA1

    BAR2=2*(DIF2-DEA2)

    return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2



def initialize(context):

    global init_price

    init_price = None

    # 获取沪深300股票

    g.security = get_index_stocks('000300.SS')

    #g.security = ['600570.SS']

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    set_universe(g.security)



def handle_data(context, data):

    # 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取

    # 从股票上市至今的所有历史数据，即增加获取的天数

    close_price = get_history(2, '1d', field='close', security_list=g.security)

    #如果是停牌不进行计算

    for security in g.security:

        if data[security].is_open >0:

            global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2

            if init_price is None:

                init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值

                EXPMA12_1 = init_price

                EXPMA26_1 = init_price

                DIF1 = init_price

                DEA1 = init_price

            # m用于计算平滑系数a=m/(N+1)

            m = 2.0

            #设定指数平滑基期数

            N1 = 12

            N2 = 26

            N3 = 9

            EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])

            # 取得当前价格

            current_price = data[security].price

            # 取得当前的现金

            cash = context.portfolio.cash

            # DIF、DEA均为正，DIF向上突破DEA，买入信号参考

            if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:

                # 计算可以买多少只股票

                number_of_shares = int(cash/current_price)

                # 购买量大于0时，下单

                if number_of_shares > 0:

                    # 以市单价买入股票，日回测时即是开盘价

                    order(security, +number_of_shares)

                    # 记录这次买入

                    log.info("Buying %s" % (security))

            # DIF、DEA均为负，DIF向下突破DEA，卖出信号参考

            elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:

                # 卖出所有股票,使这只股票的最终持有量为0

                order_target(security, 0)

                # 记录这次卖出

                log.info("Selling %s" % (security))

            # 将今日的值赋给全局变量作为下一次前一日的值

            DEA1 = DEA2

            DIF1 = DIF2

            EXPMA12_1 = EXPMA12_2

            EXPMA26_1 = EXPMA26_2

开通券商账户后可以可以先试用，再考虑是否开通量化接口权限

量化交易接口python A股

股票 • 绫波丽发表了文章 • 0 个评论 • 7990 次浏览 • 2021-07-01 11:22 • 来自相关话题

回测策略

实际代码需要在回测策略里面写，写完后确定无误，就可以放在仿真环境下真实运行。

如果你运行得到的结果很满意，那么就可以直接部署到实盘服务器上。

实盘服务器是在券商那边，不需要个人购买服务器，也不需要本地开着这个Ptrade，就是说不需要在个人电脑上一直开着跑，你的最终代码和程序是在券商服务器上部署与运行，除非有报错异常停止，不然在你不暂停或者停止的前提下，可以一直运行下去。

接口文档也非常详细：

一些常见策略代码：

双均线策略

    def initialize(context):

 2    # 初始化此策略

 3    # 设置我们要操作的股票池, 这里我们只操作一支股票

 4    g.security = '600570.SS'

 5    set_universe(g.security)

 6    pass

 7

 8 #当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

 9 def handle_data(context, data):

10    security = g.security

11

12    #得到十日历史价格

13    df = get_history(10, '1d', 'close', security, fq=None, include=False)

14

15    # 得到五日均线价格

16    ma5 = round(df['close'][-5:].mean(), 3)

17

18    # 得到十日均线价格

19    ma10 = round(df['close'][-10:].mean(), 3)

20

21    # 取得昨天收盘价

22    price = data[security]['close']

23

24    # 得到当前资金余额

25    cash = context.portfolio.cash

26

27    # 如果当前有余额，并且五日均线大于十日均线

28    if ma5 > ma10:

29        # 用所有 cash 买入股票

30        order_value(security, cash)

31        # 记录这次买入

32        log.info("Buying %s" % (security))

33

34    # 如果五日均线小于十日均线，并且目前有头寸

35    elif ma5 < ma10 and get_position(security).amount > 0:

36        # 全部卖出

37        order_target(security, 0)

38        # 记录这次卖出

39        log.info("Selling %s" % (security))

macd策略
指数平滑均线函数，以price计算，可以选择收盘、开盘价等价格，N为时间周期，m用于计算平滑系数a=m/(N+1)，EXPMA1为前一日值

    def f_expma(N,m,EXPMA1,price):

 2    a = m/(N+1)

 3    EXPMA2 = a * price + (1 - a)*EXPMA1

 4    return EXPMA2 #2为后一天值

 5

 6 #定义macd函数，输入平滑系数参数、前一日值，输出当日值

 7  def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):

 8    EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)

 9    EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)

10    DIF2 = EXPMA12_2 - EXPMA26_2

11    a = m/(N3+1)

12    DEA2 = a * DIF2 + (1 - a)*DEA1

13    BAR2=2*(DIF2-DEA2)

14    return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2

15

16  def initialize(context):

17    global init_price

18    init_price = None

19    # 获取沪深300股票

20    g.security = get_index_stocks('000300.SS')

21    #g.security = ['600570.SS']

22    # 设置我们要操作的股票池, 这里我们只操作一支股票

23    set_universe(g.security)

24

25  def handle_data(context, data):

26    # 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取

27    # 从股票上市至今的所有历史数据，即增加获取的天数

28    close_price = get_history(2, '1d', field='close', security_list=g.security)

29    #如果是停牌不进行计算

30    for security in g.security:

31        if data[security].is_open >0:

32            global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2

33            if init_price is None:

34                init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值

35                EXPMA12_1 = init_price

36                EXPMA26_1 = init_price

37                DIF1 = init_price

38                DEA1 = init_price

39            # m用于计算平滑系数a=m/(N+1)

40            m = 2.0

41            #设定指数平滑基期数

42            N1 = 12

43            N2 = 26

44            N3 = 9

45            EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])

46            # 取得当前价格

47            current_price = data[security].price

48            # 取得当前的现金

49            cash = context.portfolio.cash

50            # DIF、DEA均为正，DIF向上突破DEA，买入信号参考

51            if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:

52                # 计算可以买多少只股票

53                number_of_shares = int(cash/current_price)

54                # 购买量大于0时，下单

55                if number_of_shares > 0:

56                    # 以市单价买入股票，日回测时即是开盘价

57                    order(security, +number_of_shares)

58                    # 记录这次买入

59                    log.info("Buying %s" % (security))

60            # DIF、DEA均为负，DIF向下突破DEA，卖出信号参考

61            elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:

62                # 卖出所有股票,使这只股票的最终持有量为0

63                order_target(security, 0)

64                # 记录这次卖出

65                log.info("Selling %s" % (security))

66            # 将今日的值赋给全局变量作为下一次前一日的值

67            DEA1 = DEA2

68            DIF1 = DIF2

69            EXPMA12_1 = EXPMA12_2

70            EXPMA26_1 = EXPMA26_2

Ptrade策略示例

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 4598 次浏览 • 2021-05-26 19:02 • 来自相关话题

策略示例

集合竞价追涨停策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')  



def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

    

def handle_data(context, data):

    pass

tick级别均线策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每3秒运行一次主函数

    run_interval(context, func, seconds=3)

      

#盘前准备历史数据

def before_trading_start(context, data):

    history = get_history(10, '1d', 'close', g.security, fq='pre', include=False)

    g.close_array = history['close'].values

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def func(context):

    

    stock = g.security

    

    #获取最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    

    # 得到五日均线价格

    days = 5

    ma5 = get_MA_day(stock, days, g.close_array[-4:], price)   

    # 得到十日均线价格

    days = 10

    ma10 = get_MA_day(stock, days, g.close_array[-9:], price)



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(stock, cash)

        # 记录这次买入

        log.info("Buying %s" % (stock))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(stock).amount > 0:

        # 全部卖出

        order_target(stock, 0)

        # 记录这次卖出

        log.info("Selling %s" % (stock))    



#计算实时均线函数

def get_MA_day(stock,days,close_array,current_price):

    close_sum = close_array[-(days-1):].sum()

    MA = (current_price + close_sum)/days

    return MA



def handle_data(context, data):

    pass

双均线策略

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    pass

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def handle_data(context, data):

    security = g.security



    #得到十日历史价格

    df = get_history(10, '1d', 'close', security, fq=None, include=False)

    

    # 得到五日均线价格

    ma5 = round(df['close'][-5:].mean(), 3)

    

    # 得到十日均线价格

    ma10 = round(df['close'][-10:].mean(), 3)



    # 取得昨天收盘价

    price = data[security]['close']



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(security, cash)

        # 记录这次买入

        log.info("Buying %s" % (security))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(security).amount > 0:

        # 全部卖出

        order_target(security, 0)

        # 记录这次卖出

        log.info("Selling %s" % (security))

macd策略

指数平滑均线函数，以price计算，可以选择收盘、开盘价等价格，N为时间周期，m用于计算平滑系数a=m/(N+1)，EXPMA1为前一日值

def f_expma(N,m,EXPMA1,price):

    a = m/(N+1)

    EXPMA2 = a * price + (1 - a)*EXPMA1

    return EXPMA2 #2为后一天值



#定义macd函数，输入平滑系数参数、前一日值，输出当日值

def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):

    EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)

    EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)

    DIF2 = EXPMA12_2 - EXPMA26_2

    a = m/(N3+1)

    DEA2 = a * DIF2 + (1 - a)*DEA1

    BAR2=2*(DIF2-DEA2)

    return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2



def initialize(context):

    global init_price

    init_price = None

    # 获取沪深300股票

    g.security = get_index_stocks('000300.SS')

    #g.security = ['600570.SS']

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    set_universe(g.security)



def handle_data(context, data):

    # 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取

    # 从股票上市至今的所有历史数据，即增加获取的天数

    close_price = get_history(2, '1d', field='close', security_list=g.security)

    #如果是停牌不进行计算

    for security in g.security:

        if data[security].is_open >0:

            global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2

            if init_price is None:

                init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值

                EXPMA12_1 = init_price

                EXPMA26_1 = init_price

                DIF1 = init_price

                DEA1 = init_price

            # m用于计算平滑系数a=m/(N+1)

            m = 2.0

            #设定指数平滑基期数

            N1 = 12

            N2 = 26

            N3 = 9

            EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])

            # 取得当前价格

            current_price = data[security].price

            # 取得当前的现金

            cash = context.portfolio.cash

            # DIF、DEA均为正，DIF向上突破DEA，买入信号参考

            if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:

                # 计算可以买多少只股票

                number_of_shares = int(cash/current_price)

                # 购买量大于0时，下单

                if number_of_shares > 0:

                    # 以市单价买入股票，日回测时即是开盘价

                    order(security, +number_of_shares)

                    # 记录这次买入

                    log.info("Buying %s" % (security))

            # DIF、DEA均为负，DIF向下突破DEA，卖出信号参考

            elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:

                # 卖出所有股票,使这只股票的最终持有量为0

                order_target(security, 0)

                # 记录这次卖出

                log.info("Selling %s" % (security))

            # 将今日的值赋给全局变量作为下一次前一日的值

            DEA1 = DEA2

            DIF1 = DIF2

            EXPMA12_1 = EXPMA12_2

            EXPMA26_1 = EXPMA26_2

python判断可转债是否强赎

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 2732 次浏览 • 2021-04-02 13:41 • 来自相关话题

占坑，后期把代码整理下放上来。

更新：

制作好了一个接口，用户可以直接调用。
数据来源与集思录。

获取 排除满足强赎天数剩余N天的可转债，排除强赎可转债。



比如：DAY=4 ，那么假设强赎满足天数为15天，那么返回市场上强赎强赎倒数天数大于4天的可转债，即返回小于或者等于11天以下的转债。把满足条件还差4天的转债排除掉了，当然，已经公告强赎的也会被排除。







import requests



URL = 'http://11.11.11.11/api/redeem/'

# DAY 强赎倒数剩余天数小于 DAY （4）天， 已经公告强赎的也是被排除的

DAY = 4



SIGN = '私信星主获取' # sign和以前一致



data = {'day': DAY,

        'sign': SIGN}

r = requests.post(URL, data=data)



print(r.json())

具体用户可以关注知识星球：

#获取当日的股票池

g.stock_list = get_Ashares(g.current_date)

可以自己使用。

而

get_history(70, '1d', ['close','volume'], g.stock_list, fq='dypre', include=False)

原创文章，转载请注明出处
http://30daydo.com/article/44151

（教你使用python进行量化分析股票，可转债数据）

nunpy中的std标准差是样本差吗

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 3728 次浏览 • 2019-07-01 10:08 • 来自相关话题

写个代码测试下：

# 测试一下那个方差

x=[1,2,3,4,5,6,7,8,9,10]

X = np.array(x)

X.mean()
5.5

X.std() # 标准差
2.8722813232690143

手工计算一下：

def my_fangca(X):

    l=len(X)

    mean=X.mean()

    sum_ = 0

    sum_std=0

    for i in X:

        sum_+=(i-mean)**2

    var_=sum_/l

    std_=(sum_/(l))**0.5

    return var_,std_

result = my_fangca(X)
得到的result

(8.25, 2.8722813232690143)

说明numpy的std是标准差，不是样本差

修改easytrader国金证券的默认启动路径

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 5021 次浏览 • 2019-06-17 10:23 • 来自相关话题

如果你的国金证券不是安装在默认路径的话，会无法启动。报错：

pywinauto.application.AppStartError: Could not create the process "C:\全能行证券交易终端\xiadan.exe"
Error returned by CreateProcess: (2, 'CreateProcess', '系统找不到指定的文件。')

class GJ(CommonConfig):

    DEFAULT_EXE_PATH = "C:\\Tool\\xiadan.exe"

只要修改上面的路径就可以了。注意用双斜杠。

【可转债数据】发行速度趋势

股票 • 李魔佛发表了文章 • 2 个评论 • 3388 次浏览 • 2019-04-08 16:24 • 来自相关话题

随着年后股市一波流，每天涨涨涨，发行可转债的数量也越来越多。
用pyecharts做了一张趋势图，可以显然易见地窥探目前可转债的发行速度。

实现代码也很简单：
（核心部分）

line=Line()

line.add('可转债个数趋势',b,v,mark_line=["average"], mark_point=["max", "min"])

from  setting import get_mysql_conn,get_engine

import pandas as pd

import pymongo

from pyecharts import Geo,Style,Map

engine = get_engine('db_stock',local='local')

# 堆叠图

from pyecharts import Bar

df = pd.read_sql('tb_bond_jisilu',con=engine)



result ={}

for name,grades in df.groupby('评级'):

#     print(name,grades[['可转债名称','可转债价格']])

    for each in grades['可转债价格']:

        result.setdefault(name,)

        result[name].append(each)

        

        

# 确定价格的范围



value = [str(i) for i in range(85,140)]

ret = [0]*len(value)

ret1 = dict(zip(value,ret))



ret_A_add = ret1.copy()

for item in result['A+']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            ret_A_add[k]+=1

            

retAA_ = ret1.copy()

for item in result['']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA_[k]+=1



retAA = ret1.copy()

for item in result['AA']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA[k]+=1

            

retAA_add = ret1.copy()

for item in result['AA+']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA_add[k]+=1

            

retAAA = ret1.copy()

for item in result['AAA']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAAA[k]+=1



bar = Bar('可转债价格分布')

bar.add('A+',value,list(ret_A_add.values()),is_stack=True,yaxis_max=11)

bar.add('',value,list(retAA_.values()),is_stack=True,yaxis_max=11)

bar.add('AA',value,list(retAA.values()),is_stack=True,yaxis_max=11)

bar.add('AA+',value,list(retAA_add.values()),is_stack=True,yaxis_max=11)

bar.add('AAA',value,list(retAAA.values()),is_stack=True,yaxis_max=11)

如果没有安装pyecharts，需要用pip安装即可。

原创文章
转载请注明出处：
http://30daydo.com/article/400

python数据分析之 A股上市公司按地区分布与可视化地图显示

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 9181 次浏览 • 2018-12-19 14:07 • 来自相关话题

首先传统方法是使用数据库：

SELECT area `地区`,count(*) as `数目` FROM `tb_basic_info` GROUP BY area order by 数目 desc;

# A股上市公司分布：

df = pd.read_sql('tb_basic_info',con=engine)

engine为from sqlalchemy import create_engine 中的连接引擎。

然后直接统计：

result = df['area'].value_counts()

得到的result就是统计结果：

看是不是比mysql语句简单多了？

得到一样的数据。

接下来使用图像来显示我们的数据：

total = result.sum()

ration = result/total*100

可以看到江浙地区占了22%的数量，体量还是很大的。

接下来，为了数据更加直观，把数据在地图上显示出来：

点击查看大图

颜色越红，表明上市公司越多。现在数据够直观了吧。

实现代码：

# 热力图

def create_heatmap(attr,value,name,maptype):

    style = Style(title_color="#fff", title_pos="center",

              width=1200, height=600, background_color="#696969")



    # 可视化

    geo = Geo(name,**style.init_style)

    geo.add("", attr, value, visual_range=[min(value), max(value)], symbol_size=8,

            visual_text_color="#000",

            is_visualmap=True, type='effectScatter',effect_scale=7,is_random=True,is_roam=False,is_piecewise = True,visual_split_number= 10,

            )



    geo.render('{}.html'.format(name))

create_heatmap(attr,value,'公司分布','china')

更多的数据分析，请关注本网站。
不定期更新哦

原创文章
转载请注明出处：
http://30daydo.com/article/388

更多...

话题描述

最佳回复者

: 李魔佛
获得 0 次赞同, 0 次感谢

: 绫波丽
获得 0 次赞同, 0 次感谢

量化交易

话题描述

相关话题

最佳回复者

5 人关注该话题