量化交易策略——布林线指标（二）
量化交易策略——布林线指标（二）
本策略不太适用在大牛市或者大熊市，用于股市平稳波动时期是不错的。
策略思路：
股票价格在一段时间内，可以认为是在一定水平上下波动。比如，可以简单认为股价在过去100天的平均值基础上，上下波动几个标准差。
策略实现：
1.股价高于这个波动区间，即突破上顶，说明股价虚高，故卖出；
2.股价低于这个波动区间，即穿破下底，说明股价虚低，故买入。
g.security =
get_index_stocks('000300.XSHG')&
set_universe(g.security)
set_benchmark('000300.XSHG')
set_commission(PerTrade(buy_cost=0.0003, sell_cost=0.0013,
min_cost=5))
def handle_data(context, data):
& & for stock in
list(context.portfolio.positions.keys()):
& his = history(3, '1d', 'close', [stock])
((1-(his[stock][-1]/his[stock][0]))&=0.05):
order_target(stock, 0)
& & # 调仓日交易
& & for stock in
g.security:
& if not data[stock].isnan():
布林上下界
& & & mavg_price
= data[stock].mavg(100)
& & & std_dev
=data[stock].stddev(100, field='price')
& & & upper_band
= mavg_price + 2 * std_dev
& & & lower_band
= mavg_price - 2 * std_dev
& & & num =
len(context.portfolio.positions.keys())
& & & cash =
context.portfolio.cash
& & & position =
context.portfolio.positions[stock].amount
num&=10 and cash & 0:
num_of_shares=cash/data[stock].price
& & & elif
num&10 and cash & 0:
& & cash2 =
context.portfolio.cash/15
num_of_shares=cash2/data[stock].price
& & & # 交易
data[stock].price & (0.95 * lower_band) and cash & 0 and
position & 100:
& & order(stock,
+num_of_shares)
& & & elif
data[stock].price & (1.05 * upper_band) and position &
& & order_target(stock, 0)
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。如何看待京东量化交易平台？ - 知乎244被浏览11194分享邀请回答92 条评论分享收藏感谢收起5添加评论分享收藏感谢收起查看更多回答Ricequant 量化社区的初衷让各位爱好量化的人士可以碰撞思维，在分享和争辩中学习到有用且实战的量化知识。
有赖于各位在社区中贡献满满的干货以及有质量的讨论，从编程入门教学到技术指标再到多因子选股、财务数据分析等，囊括了很多方面的知识。
我在此组织 整理了下社区所发的内容、并分类出来，方便大家更容易找到相应的知识点。此贴会不断地更新
下面开始放毒了：
Python入门
Ricequant 平台入门教学
技术分析指标及TALIB的使用
【价值投资】【财务分析】【基本面】
轮动策略、ETF
动量、趋势、反转
舆情大数据
论文、书籍、阅读材料等
已收藏，感谢楼主分享
楼主会用python吗
- 虚怀若谷 求知若渴
收藏了，感谢！
已经用了，感谢米框
- 70后资深会计，ＣＰＡ，dif-40精通CIA，掌握了股市密码，希望发行自己的阳光私募产品，欢迎合作
看完这个帖子 有森森的恐惧感
。啥也不懂啊。编程盲啊 ？顺便问下楼主 ：这些帖子是说怎么在股市用联合收割机割韭菜的教程吗？笑
- 半自由职业者
我去，都看会了就不用炒股了
我觉得，以一个的精力有限为前提，在没有基础的情况下，化这么多时间去研究程序是没什么意义的。如果不是一个团队，只是个人的化是没有条件做如此复杂的量化投资策略的。
- 交易渴望症患者
- 投资是一场修行，既要博学强识，又要坐怀不乱……
牛逼！收藏！
以我一个理工科学生毕业，看到楼主，都不得不膜拜一下，厉害厉害
大家有什么想学的也可以在下面评论哟～
- 90后摆地摊
- 终于回来了，呵呵
楼主好厉害啊
- 喂喂，我是姜军长，请你务必在坚持最后五分钟，最后五分钟
赞一个，有空读读，哪怕学不会，了解点毛皮也不坏：）
题文不符, 建议改标题为&量化交易基础知识&。
- 90后小韭菜 大三
- 交易所不死老滑头
十八般武艺，只要学会其中一个就够用了。
- 不谋全局者，不足谋一域；不谋万世者，不足谋一时。
收藏了，谢谢
开始学习了。希望多交流。
- 事非经历不知难
我资金小，就像再好的机关枪，没有子弹也不行，我先投降了。
不过，分享精神长青，总有需要的人，替他们谢谢你，我也愿意做一片小韭菜，甘当试验品。
不一定要学会嘛了解了解也许能激发些灵感呢
不会用Python，有无用VBA的，我正学习VBA。
- 韭菜从业资格
满满干货啊～多谢楼主
收藏了。谢谢！
- 牢记凯利公式，严格控制仓位。做好风险评估，尽量唯利是图。
收藏慢慢看，谢谢?(?????)?
- 数据挖掘-深度学习-宏观对冲
这个平台似乎不错，研究一下，感谢楼主。
- 宁愿死也不愿意思考
看到要学这么多，吓尿了。不管怎么说，还是谢谢楼主！
震撼！谢谢楼主
有什么意见或者建议欢迎私信我哟～
所以我被当成发广告的了？
那以后有什么只能在这里更新了
分享一个我自己写的策略的表现
学了一段时间python，比想象中困难，简单一点的用excel方便，但excel更新价格好卡。
正需要这方面的资料，送上门来了。谢谢
- 随心所欲，从善如流
欢迎各路资金踊跃入市，不论你是哪个门派的，能来就好，毕竟大盘的成交量已经低迷了很久了。
都把大刀换成手枪，结果还是相互割
正在学习Python，感谢分享！
- 理财的慢牛
已收藏，感谢。
收藏，琢磨，点赞
已收藏，感谢楼主分享
- 屌丝一枚，努力成为高大上，至高无上
博学而精进
即使不全面使用量化策略，使用量化工具辅助决策已然是发展方向。
谢谢你的文章,这个系列也挺好, 量化小讲堂 - Python
- 一个小散的财务自由梦
Mark一下， 学无止境
- 好好学习，天天向上！
不错！！谢谢！
非常感谢楼主，我在主贴“量化学习资源”链接中找到了杨博理的《中低频量化交易策略研发（上）》，不知道哪里能找到该书的（下），谢了！
收藏了，以后有空学学
【随机相对强弱指数】 代码及运行：
这次的策略主要使用了随机相对强弱指数，特点是最大回撤比较小（18%），年化收益近50%，回测时间2年（）。这两年间的沪深300指数变化不大，尤其是14-15年。考虑这是一个单技术指标的简单策略，这样的表现已经不差。
随机相对强弱指数（Stochastic Relative Strength Index, StochRSI）是基于相对强弱指数（Relative Strength Index）而来的一个技术分析指标，计算方式为：
StochRSI = (RSI - Lowest Low RSI) / (Highest High RSI - Lowest Low RSI)
Lowest Low RSI指的是过去一段时间内RSI的最低值，最常用的是14天。相应地，Highest High RSI指的是过去14个交易日内RSI的最大值。
StochRSI是一个比较灵敏的指标，取值范围为0-1。一般认为，StochRSI的值大于0.8时，即现在的RSI已经相当接近过去一段时间最高的RSI，股票可能已经被超买，投资者应该考虑卖出股票。而当StochRSI的值小于0.2时，RSI已经接近“历史”最低，股票可能被超卖，所以应该考虑买入。
然而除了作为超买超卖的指标，StochRSI还有别的用法，也是这次策略里的用法：可以在StochRSI与股价趋势背离的时候买入卖出。背离有两种可能，一是股价一路走高，然而StochRSI进入超卖区（小于0.2）；二是股价走低，StochRSI反而走高，进入超买区（大于0.8）。
股价走高而StochRSI走低时，说明股价的走势可能已经后劲不足，可能短时间内就会开始下跌，因此应该卖出。股价走低而StochRSI走高时，说明股价会很快止跌上涨，所以应该买入。
配合选股和其他指标，可能还可以再减少最大回撤。这个策略非常简单，但是提供了一个在大盘起伏不明显时候的投资思路。
- 老人家，低风险
满满正能量
感谢楼主无私奉献
- 流而不盈
收藏了，谢谢。要好好学习学习
在今年1月我画过一个图，和下面的类似，只有不到20%的时间阿娇市净率低于4.15.
今天，小编我又用ricequant画了个图，在过去2年里80%的交易日阿娇的市净率都是低于5的
按今日最高价，阿娇的市净率已经到达4.95
仅仅是列个简单的数据，不表达任何观点～
你们说阿娇的估值会不会反转呢？
又到了互道傻逼的时刻了！好想开个赌局
写了一个买全市场pe最低的100个股票的策略，表现还不错啊
收藏了，谢谢
聪明的承担风险
先收藏，以后慢慢看
- 低风险爱好者
先收藏，以后慢慢看
收藏，学习，适合散户吗
- 一分钱投资
收藏了，谢谢楼主
很好值得收藏
阿娇今天的市净率差点到5了，我考虑等到5.1开始逐步卖出阿娇
- 时间自由追寻者
我写了一个自定义调仓频率的函数，供大家参考
import numpy as np
def init(context) :
# 提取中证500指数成分股
context.stocks_pool = index_components('399905.XSHE')
# 随机选取其中的30只
stocks = []
x = [x for x in np.random.randint(0, len(context.stocks_pool), 30)]
for i in x :
stocks.append(context.stocks_pool[i])
context.stocks = stocks
context.flag = False
context.count = 0
# 计数器初始化
def handle_bar(context, bar_dict) :
if context.flag == False :
context.start_date = context.now.date()
print ('start_date -->', context.start_date)
for s in context.stocks :
if bar_dict[s].is_trading and not is_st_stock(s) and bar_dict[s].low & bar_dict[s].high :
order_target_percent(s, 0.9 / len(context.stocks))
print ('买入股票 -->%s'%s)
context.flag = True
# 交易日计时器
if context.flag == True :
context.count
print ('count = ',context.count)
# 设置调仓频率，此处是11个交易日，即半个月
if context.count == 11 :
print ('到期卖出股票')
for s in context.portfolio.positions.keys():
if bar_dict[s].is_trading and bar_dict[s].low & bar_dict[s].high :
order_target_percent(s, 0)
print (context.now.date(),' 卖出', s)
context.flag = False
context.count = 0
赚钱的策略才有用,用什么语言是其次的
是这样的，所以我选了最好上手的python
你们在说什么，好像天书
从雪球上搬来一个股息排序
不过，我写过一个股息率有关的策略，大量分散买入高股息股票有很明显的阿尔法（股息要足够高，这里要视流动性来定）。并通过高股息股票的数量值来控制仓位能有效控制回撤。但是仅仅持有3-5只高股息的股票的话，还是有很大的可能表现平平的。
阿娇还是没有一举涨破5pb
- 与狼共舞，概率和统计，韭菜三分钟
投降投降，缴枪不杀
个股下跌10%就止损的模版
止损描述： 持股大于 X 天，且区间内回报少于 Y % 止损
使用方法：
设置持股天数 X，
在 init 中 ： context.period= X ； 设置区间内回报 Y context.total_return = Y (单位为比例， 非百分比。)
record 和 def stoploss 至script
2： 在下单前 插入 ‘record(context,bar_dict,stock)’ （必须使用for loop 下单）
3： 设置 scheduler.run_daily(stopless)
可以自己import我们平台支持的第三方python模块，比如pandas、numpy等。import pandas as pd
import numpy as np
import time
import datetime
import math
import itertools
在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。def init(context):
context.to_buy = ('300033.XSHE','000025.XSHE')
context.period=10 # 持股天数X
context.total_return=0.05 # 持股天数内的回报率
# 实时打印日志
#scheduler.run_daily(stoploss)
(&Interested at stock: & + str(context.to_buy))
context.time=pd.DataFrame()
scheduler.run_monthly(rebalance,1)
scheduler.run_daily(stoploss)
你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新def handle_bar(context, bar_dict):
# 开始编写你的主要的算法逻辑
# bar_dict[order_book_id] 可以拿到某个证券的bar信息
# context.portfolio 可以拿到现在的投资组合状态信息
# 使用order_shares(id_or_ins, amount)方法进行落单
# TODO: 开始编写你的算法吧！
def stoploss( context,bar_dict):
# 根据时间 清仓
print(context.time)
for stock in
context.portfolio.positions:
if stock in context.time.columns:
buytime=context.time[stock][0] # 获取买入时间
currenttime=context.now.replace(tzinfo=None) # 获取当前时间
print ('buytime='+str(buytime))
print('currenttime='+str(currenttime))
total_return=context.portfolio.positions[stock].market_value/context.portfolio.positions[stock].bought_value # 计算回报
escape=(currenttime-buytime).days # 计算持有天数
if escape>context.period and total_return&1+context.total_return:
print(str(stock)+ '大于' + str (context.period)+'天 且回报过小， 卖出')
order_target_percent(stock, 0)
del context.time[stock]
elif total_return>1+context.total_return:
print(str(stock)+'回报为: ' +str(total_return)+'大于预设值'+str(1+context.total_return))
print(str(stock)+ '持仓未到' +str(context.period)+'天,继续持有')
def record(context,bar_dict,stock):
if stock not in context.time.columns:
temp=pd.DataFrame({str(stock):[context.now.replace(tzinfo=None)]})
context.time = pd.concat([context.time, temp], axis=1, join='inner')
def rebalance(context,bar_dict):
#time=pd.DataFrame() #在买入的同时 创建一个Dataframe 储存买入的时间。
if len(context.to_buy)!=0:
for stock in context.to_buy:
record(context,bar_dict,stock)
order_target_percent(stock,1/len(context.to_buy))
#temp=pd.DataFrame({str(stock):[context.now.replace(tzinfo=None)]})
#time = pd.concat([time, temp], axis=1, join='inner')
#context.time=time
order_target_percent(stock,0)
另外一种止损方法：
止损描述 :
回撤超过 X%
之后 止损。
套用方法：
在 init 中设置你的 回撤 X
context.drawdown = 0.1 % 回撤限度 10%
1： 复制‘scheduler.run_daily(stoploss)’ 至 init
复制 def stoploss ， def createdic 到策略内
之前加入 createdic(context,bar_dict,stock)
可以自己import我们平台支持的第三方python模块，比如pandas、numpy等。import pandas as pd
import numpy as np
import time
import math
import datetime
在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。def init(context):
context.to_buy = ('300033.XSHE','000025.XSHE','601390.XSHG')
context.drawdown= 0.1 # 回撤限度 10%
context.maxvalue=pd.DataFrame()
# 实时打印日志
#scheduler.run_daily(stoploss)
(&Interested at stock: & + str(context.to_buy))
scheduler.run_monthly(position,1)
scheduler.run_daily(stoploss)
def stoploss(context,bar_dict):
for stock in context.portfolio.positions:
market_value=context.portfolio.positions[stock].market_value# 该股市场价值 单位（RMB）
bought_value=context.portfolio.positions[stock].bought_value#该股初始价值 单位（RMB）
stockdic=context.maxvalue[stock]
maxvalue=stockdic[0]
del context.maxvalue[stock]
#currSP=context.initSPM*(1+math.floor((maxvalue/bought_value-1)/context.step)*context.increment) #阶梯止损算法 例： 该股市值增加10%， 止盈比例提高 5%
temp=pd.DataFrame({str(stock):[max(maxvalue,market_value)]})
context.maxvalue=pd.concat([context.maxvalue,temp], axis=1, join='inner') # 更新其盘中最高价值和先阶段比例。
drawdown=1-market_value/max(maxvalue,market_value)
print(str(stock)+'的成本为：' +str( bought_value) +', 最高价值为：'+str(maxvalue)+'现价值为：'+ str(market_value))
print(str(stock) +'的现 回撤为: ' +str(drawdown*100)+ '%')
# ( type(market_value))
#(type(ontext.maxvalue[stock].values)))
if drawdown>context.drawdown:# 现价低于 原价一定比例
order_target_percent(stock,0)
print(str(stock)+'回撤大于'+ str(context.drawdown*100)+ '%'+'
触发止损')
del context.maxvalue[stock]
你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新def handle_bar(context, bar_dict):
# 开始编写你的主要的算法逻辑
# bar_dict[order_book_id] 可以拿到某个证券的bar信息
# context.portfolio 可以拿到现在的投资组合状态信息
# 使用order_shares(id_or_ins, amount)方法进行落单
# TODO: 开始编写你的算法吧！
#position(context,bar_dict)
#(type(context.now))
def createdic(context,bar_dict,stock):
if stock not in context.maxvalue.columns:
temp=pd.DataFrame({str(stock):[context.portfolio.positions[stock].bought_value]})
context.maxvalue = pd.concat([context.maxvalue, temp], axis=1, join='inner')
print(context.maxvalue)
def position(context,bar_dict):
if len(context.to_buy)!=0:
for stock in context.to_buy:
order_target_percent(stock,1/len(context.to_buy))
createdic(context,bar_dict,stock)
order_target_percent(stock,0)
收藏了，学习
止损方法3:
止损描述： 当前股价大于/小于 某一价格 进行 止盈/止损
使用方法：
在init 中 设置止盈/止损比例，
止损:context.stoplossmultipler= 0.9 #亏损10% 触发止损
止盈：context.stoppofitmultipler= 1.5 #盈利 50% 触发止盈
1： 复制 def stoploss 至script
2： 设置 scheduler.run_daily(stopless)
可以自己import我们平台支持的第三方python模块，比如pandas、numpy等。import pandas as pd
import numpy as np
import time
import datetime
在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。def init(context):
context.to_buy = ('300033.XSHE','000025.XSHE','601766.XSHG')
context.stoplossmultipler= 0.95 #止损 乘数
context.stoppofitmultipler= 1.5 #止盈 乘数
# 实时打印日志
#scheduler.run_daily(stoploss)
(&Interested at stock: & + str(context.to_buy))
scheduler.run_monthly(position,1)
scheduler.run_daily(stoploss)
def stoploss(context,bar_dict):
for stock in context.portfolio.positions:
if bar_dict[stock].last&context.portfolio.positions[stock].average_cost*context.stoplossmultipler:# 现价低于 原价一定比例
order_target_percent(stock,0)
print(str(stock)+'跌幅超过'+str((1-context.stoplossmultipler)*100) +'%
触发止损')
elif bar_dict[stock].last>context.portfolio.positions[stock].average_cost*context.stoppofitmultipler:# 现价高于原价一定比例
order_target_percent(stock,0)
print(str(stock)+'涨幅幅超过'+str((context.stoppofitmultipler-1)*100) +'%
触发止盈')
你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新def handle_bar(context, bar_dict):
# 开始编写你的主要的算法逻辑
# bar_dict[order_book_id] 可以拿到某个证券的bar信息
# context.portfolio 可以拿到现在的投资组合状态信息
# 使用order_shares(id_or_ins, amount)方法进行落单
# TODO: 开始编写你的算法吧！
#position(context,bar_dict)
#(type(context.now))
def position(context,bar_dict):
if len(context.to_buy)!=0:
for stock in context.to_buy:
order_target_percent(stock,1/len(context.to_buy))
order_target_percent(stock,0)
感谢楼主，收藏，学习
动态止损：
止损描述 :
设置初始 止损比例 M ， 股价每上涨 X% ， 就将止损比例 提高 Y %
本例中：初始止损比例为 -10%。 股价每上涨 10%， 就将止盈比例提高9%
套用方法：
在 init 中设置你的 A X Y
1： 复制‘scheduler.run_daily(stoploss)’ 至 init
复制 def stoploss ， def createdic 到策略内
之后加入 createdic(context,bar_dict,stock)
可以自己import我们平台支持的第三方python模块，比如pandas、numpy等。import pandas as pd
import numpy as np
import time
import math
import datetime
在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。def init(context):
context.to_buy = ('300033.XSHE','000025.XSHE')
context.initSLM=0.9 # 初始止损比例 M
context.step=0.10
context.increment=0.09 # 止损增量
context.maxvalue=pd.DataFrame()
# 实时打印日志
#scheduler.run_daily(stoploss)
(&Interested at stock: & + str(context.to_buy))
scheduler.run_monthly(position,1)
scheduler.run_daily(stoploss)
def stoploss(context,bar_dict):
for stock in context.portfolio.positions:
market_value=context.portfolio.positions[stock].market_value# 该股市场价值 单位（RMB）
bought_value=context.portfolio.positions[stock].bought_value#该股初始价值 单位（RMB）
stockdic=context.maxvalue[stock]
maxvalue=stockdic[0]
del context.maxvalue[stock]
currSL=context.initSLM*(1+context.increment)**math.floor((math.log(maxvalue/bought_value)/math.log(1+context.step)))#阶梯止损算法
temp=pd.DataFrame({str(stock):[max(maxvalue,market_value),currSL]})
context.maxvalue=pd.concat([context.maxvalue,temp], axis=1, join='inner') # 更新dataframe。
print(str(stock)+'的成本为：' +str( bought_value) +', 最高价值为：'+str(maxvalue)+'现价值为：'+ str(market_value))
print(str(stock) +'的现 止损价位为: ' +str(currSL))
# ( type(market_value))
#(type(ontext.maxvalue[stock].values)))
if market_value&bought_value*currSL:# 现价初始止损价
order_target_percent(stock,0)
#del context.maxvalue[stock]
print(str(stock)+ ('触发止损'))
'''elif market_value&bought_value*currSL:# 现价低于阶梯止损价
order_target_percent(stock,0)
print(str(stock)+ ('触发初始止损'))
del context.maxvalue[stock]'''
你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新def handle_bar(context, bar_dict):
# 开始编写你的主要的算法逻辑
# bar_dict[order_book_id] 可以拿到某个证券的bar信息
# context.portfolio 可以拿到现在的投资组合状态信息
# 使用order_shares(id_or_ins, amount)方法进行落单
# TODO: 开始编写你的算法吧！
#position(context,bar_dict)
#(type(context.now))
def createdic(context,bar_dict,stock):
if stock not in context.maxvalue.columns:
temp=pd.DataFrame({str(stock):[context.portfolio.positions[stock].bought_value,context.initSLM]})
context.maxvalue = pd.concat([context.maxvalue, temp], axis=1, join='inner')
print(context.maxvalue)
def position(context,bar_dict):
if len(context.to_buy)!=0:
for stock in context.to_buy:
order_target_percent(stock,1/len(context.to_buy))
createdic(context,bar_dict,stock)
order_target_percent(stock,0)
这个必须支持一下
- 微信公众号“feichang158”欢迎关注！
在之前的止损策略里， 我们介绍了 时间止损和阶梯止损， 这两个简单的 止损策略。
如果忘了， 我们再来复习一下。
if 持股时间 >X 天 and 周期内涨幅少于 Y%：
阶梯次数= floor(log(1+最大涨幅%)/log(1+阶梯长度%))
止损价位=初始止损价*(1+Y%)^周期次数
if 现价&止损价位:
如果把他们结合在一起呢 ？ 。
这样就诞生了一个时间止损 Pro 版。
持有 X 天， 若在此周期内涨幅超过 Y % 则继续持有， 并将止损价设置为 (1+Y%)
阶梯次数= floor (持股时间(天)/周期X(天))
止损价= 买入价*(1+阶梯次数* Y%)
if 持股时间>周期 X
and 现价& 止损价：
持股时间&周期X and 现价&买入价*预设止损比例：
在第一个周期内亏损过多， 卖出止损
效果还是挺好的呢
止损描述： 持股大于 X 天，且区间内回报少于 Y % 止损
若回报大于Y% 则将止损线提高至 1+Y%
使用方法：
设置持股天数 X，
在 init 中 ： context.period= X ； 设置区间内回报 Y，在 init 中 ： context.increment= Y (单位为比例， 非百分比。)
record 和 def stoploss 至script
2： 在下单前 插入 ‘record(context,bar_dict,stock)’ （必须使用for loop 下单）
3： 设置 scheduler.run_daily(stopless)
可以自己import我们平台支持的第三方python模块，比如pandas、numpy等。import pandas as pd
import numpy as np
import time
import datetime
import math
import itertools
在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。def init(context):
context.to_buy = ('300033.XSHE','000025.XSHE')
context.period=10 # 持股天数X
context.increment=0.15
# 实时打印日志
context.time=pd.DataFrame()
scheduler.run_monthly(rebalance,1)
scheduler.run_daily(stoploss)
你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新def handle_bar(context, bar_dict):
# 开始编写你的主要的算法逻辑
# bar_dict[order_book_id] 可以拿到某个证券的bar信息
# context.portfolio 可以拿到现在的投资组合状态信息
# 使用order_shares(id_or_ins, amount)方法进行落单
# TODO: 开始编写你的算法吧！
def stoploss( context,bar_dict):
# 根据时间 清仓
print(context.time)
for stock in
context.portfolio.positions:
if stock in context.time.columns:
buytime=context.time[stock][0] # 获取买入时间
currenttime=context.now.replace(tzinfo=None) # 获取当前时间
print ('buytime='+str(buytime))
print('currenttime='+str(currenttime))
total_return=context.portfolio.positions[stock].market_value/context.portfolio.positions[stock].bought_value # 计算回报
escape=(currenttime-buytime).days # 计算持有天数
threshold=math.floor(escape/context.period)*context.increment+1 # 计算期望。
if escape>context.period and total_return&threshold:
print(str(stock)+ '大于' + str (context.period)+'天 且回报小于'+ str(threshold)+' 卖出')
order_target_percent(stock, 0)
del context.time[stock]
elif total_return>threshold:
print(str(stock)+'回报为: ' +str(total_return)+'大于预设值'+str(threshold)+', 继续持有')
elif total_return&0.95:
print(str(stock)+'周期内跌幅超过5% 直接止损')
print(str(stock)+ '持仓未到' +str(context.period)+'天,继续持有')
def record(context,bar_dict,stock):
if stock not in context.time.columns:
temp=pd.DataFrame({str(stock):[context.now.replace(tzinfo=None)]})
context.time = pd.concat([context.time, temp], axis=1, join='inner')
def rebalance(context,bar_dict):
#time=pd.DataFrame() #在买入的同时 创建一个Dataframe 储存买入的时间。
if len(context.to_buy)!=0:
for stock in context.to_buy:
record(context,bar_dict,stock)
order_target_percent(stock,1/len(context.to_buy))
order_target_percent(stock,0)
- 懒是人类进步的动力
学习 谢谢分享
难道必须是程序员出身啊
python很容易上手的，主要还是交易思想。
首先介绍一个指标： ATR指标。
真实波幅（ATR）主要应用于了解股价的震荡幅度和节奏，在窄幅整理行情中用于寻找突破时机。通常情况下股价的波动幅度会保持在一定常态下，但是如果有主力资金进出时，股价波幅往往会加剧。另外，在股价横盘整理、波幅减少到极点时，也往往会产生变盘行情。真实波幅（ATR）正是基于这种原理而设计的指标。
好了，总而言之，这是一个玄学指标。 玄学止损， Best 止损。
我们来看看这个玄学指标是怎么算的吧？
Raw_ATR=max(|今日振幅|， |昨天收盘-今日最高价|，|昨天收盘-今日最低价|)# 未处理ATR 为这三个指标的最大值
ATR=moving_average (ATR ,N)
#真实ATR 为 Raw_ATR 的N 日简单移动平均,默认N=22
根据这个指标， 我们能做很多有意思的策略。
这里就举一个例子： 吊灯止损。
计算每日, 某个股票的ATR。
if 现价&持有股票之后的收盘价-3* ATR：
这里提供了 一个相当精彩的模板， 喜欢的话拿去玩吧...
止损描述 :
计算ATR指标。 若当前价& 持仓最高价-3* ATR ：
卖出止损。
套用方法：
在 init 中设置你的 moving average ATR 周期： context.ATRperiod=22
1： 复制‘scheduler.run_daily(stoploss)’ 至 init
复制 def stoploss ， def createdic ，def findATR 到策略内
之后加入 createdic(context,bar_dict,stock)
可以自己import我们平台支持的第三方python模块，比如pandas、numpy等。import pandas as pd
import numpy as np
import time
import math
import talib
import datetime
在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。def init(context):
context.to_buy = ('300033.XSHE','000025.XSHE')
context.ATRperiod=22# ATR 中moving average 的N 值,可自己调, 默认为22
update_universe(context.to_buy)
context.trigger=0
context.initSL=0.9
context.profit=0.2 # 当盈利大于20% 就将阶梯设为此价位。
context.maxvalue=pd.DataFrame()
# 实时打印日志
#scheduler.run_daily(stoploss)
(&Interested at stock: & + str(context.to_buy))
scheduler.run_monthly(position,1)
scheduler.run_daily(stoploss)
def findATR(context,bar_dict,stock): # 玄学指标
close=history(context.ATRperiod+2,'1d','close')[stock][0:context.ATRperiod]
high=history(context.ATRperiod+2,'1d','high')[stock][1:context.ATRperiod+1]
low=history(context.ATRperiod+2,'1d','low')[stock][1:context.ATRperiod+1]
art1=high.values-low.values
art2=abs(close.values-high.values)
art3=abs(close.values-low.values)
art123=np.matrix([art1, art2,art3])
rawatr=np.array(art123.max(0)).flatten()
ATR=rawatr.sum()/len(rawatr)
print(str(rawatr)+'ATR='+str(rawatr))
print(str(stock)+'ATR='+str(ATR))
return ATR
def stoploss(context,bar_dict):
for stock in context.portfolio.positions:
high=bar_dict[stock].high
current=bar_dict[stock].last
bought_value=context.portfolio.positions[stock].bought_value#该股初始价值 单位（RMB）
stockdic=context.maxvalue[stock]
highest=stockdic[0]
del context.maxvalue[stock]
ATR=findATR(context,bar_dict,stock)
#currSP=context.initSPM*(1+math.floor((maxvalue/bought_value-1)/context.step)*context.increment) #阶梯止损算法 例： 该股市值增加10%， 止盈比例提高 5%
temp=pd.DataFrame({str(stock):[max(highest,high)]})
context.maxvalue=pd.concat([context.maxvalue,temp], axis=1, join='inner') # 更新其盘中最高价值和先阶段比例。
print(str(stock)+'的成本为：' +str( context.portfolio.positions[stock].average_cost) +', 最高价为：'+str(highest)+'ATR为：'+ str(ATR))
if bar_dict[stock].last&highest-3*ATR:
print('吊灯止损')
order_target_percent(stock,0)
del context.maxvalue[stock]
# ( type(market_value))
#(type(ontext.maxvalue[stock].values)))
你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新def handle_bar(context, bar_dict):
# 开始编写你的主要的算法逻辑
# bar_dict[order_book_id] 可以拿到某个证券的bar信息
# context.portfolio 可以拿到现在的投资组合状态信息
# 使用order_shares(id_or_ins, amount)方法进行落单
# TODO: 开始编写你的算法吧！
#position(context,bar_dict)
#(type(context.now))
def createdic(context,bar_dict,stock):
if stock not in context.maxvalue.columns:
temp=pd.DataFrame({str(stock):[0]})
context.maxvalue = pd.concat([context.maxvalue, temp], axis=1, join='inner')
print(context.maxvalue)
def position(context,bar_dict):
if len(context.to_buy)!=0:
for stock in context.to_buy:
createdic(context,bar_dict,stock)
order_target_percent(stock,1/len(context.to_buy))
order_target_percent(stock,0)
大家可以提一些问题呀
以及你们有什么想看的都可以留言
看来还是我多多分享吧
这个必须支持一下，先收藏了，有时间再慢慢阅读，不一定非要精通，有时候思路就是最好的火花
- 数理金融
要回复问题请先或