量化接口
小市值轮动-量化交易-程序化交易-Ptrade实盘
Ptrade • 李魔佛 发表了文章 • 0 个评论 • 2228 次浏览 • 2023-10-07 14:14
运行了一段时间的实盘策略。中途不断加条件，避免买入暴雷的品种；遇到一字板涨停的不要急于轮动卖出。等破板再卖出。
当前策略持有30只。
点击查看大图
点击查看大图
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
查看全部
当前策略持有30只。
点击查看大图
点击查看大图
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
查看全部
运行了一段时间的实盘策略。中途不断加条件，避免买入暴雷的品种；遇到一字板涨停的不要急于轮动卖出。等破板再卖出。
当前策略持有30只。
点击查看大图
点击查看大图
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
当前策略持有30只。
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
ptrade量化策略：低位首板启动板-首板+低吸+单阳不破
Ptrade • 李魔佛 发表了文章 • 0 个评论 • 1716 次浏览 • 2023-09-05 22:44
低位的首板通常是启动板，首板+低吸+单阳不破，胜率还过得去。毛估估大于55%
Ptrade实现实盘自动交易代码。
（图片截图非本策略，随意贴的）
里面细节比较多。
得慢慢调。
Ptrade实现实盘自动交易代码。
（图片截图非本策略，随意贴的）
里面细节比较多。
得慢慢调。
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
Ptrade • 李魔佛 发表了文章 • 0 个评论 • 2058 次浏览 • 2023-09-01 22:53
国盛证券Ptrade有实盘正式版 和 测试版， 测试版提供的是模拟账户，里面的资金是模拟的，默认有500万，随意你操作，亏完拉倒重新设置就好了。
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
仿真客户端
国盛Ptrade测试版 模拟账户下载：
https://download.gszq.com/ptrade/PTrade1.0-Client-V201906-00-000.zip
仿真账户： ***** / ****** 量化回测：支持1分钟、日线回测。 量化交易：支持LEVEL1 tick股票交易。 量化研究：提供云Ipython Notebook研究环境、行情数据2005年至今、可使用全市场金融数据。
虽然ptrade有测试版本，但是个人还是非常不推荐使用测试版本。 以前在上面写过回测或者模拟盘，发现问题非常多，一个是数据缺了，数据错乱。以前被它坑过，后面基本都就不敢用了。 群里的兄弟大部分也被坑过，进群公告就是告诫他们，远离测试版。。。哈
实盘版本的需要开通才能申请，不同券商的门槛不一样。需要的朋友可以扫码咨询：
查看全部
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
仿真客户端
国盛Ptrade测试版 模拟账户下载：
https://download.gszq.com/ptrade/PTrade1.0-Client-V201906-00-000.zip
仿真账户： ***** / ****** 量化回测：支持1分钟、日线回测。 量化交易：支持LEVEL1 tick股票交易。 量化研究：提供云Ipython Notebook研究环境、行情数据2005年至今、可使用全市场金融数据。
虽然ptrade有测试版本，但是个人还是非常不推荐使用测试版本。 以前在上面写过回测或者模拟盘，发现问题非常多，一个是数据缺了，数据错乱。以前被它坑过，后面基本都就不敢用了。 群里的兄弟大部分也被坑过，进群公告就是告诫他们，远离测试版。。。哈
实盘版本的需要开通才能申请，不同券商的门槛不一样。需要的朋友可以扫码咨询：
查看全部
国盛证券Ptrade有实盘正式版 和 测试版， 测试版提供的是模拟账户，里面的资金是模拟的，默认有500万，随意你操作，亏完拉倒重新设置就好了。
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
仿真客户端
国盛Ptrade测试版 模拟账户下载：
https://download.gszq.com/ptrade/PTrade1.0-Client-V201906-00-000.zip
虽然ptrade有测试版本，但是个人还是非常不推荐使用测试版本。 以前在上面写过回测或者模拟盘，发现问题非常多，一个是数据缺了，数据错乱。以前被它坑过，后面基本都就不敢用了。 群里的兄弟大部分也被坑过，进群公告就是告诫他们，远离测试版。。。哈
实盘版本的需要开通才能申请，不同券商的门槛不一样。需要的朋友可以扫码咨询：
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
仿真客户端
国盛Ptrade测试版 模拟账户下载：
https://download.gszq.com/ptrade/PTrade1.0-Client-V201906-00-000.zip
仿真账户： ***** / ****** 量化回测：支持1分钟、日线回测。 量化交易：支持LEVEL1 tick股票交易。 量化研究：提供云Ipython Notebook研究环境、行情数据2005年至今、可使用全市场金融数据。
虽然ptrade有测试版本，但是个人还是非常不推荐使用测试版本。 以前在上面写过回测或者模拟盘，发现问题非常多，一个是数据缺了，数据错乱。以前被它坑过，后面基本都就不敢用了。 群里的兄弟大部分也被坑过，进群公告就是告诫他们，远离测试版。。。哈
实盘版本的需要开通才能申请，不同券商的门槛不一样。需要的朋友可以扫码咨询：
第一创业证券开户，支持量化聚宽，QMT
券商万一免五 • 绫波丽 发表了文章 • 0 个评论 • 3156 次浏览 • 2022-04-10 19:44
第一创业证券股份有限公司（以下简称“公司”、“第一创业”）前身是1993年4月成立的佛山证券公司。公司注册资本42.024亿元，总部设在深圳，员工超过3000人。2016年5月11日，公司首次公开发行股票并在深圳证券交易所上市交易
第一创业证券开户，费率如下
股票:万2.5
场内基金申购1折
可转债:沪市：万0.1 深市：万0.5
支持量化聚宽，QMT
需要开户的老铁，请扫码联系，备注：第一创业开户 查看全部
第一创业证券开户，费率如下
股票:万2.5
场内基金申购1折
可转债:沪市：万0.1 深市：万0.5
支持量化聚宽，QMT
需要开户的老铁，请扫码联系，备注：第一创业开户 查看全部
第一创业证券股份有限公司（以下简称“公司”、“第一创业”）前身是1993年4月成立的佛山证券公司。公司注册资本42.024亿元，总部设在深圳，员工超过3000人。2016年5月11日，公司首次公开发行股票并在深圳证券交易所上市交易
第一创业证券开户，费率如下
股票:万2.5
场内基金申购1折
可转债:沪市：万0.1 深市：万0.5
支持量化聚宽，QMT
需要开户的老铁，请扫码联系，备注：第一创业开户
东方证券万一免五开户
券商万一免五 • 绫波丽 发表了文章 • 0 个评论 • 2347 次浏览 • 2022-03-28 22:04
东方证券万一免五开户，费率如下：
1. A股佣金：万1免五
2. 场内基金：（封基/LOF/ETF）万0.5
3. 可转债＋债券：万分之0.5（沪）万分之0.5（深圳）
4. 融资融券利率6.5%，按使用天数收取利息
5.专属新客理财入金1万起，时间30天或60天的优秀理财产品。（固收类产品）
6. 支持同花顺，通达信登录
7. 支持量化金字塔
需要开户的老铁们， 请扫码联系，备注：东方证券开户
查看全部
1. A股佣金：万1免五
2. 场内基金：（封基/LOF/ETF）万0.5
3. 可转债＋债券：万分之0.5（沪）万分之0.5（深圳）
4. 融资融券利率6.5%，按使用天数收取利息
5.专属新客理财入金1万起，时间30天或60天的优秀理财产品。（固收类产品）
6. 支持同花顺，通达信登录
7. 支持量化金字塔
需要开户的老铁们， 请扫码联系，备注：东方证券开户
查看全部
东方证券万一免五开户，费率如下：
1. A股佣金：万1免五
2. 场内基金：（封基/LOF/ETF）万0.5
3. 可转债＋债券：万分之0.5（沪）万分之0.5（深圳）
4. 融资融券利率6.5%，按使用天数收取利息
5.专属新客理财入金1万起，时间30天或60天的优秀理财产品。（固收类产品）
6. 支持同花顺，通达信登录
7. 支持量化金字塔
需要开户的老铁们， 请扫码联系，备注：东方证券开户
1. A股佣金：万1免五
2. 场内基金：（封基/LOF/ETF）万0.5
3. 可转债＋债券：万分之0.5（沪）万分之0.5（深圳）
4. 融资融券利率6.5%，按使用天数收取利息
5.专属新客理财入金1万起，时间30天或60天的优秀理财产品。（固收类产品）
6. 支持同花顺，通达信登录
7. 支持量化金字塔
需要开户的老铁们， 请扫码联系，备注：东方证券开户
开通Ptrade Python量化接口 国金证券/国盛证券
股票 • 绫波丽 发表了文章 • 0 个评论 • 20407 次浏览 • 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千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限 查看全部
而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用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千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限 查看全部
目前不少在A股做量化的大部分使用tushare，优矿，米筐，聚宽等等，无论教程，还是实际操作，基本没见有教怎么用程序下单，实盘交易的。
而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用tushare或者新浪接口数据，扫描一次全市场的行情用时很久且不稳定，等扫描结束，再下单，此时价格可能已经是几分钟前的了，且此类接口调用次数多是会被封IP的。
笔者使用的是券商提供的量化软件：Ptrade。是恒生电子研发的提供给机构使用的程序化交易软件。提供策略回测，下单API接口，实时行情获取，并且使用的开发语言python，易于上手。
策略回测与实盘交易
研究页面
研究页面，熟悉python jupyter notebook的朋友对这个界面肯定很熟悉。
研究的页面实际就运行你逐行输出调试程序，了解每个函数的具体使用，或者你策略的中途结果调试。
回测策略
实际代码需要在回测策略里面写，写完后确定无误，就可以放在仿真环境下真实运行。如果你运行得到的结果很满意，那么就可以直接部署到实盘服务器上。实盘服务器是在券商那边，不需要个人购买服务器，也不需要本地开着这个Ptrade，就是说不需要在个人电脑上一直开着跑，你的最终代码和程序是在券商服务器上部署与运行，除非有报错异常停止，不然在你不暂停或者停止的前提下，可以一直运行下去。
条件满足后下单
可视化量化
同时也提供一些常见的现成的量化策略，选中后只要鼠标点点点也能够自动化跑这些策略了，当然里面很多参数都可以用鼠标点点点修改。
接口文档也非常详细：
一些常见策略代码：
集合竞价追涨停策略
双均线策略
tick级别均线策略
通俗点就是按照秒级别进行操作。
macd策略
软件与交易接口开通条件：
开通该券商后，存入资金指定资金即可开通。开通后股票交易费率万一
本身券商的交易费率为股票万一，可转债沪百万分之五，深十万分之五，基金万0.5，非常厚道。
不太了解量化行业的可以了解下，不少面向机构的量化交易软件的佣金是万2.5的，且开户门槛高，基本是500W以上，比如华泰的matic量化的门槛是1千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限
而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用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千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限
小市值轮动-量化交易-程序化交易-Ptrade实盘
Ptrade • 李魔佛 发表了文章 • 0 个评论 • 2228 次浏览 • 2023-10-07 14:14
运行了一段时间的实盘策略。中途不断加条件，避免买入暴雷的品种；遇到一字板涨停的不要急于轮动卖出。等破板再卖出。
当前策略持有30只。
点击查看大图
点击查看大图
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
查看全部
当前策略持有30只。
点击查看大图
点击查看大图
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
查看全部
运行了一段时间的实盘策略。中途不断加条件，避免买入暴雷的品种；遇到一字板涨停的不要急于轮动卖出。等破板再卖出。
当前策略持有30只。
点击查看大图
点击查看大图
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
当前策略持有30只。
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
开通Ptrade Python量化接口 国金证券/国盛证券
股票 • 绫波丽 发表了文章 • 0 个评论 • 20407 次浏览 • 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千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限 查看全部
而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用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千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限 查看全部
目前不少在A股做量化的大部分使用tushare，优矿，米筐，聚宽等等，无论教程，还是实际操作，基本没见有教怎么用程序下单，实盘交易的。
而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用tushare或者新浪接口数据，扫描一次全市场的行情用时很久且不稳定，等扫描结束，再下单，此时价格可能已经是几分钟前的了，且此类接口调用次数多是会被封IP的。
笔者使用的是券商提供的量化软件：Ptrade。是恒生电子研发的提供给机构使用的程序化交易软件。提供策略回测，下单API接口，实时行情获取，并且使用的开发语言python，易于上手。
策略回测与实盘交易
研究页面
研究页面，熟悉python jupyter notebook的朋友对这个界面肯定很熟悉。
研究的页面实际就运行你逐行输出调试程序，了解每个函数的具体使用，或者你策略的中途结果调试。
回测策略
实际代码需要在回测策略里面写，写完后确定无误，就可以放在仿真环境下真实运行。如果你运行得到的结果很满意，那么就可以直接部署到实盘服务器上。实盘服务器是在券商那边，不需要个人购买服务器，也不需要本地开着这个Ptrade，就是说不需要在个人电脑上一直开着跑，你的最终代码和程序是在券商服务器上部署与运行，除非有报错异常停止，不然在你不暂停或者停止的前提下，可以一直运行下去。
条件满足后下单
可视化量化
同时也提供一些常见的现成的量化策略，选中后只要鼠标点点点也能够自动化跑这些策略了，当然里面很多参数都可以用鼠标点点点修改。
接口文档也非常详细：
一些常见策略代码：
集合竞价追涨停策略
双均线策略
tick级别均线策略
通俗点就是按照秒级别进行操作。
macd策略
软件与交易接口开通条件：
开通该券商后，存入资金指定资金即可开通。开通后股票交易费率万一
本身券商的交易费率为股票万一，可转债沪百万分之五，深十万分之五，基金万0.5，非常厚道。
不太了解量化行业的可以了解下，不少面向机构的量化交易软件的佣金是万2.5的，且开户门槛高，基本是500W以上，比如华泰的matic量化的门槛是1千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限
而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用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千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限
小市值轮动-量化交易-程序化交易-Ptrade实盘
Ptrade • 李魔佛 发表了文章 • 0 个评论 • 2228 次浏览 • 2023-10-07 14:14
运行了一段时间的实盘策略。中途不断加条件，避免买入暴雷的品种；遇到一字板涨停的不要急于轮动卖出。等破板再卖出。
当前策略持有30只。
点击查看大图
点击查看大图
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
查看全部
当前策略持有30只。
点击查看大图
点击查看大图
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
查看全部
运行了一段时间的实盘策略。中途不断加条件，避免买入暴雷的品种；遇到一字板涨停的不要急于轮动卖出。等破板再卖出。
当前策略持有30只。
点击查看大图
点击查看大图
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
当前策略持有30只。
基于股票的策略不敢多买，属于试验阶段，后期仍然会不断根据市场调仓； 主仓依然在可转债。
公众号：可转债量化分析
如果需要策略代写，（ptrade、qmt，其他量化平台）
可以公众号后台回复：
策略代写
ptrade量化策略：低位首板启动板-首板+低吸+单阳不破
Ptrade • 李魔佛 发表了文章 • 0 个评论 • 1716 次浏览 • 2023-09-05 22:44
低位的首板通常是启动板，首板+低吸+单阳不破，胜率还过得去。毛估估大于55%
Ptrade实现实盘自动交易代码。
（图片截图非本策略，随意贴的）
里面细节比较多。
得慢慢调。
Ptrade实现实盘自动交易代码。
（图片截图非本策略，随意贴的）
里面细节比较多。
得慢慢调。
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
Ptrade • 李魔佛 发表了文章 • 0 个评论 • 2058 次浏览 • 2023-09-01 22:53
国盛证券Ptrade有实盘正式版 和 测试版， 测试版提供的是模拟账户，里面的资金是模拟的，默认有500万，随意你操作，亏完拉倒重新设置就好了。
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
仿真客户端
国盛Ptrade测试版 模拟账户下载：
https://download.gszq.com/ptrade/PTrade1.0-Client-V201906-00-000.zip
仿真账户： ***** / ****** 量化回测：支持1分钟、日线回测。 量化交易：支持LEVEL1 tick股票交易。 量化研究：提供云Ipython Notebook研究环境、行情数据2005年至今、可使用全市场金融数据。
虽然ptrade有测试版本，但是个人还是非常不推荐使用测试版本。 以前在上面写过回测或者模拟盘，发现问题非常多，一个是数据缺了，数据错乱。以前被它坑过，后面基本都就不敢用了。 群里的兄弟大部分也被坑过，进群公告就是告诫他们，远离测试版。。。哈
实盘版本的需要开通才能申请，不同券商的门槛不一样。需要的朋友可以扫码咨询：
查看全部
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
仿真客户端
国盛Ptrade测试版 模拟账户下载：
https://download.gszq.com/ptrade/PTrade1.0-Client-V201906-00-000.zip
仿真账户： ***** / ****** 量化回测：支持1分钟、日线回测。 量化交易：支持LEVEL1 tick股票交易。 量化研究：提供云Ipython Notebook研究环境、行情数据2005年至今、可使用全市场金融数据。
虽然ptrade有测试版本，但是个人还是非常不推荐使用测试版本。 以前在上面写过回测或者模拟盘，发现问题非常多，一个是数据缺了，数据错乱。以前被它坑过，后面基本都就不敢用了。 群里的兄弟大部分也被坑过，进群公告就是告诫他们，远离测试版。。。哈
实盘版本的需要开通才能申请，不同券商的门槛不一样。需要的朋友可以扫码咨询：
查看全部
国盛证券Ptrade有实盘正式版 和 测试版， 测试版提供的是模拟账户，里面的资金是模拟的，默认有500万，随意你操作，亏完拉倒重新设置就好了。
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
仿真客户端
国盛Ptrade测试版 模拟账户下载：
https://download.gszq.com/ptrade/PTrade1.0-Client-V201906-00-000.zip
虽然ptrade有测试版本，但是个人还是非常不推荐使用测试版本。 以前在上面写过回测或者模拟盘，发现问题非常多，一个是数据缺了，数据错乱。以前被它坑过，后面基本都就不敢用了。 群里的兄弟大部分也被坑过，进群公告就是告诫他们，远离测试版。。。哈
实盘版本的需要开通才能申请，不同券商的门槛不一样。需要的朋友可以扫码咨询：
国盛证券Ptrade测试版下载 Ptrade模拟客户端 模拟账号
仿真客户端
国盛Ptrade测试版 模拟账户下载：
https://download.gszq.com/ptrade/PTrade1.0-Client-V201906-00-000.zip
仿真账户： ***** / ****** 量化回测：支持1分钟、日线回测。 量化交易：支持LEVEL1 tick股票交易。 量化研究：提供云Ipython Notebook研究环境、行情数据2005年至今、可使用全市场金融数据。
虽然ptrade有测试版本，但是个人还是非常不推荐使用测试版本。 以前在上面写过回测或者模拟盘，发现问题非常多，一个是数据缺了，数据错乱。以前被它坑过，后面基本都就不敢用了。 群里的兄弟大部分也被坑过，进群公告就是告诫他们，远离测试版。。。哈
实盘版本的需要开通才能申请，不同券商的门槛不一样。需要的朋友可以扫码咨询：
第一创业证券开户，支持量化聚宽，QMT
券商万一免五 • 绫波丽 发表了文章 • 0 个评论 • 3156 次浏览 • 2022-04-10 19:44
第一创业证券股份有限公司（以下简称“公司”、“第一创业”）前身是1993年4月成立的佛山证券公司。公司注册资本42.024亿元，总部设在深圳，员工超过3000人。2016年5月11日，公司首次公开发行股票并在深圳证券交易所上市交易
第一创业证券开户，费率如下
股票:万2.5
场内基金申购1折
可转债:沪市：万0.1 深市：万0.5
支持量化聚宽，QMT
需要开户的老铁，请扫码联系，备注：第一创业开户 查看全部
第一创业证券开户，费率如下
股票:万2.5
场内基金申购1折
可转债:沪市：万0.1 深市：万0.5
支持量化聚宽，QMT
需要开户的老铁，请扫码联系，备注：第一创业开户 查看全部
第一创业证券股份有限公司（以下简称“公司”、“第一创业”）前身是1993年4月成立的佛山证券公司。公司注册资本42.024亿元，总部设在深圳，员工超过3000人。2016年5月11日，公司首次公开发行股票并在深圳证券交易所上市交易
第一创业证券开户，费率如下
股票:万2.5
场内基金申购1折
可转债:沪市：万0.1 深市：万0.5
支持量化聚宽，QMT
需要开户的老铁，请扫码联系，备注：第一创业开户
东方证券万一免五开户
券商万一免五 • 绫波丽 发表了文章 • 0 个评论 • 2347 次浏览 • 2022-03-28 22:04
东方证券万一免五开户，费率如下：
1. A股佣金：万1免五
2. 场内基金：（封基/LOF/ETF）万0.5
3. 可转债＋债券：万分之0.5（沪）万分之0.5（深圳）
4. 融资融券利率6.5%，按使用天数收取利息
5.专属新客理财入金1万起，时间30天或60天的优秀理财产品。（固收类产品）
6. 支持同花顺，通达信登录
7. 支持量化金字塔
需要开户的老铁们， 请扫码联系，备注：东方证券开户
查看全部
1. A股佣金：万1免五
2. 场内基金：（封基/LOF/ETF）万0.5
3. 可转债＋债券：万分之0.5（沪）万分之0.5（深圳）
4. 融资融券利率6.5%，按使用天数收取利息
5.专属新客理财入金1万起，时间30天或60天的优秀理财产品。（固收类产品）
6. 支持同花顺，通达信登录
7. 支持量化金字塔
需要开户的老铁们， 请扫码联系，备注：东方证券开户
查看全部
东方证券万一免五开户，费率如下：
1. A股佣金：万1免五
2. 场内基金：（封基/LOF/ETF）万0.5
3. 可转债＋债券：万分之0.5（沪）万分之0.5（深圳）
4. 融资融券利率6.5%，按使用天数收取利息
5.专属新客理财入金1万起，时间30天或60天的优秀理财产品。（固收类产品）
6. 支持同花顺，通达信登录
7. 支持量化金字塔
需要开户的老铁们， 请扫码联系，备注：东方证券开户
1. A股佣金：万1免五
2. 场内基金：（封基/LOF/ETF）万0.5
3. 可转债＋债券：万分之0.5（沪）万分之0.5（深圳）
4. 融资融券利率6.5%，按使用天数收取利息
5.专属新客理财入金1万起，时间30天或60天的优秀理财产品。（固收类产品）
6. 支持同花顺，通达信登录
7. 支持量化金字塔
需要开户的老铁们， 请扫码联系，备注：东方证券开户
开通Ptrade Python量化接口 国金证券/国盛证券
股票 • 绫波丽 发表了文章 • 0 个评论 • 20407 次浏览 • 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千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限 查看全部
而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用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千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限 查看全部
目前不少在A股做量化的大部分使用tushare，优矿，米筐，聚宽等等，无论教程，还是实际操作，基本没见有教怎么用程序下单，实盘交易的。
而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用tushare或者新浪接口数据，扫描一次全市场的行情用时很久且不稳定，等扫描结束，再下单，此时价格可能已经是几分钟前的了，且此类接口调用次数多是会被封IP的。
笔者使用的是券商提供的量化软件：Ptrade。是恒生电子研发的提供给机构使用的程序化交易软件。提供策略回测，下单API接口，实时行情获取，并且使用的开发语言python，易于上手。
策略回测与实盘交易
研究页面
研究页面，熟悉python jupyter notebook的朋友对这个界面肯定很熟悉。
研究的页面实际就运行你逐行输出调试程序，了解每个函数的具体使用，或者你策略的中途结果调试。
回测策略
实际代码需要在回测策略里面写，写完后确定无误，就可以放在仿真环境下真实运行。如果你运行得到的结果很满意，那么就可以直接部署到实盘服务器上。实盘服务器是在券商那边，不需要个人购买服务器，也不需要本地开着这个Ptrade，就是说不需要在个人电脑上一直开着跑，你的最终代码和程序是在券商服务器上部署与运行，除非有报错异常停止，不然在你不暂停或者停止的前提下，可以一直运行下去。
条件满足后下单
可视化量化
同时也提供一些常见的现成的量化策略，选中后只要鼠标点点点也能够自动化跑这些策略了，当然里面很多参数都可以用鼠标点点点修改。
接口文档也非常详细：
一些常见策略代码：
集合竞价追涨停策略
双均线策略
tick级别均线策略
通俗点就是按照秒级别进行操作。
macd策略
软件与交易接口开通条件：
开通该券商后，存入资金指定资金即可开通。开通后股票交易费率万一
本身券商的交易费率为股票万一，可转债沪百万分之五，深十万分之五，基金万0.5，非常厚道。
不太了解量化行业的可以了解下，不少面向机构的量化交易软件的佣金是万2.5的，且开户门槛高，基本是500W以上，比如华泰的matic量化的门槛是1千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限
而退而求其次使用按键精灵，模拟点击交易软件进行点击下单，非常不稳定，无法判断下单后是否成交，也无法实时获取行情数据。如果使用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千万元起步。
所以笔者还是很推荐目前该券商的量化交易接口。
需要开通咨询了解的朋友可以扫码联系：
开通券商账户后可以 可以先试用，再考虑是否开通量化接口权限
