log.info(str('函数运行时间（stoploss）' + str(context.current_dt.time())))

讲完基于单均线的股票模型

record(stock_price=current_price)

画出上一时间点价格

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

剪切选择的单元格

主要给大家提供几个大范围的量化思路

本篇为第一讲，举了一个技术指标的例子

收益曲线非常可观

小结

我们这里是量化课堂的第三部分

在这里，小编提供一个同时持有股票数 N 的选择的小tips

如果想分散风险，可以多选一些股票

因为手续费是有最低限制的

但是，分到每个股票的资金最好不要少于两万

如果风险承受能力强的话可以少选一点

各位读者可以自己尝试修改参数

是不是很棒？

看看参数应该如何选取

你会发现在大部分时间里面，策略的收益比基准收益高

从2005开始回测至今

好啦，看看小编选了5个股票的回测结果吧

最大可以同时持有N只股票

用于实现这个策略的主函数可以参考回测代码块1和2

死叉了就卖出

按日进行判断和交易

哪只金叉了就买入

在交易日前，同时对多个股票进行判断

其中pi表示前一天的收盘价，且

除了改为指数移动平均线以外，小编还加入多股票实现方法

多股票

就可以轻松的在不同的参数之间来回切换，比较收益

如果写出这样的子函数，那么在主程序里面只要改一下函数输入参数

怎么样？是不是有点挑战性？

写出来没？如果没写出来的话可以参考回测代码块3和4（里面有代码和注释）

EMA 公式分析

公式简单分析

因此这可能是个有点挑战的地方

主要区别在于指数移动平均需要进行一个迭代

指数移动平均和算术平均或者加权平均

可以试一下计算指数移动平均的函数

接下来，如果你想挑战更高难度

也可以参考回测代码块5（里面有代码和注释）

各位读者可以先自己进行尝试

然后计算一个算术平均数就可以了

方法不难，获得前N天的收盘价

我想 改造一个指 数 均线呢？

我想改造一个指数均线呢？

比如说，我想对均线进行加权呢？

对一些现有的策略进行改造

有时候我们也许会根据自己的需要对一些现有的策略进行改造

还有几个股票模型的代码

当然不行

老师，可以了嘛？

直接复制粘贴就能运行，是不是很简单呢？

单均线策略讲解完毕

有关技术指标的文章，百度上一搜一大把

我们平台里也有很多相关的帖子

python公开库ta-lib里也收录了很多指标

大家想进一步研究可以实现一下

也可以结合其他选股策略

或者根据需要制订资金等分的份数或者控制仓位等方法提高策略的收益

或者根据需要制订资金 等分的份数或者控制 仓位等方法 提高策略的收益

python 公开库 ta-lib 里 也收录了很多指标

不存在万能指标。参数也很重要

主函数 思维导图

主函数 思维 导图

第一部分是 初始化函数

开盘前选择股票池

开盘后 分析数据进行卖出和买入操作

准备 克隆策略

克隆策略完成

双均线策略-py3-Clone

双均线策略-4股-2010至今

2010年开始回测数据

回测数据段设置

结束时间是 2023-9-28

资金额度 10000000

点击 运行回测 看看结果

2010年的行情

2011年的表现，不佳

2012年的表现还好

2013年的表现

2014年的表现不错

2015年的表现先扬后抑

2016年的表现比较惨

2017年的表现不错

2018年就是贸易战的年份

2019年很不错

2020年也很不错

2021年比较震荡

2022年比较糟糕

2023年也不太有利

正在进行整体交易记录的汇总计算

整体效果不佳不如前期的 单品种系统

模型表现不佳，我们分析代码

https www.joinquant.com post 1398

代码 来自 双均线 文章

网页回退，来到前期的 API 文档中

标题：【量化课堂】双均线策略

作者：JoinQuant量化课堂

双均线策略

2015-01-01 到 2016-03-08, ￥2000000, 每天

多行注释

总体回测前

总体回测前要做的事情

def initialize(context)

initialize(context)

设置策略参数

set_params()

设置中间变量

set_variables()

设置回测条件

set_backtest()

# 设置策略参数

def set_params()

调仓频率

g.tc = 15

g.tc = 15

持仓数目

g.N = 4

g.N = 4 四只股票

设置股票池

g.security = []

g.security = [] 股票代码 列表

不是连续代码。部分股票退市

事后知道已经退市

已经包含了未来数据

# 设置中间变量

def set_variables()

return 无设置，直接返回

def set_variables() - 占位函数

#设置回测条件

def set_backtest() 回测函数

用真实价格交易

set_option('use_real_price', True)

set_option('use_real_price', True) 代码分析

log.set_level('order', 'error')

每天开盘前

每天开盘前要做的事情

def before_trading_start(context)

before_trading_start(context) - contex 作为参数

set_slip_fee(context)

根据不同的时间段设置滑点与手续费

不同时期，手续费不同

通过空格分开函数

将滑点设置为0

set_slippage(FixedSlippage(0))

FixedSlippage( 0 )

set_slippage( FixedSlippage(0) )

根据不同的时间段设置手续费

dt = context.current_dt

if dt 大于 datetime.datetime(2013, 1, 1)

set_commission(PerTrade(buy_cost=0.0003, sell_cost=0.0013, min_cost=5))

PerTrade(buy_cost=0.0003, sell_cost=0.0013, min_cost=5)

buy_cost=0.0003, sell_cost=0.0013, min_cost=5

set_commission( PerTrade(buy_cost=0.0003, sell_cost=0.0013, min_cost=5) )

elif dt datetime.datetime(2011,1, 1)

datetime.datetime(2011,1, 1)

set_commission(PerTrade(buy_cost=0.001, sell_cost=0.002, min_cost=5))

PerTrade(buy_cost=0.001, sell_cost=0.002, min_cost=5)

buy_cost=0.001, sell_cost=0.002, min_cost=5

set_commission( PerTrade(buy_cost=0.001, sell_cost=0.002, min_cost=5) )

elif dt datetime.datetime(2009,1, 1)

datetime.datetime(2009,1, 1)

set_commission(PerTrade(buy_cost=0.002, sell_cost=0.003, min_cost=5))

PerTrade(buy_cost=0.002, sell_cost=0.003, min_cost=5)

buy_cost=0.002, sell_cost=0.003, min_cost=5

set_commission( PerTrade(buy_cost=0.002, sell_cost=0.003, min_cost=5) )

else 其他 时期的 成本

set_commission(PerTrade(buy_cost=0.003, sell_cost=0.004, min_cost=5))

PerTrade(buy_cost=0.003, sell_cost=0.004, min_cost=5)

buy_cost=0.003, sell_cost=0.004, min_cost=5

set_commission( PerTrade( buy_cost=0.003, sell_cost=0.004, min_cost=5 ) )

每天交易时

def handle_data(context, data)

(context, data)

将总资金等分为g.N份，为每只股票配资

capital_unit = context.portfolio.portfolio_value g.N

capital_unit = context.portfolio.portfolio_value g.N - 代码分析

toSell = signal_stock_sell(context,data)

signal_stock_sell( context,data )

toBuy = signal_stock_buy(context,data)

代码块进行空格分隔

执行卖出操作以腾出资金

for i in range(len(g.security))

for i in range(len(g.security)) - 代码分析

if toSell[i]==1

if toSell[i] == 1 - 存在要卖出的股票

order_target_value(g.security[i],0)

order_target_value(g.security[i],0) 清空这支股票的仓位

执行买入操作

for i in range(len(g.security))

len(g.security)

if toBuy[i]==1

if toBuy[i]==1 是否需要买入

order_target_value(g.security[i],capital_unit)

order_target_value(g.security[i],capital_unit) - 代码分析

if not (1 in toBuy) or (1 in toSell)

if not (1 in toBuy) or (1 in toSell) 判断是否有操作

# log.info('今日无操作')

log.info('今日无操作') 日志里面写清楚

send_message('今日无操作') 代码分析

Ctrl + H，替换双引号 为 单引号

成功替换，方便保存文件名

['000001.XSHE','000002.XSHE','000006.XSHE','000007.XSHE','000009.XSHE'] # 设

获得卖出信号

输入：context, data

输出：sell - list

def signal_stock_sell(context,data)

sell = [0] len(g.security)

生成有多个元素的列表

新建一个 Python 3 的 Notebook

lst = [0] 5

生成 有多个元素 的列表

给研究环境改名

for i in range(len(g.security))

算出今天和昨天的两个指数移动均线的值

我们这里假设长线是60天，短线是1天(前一天的收盘价)

长线和短线之间有明显的时间差距

(ema_long_pre,ema_long_now)

结果为元组数据

get_EMA(g.security[i],60,data)

get_EMA(g.security[i],60,data) 代码分析

(ema_short_pre,ema_short_now)

get_EMA(g.security[i],1,data)

如果短均线从上往下穿越长均线，则为死叉信号，标记卖出

ema_short_now ema_long_now

ema_short_pre 大于 ema_long_pre

context.portfolio.positions[g.security[i]].sellable_amount 大于 0

sell[i]=1

return sell

循环分析每一只股票的情况

获得买入信号

输入：context, data

输出：buy - list

def signal_stock_buy(context,data)

buy = [0] len(g.security)

for i in range(len(g.security))

算出今天和昨天的两个指数移动均线的值

我们这里假设长线是60天，短线是1天(前一天的收盘价)

(ema_long_pre , ema_long_now)

get_EMA(g.security[i], 60, data)

(ema_short_pre , ema_short_now)

get_EMA(g.security[i], 1, data)

如果短均线从下往上穿越长均线，则为金叉信号，标记买入

同样是 3 个条件来确定

ema_short_now 大于 ema_long_now

ema_short_pre 小于 ema_long_pre

context.portfolio.positions[g.security[i]].sellable_amount == 0

买入条件分析

buy[i]=1

满足 3 个条件，可以买入股票

return buy

计算移动平均线数据

输入：股票代码-字符串，移动平均线天数-整数

输出：算术平均值-浮点数

def get_MA(security_code,days)

获得前days天的数据，详见API

a=attribute_history(security_code, days, '1d', ('close'))

security_code, days, '1d', ('close')

定义一个局部变量sum，用于求和

sum = 0

对前days天的收盘价进行求和

for i in range(1,days+1)

for i in range(1,days+1) 代码分析

sum+=a['close'][-i]

for 循环实现了所有收盘价都累加在一起

求和之后除以天数就可以的得到算术平均值啦

return sum 除以 days

计算指数移动平均线数据

指数移动平均线数据

输入：股票代码-字符串，移动指数平均线天数-整数，data

输出：今天和昨天的移动指数平均数-浮点数

def get_EMA(security_code,days,data)

如果只有一天的话,前一天的收盘价就是移动平均

获得前两天的收盘价数据，一个作为上一期的移动平均值，后一个作为当期的移动平均值

t = attribute_history(security_code, 2, '1d', ('close'))

return t['close'][-2],t['close'][-1]

attribute_history(security_code, 2, '1d', ('close'))

如果全局变量g.EMAs不存在的话，创建一个字典类型的变量，用来记录已经计算出来的EMA值

if 'EMAs' not in dir(g)

g.EMAs={}

字典的关键字用股票编码和天数连接起来唯一确定

以免不同股票或者不同天数的指数移动平均弄在一起了

key='%s%d' %(security_code,days)

如果关键字存在，说明之前已经计算过EMA了，直接迭代即可

if key in g.EMAs

计算alpha值

alpha=(days-1.0) (days+1.0)

获得前一天的EMA（这个是保存下来的了）

EMA_pre=g.EMAs[key]

EMA_now=EMA_pre alpha+data[security_code].close (1.0-alpha)

写入新的EMA值

g.EMAs[key]=EMA_now

给用户返回昨天和今天的两个EMA值

return (EMA_pre,EMA_now)

需要两个 EMA 值来判断金叉和死叉

获得days天的移动平均

ma=get_MA(security_code,days)

如果滑动平均存在（不返回NaN）的话，那么我们已经有足够数据可以对这个EMA初始化了

if not(isnan(ma))

g.EMAs[key]=ma

因为刚刚初始化，所以前一期的EMA还不存在

return (float('nan'),ma)

移动平均数据不足days天，只好返回NaN值

每天收盘后

每日收盘后要做的事情（本策略中不需要）

def after_trading_end(context)

return

五一算法-讲解版-5股-2010年至今

导入函数库

import jqdata

from jqlib.technical_analysis import 星

from jqdata import 星

import warnings

初始化函数

def initialize(context)

滑点高（不设置滑点的话用默认的0.00246）

set_slippage(FixedSlippage(0.02))

沪深300指数作为基准

set_benchmark('000300.XSHG')

用真实价格交易

set_option('use_real_price', True)

双引号改成单引号

set_option('avoid_future_data', True)

过滤order中低于error级别的日志

log.set_level('order', 'error')

过滤不重要的日志信息

warnings.filterwarnings('ignore')

选股参数

g.stock_num = 5 # 持仓数

g.position = 1 # 仓位

手续费

set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0005, close_commi

设置交易时间

run_monthly(my_trade, monthday=1, time='10 00', reference_security='000300.XS

开盘时运行函数

def my_trade(context)

获取选股列表并过滤掉：st,st ,退市,涨停,跌停,停牌

check_out_list = get_stock_list(context)

log.info('今日自选股：%s' % check_out_list)

adjust_position(context, check_out_list)

选出资产负债率后20%且大于0，优质资产周转率前20%，roa改善最多的股票列表

def get_stock_list(context)

curr_data = get_current_data()

yesterday = context.previous_date

df_stocknum = pd.DataFrame(columns=['当前符合条件股票数量'])

过滤次新股

by_date = yesterday - datetime.timedelta(days=1200) # 三年

datetime.timedelta(days=1200)

get_all_securities(date=by_date).index.tolist()

initial_list

所以 2005 年出开始回测。还没有记录

0.st，今天涨跌停的，停牌的

stock for stock in initial_list

if not

(curr_data[stock].day_open == curr_data[stock].high_limit) 过滤涨停

(curr_data[stock].day_open == curr_data[stock].low_limit)

curr_data[stock].paused

('ST' in curr_data[stock].name)

('' in curr_data[stock].name)

('退' in curr_data[stock].name)

对不符合条件的股票做过滤

一般聚宽提供的代码没有过滤掉 ST 股票

df_stocknum.append({'当前符合条件股票数量'：len(initial_list)}, ignore_index=True)

了解满足条件的股票数量

选出资产负债率由高到低后70%的，low_liability_list

get_fundamentals()

balance.code, balance.total_liability, balance.total_assets

filter() 过滤条件

valuation.code.in_(initial_list)

.dropna()

df = df.fillna(0)

df['ratio'] = df['total_liability'] 除法 df['total_assets'] # 资产负债率

df = df.sort_values(by = 'ratio',ascending=False)

low_liability_list = list(df.code)[int(0.3 len(list(df.code))) ]

股票代码转换成列表

[int(0.3 len(list(df.code))) ]

选出资产负债率由高到低后70%的

df_stocknum = df_stocknum.append({'当前符合条件股票数量'： len(low_liability_list)}, ig

从low_liability_list中选出不良资产比率在总体中[20%-80%]范围内的的股票，proper_receivable_list

query(balance.code

balance.total_assets, # 总资产

balance.bill_receivable, # 应收票据

balance.account_receivable, # 应收账款

balance.other_receivable, # 其他应收款

balance.good_will, # 商誉

balance.intangible_assets, # 无形资产

balance.inventories, # 存货

balance.constru_in_process,# 在建工程

balance.code.in_(low_liability_list)

df1 = df1.fillna(0)

df1.sum(axis=1) - df1['total_assets']

df1['ratio1'] = df1['bad_assets'] 除法 df1['total_assets']

df1 = df1.sort_values(by = 'ratio1',ascending=False)

proper_receivable_list

list(df1.code)

[int(0.1 len(list(df1.code))) int(0.9 len(list(df1.code)))]

df_stocknum = df_stocknum.append({'当前符合条件股票数量' len(proper_receivable_list)}

从proper_receivable_list中选出优质资产周转率前75%的公司，proper_receivable_list1

df2 = get_fundamentals()

df2 = df2.fillna(0)

df2['good_assets']

df2['total_assets'] - (df2.sum(axis=1) - df2['total_assets'] - df2['total_op

df2['ratio2'] = df2['total_operating_revenue'] 除法 df2['good_assets']

df2 = df2.sort_values(by = 'ratio2',ascending=False)

proper_receivable_list1 = list(df2.code)[ int(0.75 len(list(df2.code)))]

df_stocknum = df_stocknum.append({'当前符合条件股票数量'

if len(proper_receivable_list1) == 0

从proper_receivable_list1中过去十二个季度ROA增长最多(前20%）的股票，按照ROA`增长量降序排列,roa_list

get_history_fundamentals()

get_history_fundamentals() 读取 ROA 数据

计算 ROA 增长量

ROA 增长量，降序排序

list(s_delta_avg[ int(0.2 len(s_delta_avg))].index)

从过去四个季度ROA增长量前20%的股票中选出市净率大于0的按照资产负债率升序排列选出前g.stock_num个，final_list

pb_list = get_fundamentals()

valuation.code.in_(roa_list)

valuation.pb_ratio 大于 0.7

valuation.ps_ratio 小于 3

valuation.pb_ratio.asc()

按要求过滤股票，并按照 PB 升序排列

final_list = pb_list[ g.stock_num]

return final_list

def adjust_position(context, buy_stocks)

for stock in context.portfolio.positions

if stock not in buy_stocks

order_target(stock, 0)

position_count = len(context.portfolio.positions)

if g.stock_num 大于 position_count

context.portfolio.cash 星 g.position 除法 (g.stock_num - position_count)

仓位计算

for stock in buy_stocks

if stock not in context.portfolio.positions

order_target_value(stock, value)

if len(context.portfolio.positions) == g.stock_num

break 持仓满足条件就中断循环

调仓模块比较简单

清仓多少，买入多少

一买一卖模型

def get_stock_list(context) 晒选排序股票最复杂

过滤次新股是先决条件

垃圾股过滤

多重财务指标反复筛选

对于五一算法的一些重要内容再详细介绍

set_option('avoid_future_data', True)

打开 API 文档

查找 set_option 函数

发现大量和 set_option 相关的设置

set_option() 在股票、期货、融资融券中有大量设置

过滤order中低于error级别的日志

log.set_level('order', 'error')

查询 log.set_level 发现有 8 处介绍

找到 log.set_level 相关函数介绍

设定log级别：log.set_level

log.set_level(name, level)

设置不同种类的log的级别, 低于这个级别的log不会输出

所有log的默认级别是debug

为了降低排查问题的难度，建议日志级别保持为默认级别

不设置日志级别，或者设置log.set_level('order', 'info')

参数 name 字符串, log种类

必须是'order', 'history', 'strategy'中的一个

order 调用order系列API产生的log

history 调用history系列API(history attribute_history get_price) 产生的log

strategy 您自己在策略代码中打的log

system 统日志，除以上三类之外的日志

level 字符串, 必须是'debug', 'info', 'warning', 'error'中的一个

级别 逐步加大 debug info warning error

返回 None

设置日志级别为debug

log.set_level('order', 'debug')

尽量设置日志级别为debug，或者不设置（使用系统默认级别），有利于您快速的发现问题

模拟交易中，需要修改日志级别，可以在after_code_changed中，重新设置日志级别

log.set_level(name, level) 详细讲解完毕

在日志中输出该函数运行的时间

def filter_stocks(context)

筛选、排序股票，生成待交易股票列表

run_weekly(market_open,1,'10 00') 代码介绍

run_weekly(market_open,1,'10 00')

开盘后 10 00 进行开仓、调仓操作

run_weekly(filter_stocks,1,'09 30') 代码介绍

run_weekly(filter_stocks,1,'09 30')

筛选、过滤生成待买入股票列表为交易做准备

开盘时运行 filter_stocks() 函数

每周只在第一个交易日进行股票筛选、过滤、排序、开仓、调仓等操作

set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0003, close_commi

股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣 5 元钱

run_daily(stoploss, '9 45')

止损函数调用时间在开仓、调仓函数之前

经典小市值策略-10股-2010年至今

来自聚宽上我们自己的文章

标题：【详细注释】经典小市值策略

作者：加百力

导入函数库

from jqdata import

初始化函数，设置基准等等

08、context 是由系统维护的上下文环境

包含买入均价、持仓情况、可用资金等资产组合相关信息

def initialize(context

g. 开头的是全局变量

一经声明整个程序都可以使用

设置持股数量

g.stocknum = 10

待买入股票列表

g.buylist = []

设置沪深300股指作为基准

如果不设置，默认的基准也是沪深300股指

set_benchmark('000300.XSHG')

开启动态复权模式(使用真实价格)

set_option('use_real_price', True)

交易量不超过实际成交量的 0.1

set_option('order_volume_ratio', 0.1)

在日志中写入字符串

整个回测过程中，只会在开始阶段写入一次

log.info('初始函数开始运行且全局只运行一次')

过滤掉order系列API产生的比error级别低的log

默认是 'debug' 参数。最低的级别，日志信息最多

系统推荐尽量使用'debug'参数或不显式设置，方便找出所有错误

log.set_level('order', 'error')

设置滑点

0.02 的滑点设置还比较高

set_slippage(FixedSlippage(0.02))

止损函数在每个交易日的 9 45 都被调用一次

主要是为了尽量控制风险

回测历史数据时就是当时的日期时间

log.info(str('函数运行时间（filter_stocks）：' + str(context.current_dt.time())))

log.info(str('函数运行时间（filter_stocks）：' + str(context.current_dt.time()))) 代码介

获取当前时间的行情数据

获取当前单位时间（当天 当前分钟）的涨跌停价, 是否停牌，当天的开盘价等

回测时, 通过其他获取数据的API获取到的是前一个单位时间(天 分钟)的数据

而有些数据, 我们在这个单位时间是知道的, 比如涨跌停价, 是否停牌, 当天的开盘价

curr_data = get_current_data()

获取 上证综指和深证综指 的成份股

这个股票范围也很关键

如果换成其他一些股票指数的成分股，收益率可能大幅下降

过滤 开盘就涨停、跌停 的股票

过滤 当日暂停交易 的股票

过滤 含有 ST、 及退市标签 的股票

外围 [] 用于生成列表

内部是一个 for...in 表达式

针对 scu 股票列表中的每一只股票代码做分析过滤

括号里面是连续的 or 逻辑表达式，只要满足一个条件就为 True

小括号外面 not 取否。任何一个条件成立都会被过滤掉

[stock for stock in scu if not (

(curr_data[stock].day_open == curr_data[stock].high_limit) or

(curr_data[stock].day_open == curr_data[stock].low_limit) or

curr_data[stock].paused or

('ST' in curr_data[stock].name) or

('' in curr_data[stock].name) or

('退' in curr_data[stock].name)

获取市值最小的股票列表

query()生成一个 query 对象

query(valuation.code,valuation.market_cap) 查询 valuation 表的 股票代码、总市值 字段

filter(valuation.code.in_(scu))。过滤条件是股票代码必须在 scu 列表中。注意不是 in 而是 in_

order_by(valuation.market_cap.asc())。按照市值升序排列。小市值股票在前，大市值股票在后

limit(g.stocknum) 限制只取 g.stocknum 数量的股票

q = query(valuation.code,valuation.market_cap).filter(valuation.code.in_(scu)

get_fundamentals() 读取指定日期的股票查询数据

date = context.previous_date。对前一个交易日的股票数据做筛选、排序

读取结果以数据框的形式赋值给 df

df = get_fundamentals(q,date = context.previous_date)

将 df 数据框中的 code 列数据转换成列表类型数据

stocklist = list(df['code'])

将待买入股票列表赋值给全局变量

g.buylist = stocklist

止损函数

每天检查是否有股票触发止损条件

如有触发则立即卖出平仓

def stoploss(context)

使用 for 循环遍历 context.portfolio.positions 当前持仓的每一只股票

for stock in context.portfolio.positions

读取每只持仓股票的买入均价赋值给 cost 变量

cost = context.portfolio.positions[stock].avg_cost

cost = context.portfolio.positions[stock].avg_cost

读取每只持仓股票的当前价格

price = context.portfolio.positions[stock].price

price = context.portfolio.positions[stock].price 代码分析

计算每只持仓股票当前的收益率

ret = price cost-1

如果收益率小于 -0.2 表示浮亏已经突破 -20%

if ret 小于 -0.2

清仓该只股票

order_target() 将该只股票的持仓量调整为 0

order_target(stock,0)

在日志中写入 触发止损 这个字符串

log.info('触发止损')

分析了止损函数相关内容

context.portfolio.positions 看到他们的价值

context.portfolio.positions[stock].avg_cost 可能多次买入

context.portfolio.positions[stock].price

context 系统维护非常重要

log.info(str('函数运行时间（stoploss）' + str(context.current_dt.time())))

过滤函数是 9 点半运行

return

50、order_target_value(i, every_stock)

开盘时运行函数

def market_open(context)

在日志中写入函数运行时间

在日志中写入 函数 运行时间

str(context.current_dt.time())

str('函数运行时间（market_open）：'+str(context.current_dt.time()))

log.info() 写入日志中

如果待买入股票列表长度为 0，表示没有要操作的股票

则直接返回

len(g.buylist) == 0

if(len(g.buylist) == 0)

待买入股票列表中有要买入的股票

则调用 rebalance() 函数开仓或调仓

rebalance() 函数开仓或调仓

rebalance(context,g.buylist)

调仓 rebalance() 函数

第一个参数为上下文环境

第二个参数为待买入股票列表

def rebalance(context,buylist)

根据当前资产组合的价值，计算每只股票应持仓金额

context.portfolio.portfolio_value 除以 len(buylist)

every_stock = context.portfolio.portfolio_value 除以 len(buylist)

如果当前没有持仓就全部买入。等额分配资金

context.portfolio.positions.keys()

list(context.portfolio.positions.keys())

if len(list(context.portfolio.positions.keys())) == 0

for 循环对待买入列表中的每只股票都进行购买操作

for stock_to_buy in buylist

根据 every_stock 价值买入股票

根据 every_stock 价值 买入股票

如果有持仓，先卖出已经持有但不在待买入列表中的股票

卖出已经过时的股票

else 有持仓的情况

遍历每一只持仓股票代码

for stock_to_sell in list(context.portfolio.positions.keys())

如果这只股票代码不在买入列表中，说明已经过时应该清仓

if stock_to_sell not in buylist

清仓这只股票

股票的持仓价值额度为0

order_target_value(stock_to_sell, 0)

为buylist里的每支股票调整仓位

这句非常重要

一方面会买入当前未持仓的列表中的股票

另一方面也会影响其他持仓股票的仓位

低于资产组合平均价值的股票会加仓

高于资产组合平均价值的股票会减仓

实验证明调仓对于提高收益率很有帮助

for i in buylist

2-2 选股模块

导入模块

def initialize(context) 详细介绍

def get_factor_filter_list(context,stock_list,jqfactor,sort,p1,p2) 详细介绍

def get_stock_list(context) 详细介绍

def prepare_stock_list(context) 准备多个用于交易的股票列表

def weekly_adjustment(context) 每周调整仓位

def check_limit_up(context)

股票过滤函数，过滤 ST 股、有涨停的个股等等

def filter_limitup_stock(context, stock_list)

def filter_limitdown_stock(context, stock_list)

def filter_kcbj_stock(stock_list)

def filter_new_stock(context, stock_list, d) 过滤次新股

order_target_value_(security, value) 自定义下单函数

def open_position(security, value) 自定义开仓函数

def close_position(position) 自定义平仓函数

def print_position_info(context) 打印每日持仓信息

ETF二八轮动-2013年至今-沪深300-14点30

导入函数库

进行初始化设置

计算前 N 日涨幅

g.N = 10

两只股指ETF的收益率差距的阈值

g.rise_threshold = 0

产生信号和交易的时间

g.signal_time = '14 30'

股指ETF基金的持仓比例

g.ratio = 0.8

set_benchmark('000300.XSHG')

set_option('use_real_price',True)

log.set_level('order','error')

基金类交易手续费是

set_slippage(FixedSlippage(0),type='fund')

基金池：沪深300ETF，创业板ETF，国债ETF 黄金ETF等

基金池的规模比较大，多品种反复测试

首先使用指数测试，最后提交ETF版本

每月第一个交易日调用 CheckTrade() 函数

run_monthly(CheckTrade, 1, g.signal_time)

每个月第一个交易日处理

run_weekly(CheckTrade, 1, g.signal_time)

改成按周为单位运行，效果一般

按月线运行有 6 倍多的总收益率

def CheckTrade(context)

signal = create_signal(context, g.fund_list, g.N, g.rise_threshold)

在日志中记录交易信号

log.info('signal=%s', signal)

根据交易信号，交易股指ETF

trade(context, signal, g.fund_list, g.ratio)

余钱全部买债券ETF

trade_bond(context, g.fund_list, 1)

return 无返回值。返回结果

产生程序信号，返回 signal

def create_signal(context, fund_list, N, rise_threshold)

price_rise = [0,0]

计算基金数量

security_round_num = int(len(fund_list)除以2)

债券不参与计算信号标的

for i in range(security_round_num - 1)

stk = fund_list[i乘以2]

attribute_history 获取历史数据，可查询单个标的多个数据字段，返回数据格式为 DataFrame 或 Dict(字典)

只有两只 指数ETF 要查询，使用此函数很方便

查看某一支股票的历史数据, 可以选这只股票的多个属性, 默认跳过停牌日期

当取天数据时, 不包括当天的, 即使是在收盘后；分钟数据不包括当前分钟的数据，没有未来

这个API没有当天数据，没有未来函数

his_data = attribute_history(stk, N, '1d', ['close'], skip_paused=True)

price_rise[i] = his_data['close'][-1] 除以 his_data['close'][-N] - 1

log.info('fund%s, price_rise=%s, yesterday=%s, prev_N = %s'

两轮循环完成两只ETF基金的收益率计算

diff_price_rise = price_rise[0] - price_rise[1]

if diff_price_rise 大于 rise_threshold and price_rise[0] 大于 0

signal = 1

第二只ETF上涨较大。超过阈值，并且涨幅为正

第一只ETF上涨较大。超过阈值，并且涨幅为正

elif diff_price_rise 小于 -rise_threshold and price_rise[1] 大于 0

signal = 2

两只ETF都下跌

signal = 3

return signal

分析基金前 10 个交易日的行情数据，判断应该如何操作

根据交易信号，交易指定指数ETF

def trade(context, signal, security_round_list, ratio)

security_round_num = int(len(security_round_list) 除法 2)

context.portfolio.total_value

total_value：总的权益, 包括现金, 保证金(期货)或者仓位(股票)的总价值, 可用来计算收益

total_value = context.portfolio.total_value

log.info('current total value： %s', total_value)

卖出股指ETF操作

for i in range(security_round_num)

if i != (signal-1)

signal 为 1，清仓第 2 只基金

siganl 为 2 。第一只基金先平仓

signal为1，债券基金如何操作

siganl 为 2 。第一只基金先平仓

signal 为 2 。第二只基金不动

signal 为 2 时。债券基金处理分析

signal 为 3 时，第一、第二只基金都被平仓。第三只满仓

对应基金反而不处理，非对应的基金和第三只基金单独处理

signal 为 3 的时候第一、第二只基金被清仓

signal 为 1 时，对第一只基金按照 g.ratio 的比例买入

signal 为 2 时，对第二只基金按照 g.ratio 的比例买入

signal 为 3 时，上面已经返回不会进行下面的操作

根据 signal 的数值， 确定要操作的基金代码

stk = security_round_list[(signal-1) 2+1]

根据账户总权益和 g.ratio 的比例计算第一、第二只基金买入额度

target_value = context.portfolio.total_value g.ratio

根据计算的额度买入第一或第二只基金

order_value(stk, target_value)

买入了那只基金，额度是多少，写入日志

log.info('buy stk %s to target_value %s', stk, target_value)

第三只基金补充交易

signal 为 1 或 2 的时候，第一、第二只基金处理完毕。可能还有剩余资金

还有剩余资金

signal 为 3 时，前面的函数已经清空第一、第二只基金

有大量资金可以继续买入第三只基金

def trade_bond(context, security_round_list, ratio)

log.info('进入第三只基金补充交易函数')

获取基金数量信息

security_round_num = int(len(security_round_list) 2)

此时对应的时第三只基金

stk = security_round_list[security_round_num 2-1]

ratio 为 1

计算剩余资金的规模

cash = context.portfolio.available_cash ratio

所有剩余资金都买入第三只基金

order_value(stk, cash)

日志中记录购买第三只基金的名称和额度

log.info('buy bond %s, avail_cash %s', stk, cash)

前两只轮动，第三只避险

有大量基金代码可以组合实验.mp4

08-自由现金流-5股-2010年至今

导入函数模块

中性化、去极值化、标准化是模型特点

def initialize(context)

设置核心参数

初始化全局变量

全局变量应该在初始化函数中设置

查找全局变量，发现没有了

如果不设置滑点和交易成本则默认使用聚宽的设置

这样做的好处是，有利于对比不同算法的整体表现

每日获取昨日涨停股票列表

似乎加了 止损模块 反而收益率大幅下降了

每个月进行一次调仓操作

按周为单位运行也没问题

把昨日涨停今天没涨停的股票卖出

自由现金流模型对昨日涨停股票做单独处理

每月第一个交易日 16-00 收盘后在日志中输出市值、股价等数据

选股模块。根据财务要求和数据计算分析获取待交易股票列表

获取 365 天之前的日期。yesterday 还是用起来

生成初始股票列表

详细解释公式中用到的财务数据含义

读取满足条件的股票信息

对比值因子和roe因子做单独处理并加起来作为分数项

获取昨日涨停股票列表

调整持仓。平仓被淘汰的股票买入新股

集中过滤股票的代码不清晰

过滤停牌股票

过滤ST及其他具有退市标签的股票

过滤涨跌停股票

过滤科创板

交易模块-自定义下单

交易模块-开仓

交易模块-平仓

止损模块编写方法

g.stocks 并不是程序的一部分。直接删除

有止损版本

有止损模块的回测

有止损模块回测，实时分析图

无止损模块的回测结果更好

2015年一度回撤较大，但很快崛起

查看市值和股价信息，非小市值模型

调整昨日涨停股票

一年涨三倍以上牛股分析(最近6年)

导入所需的函数库

设置滚动天数和涨幅阈值参数

计算起始日期

获取起始日期时上市股票代码

获取当前日期

获取当前日期时上市的股票代码

输出起始和当前日期和股票数量

计算新增上市股票数量

days = [str(d)[ 冒号 10] for d in stk_price.index.values]

定义一个保存牛股的列表

zip() 将股票代码值（行索引）和股票名称值生成 zip 对象。用于for循环枚举

zip(now_stks.index.values

读取每只股票的价格数据

if len(stk_price) 小于 N_INCR_DAYS + 1

ROC() 变动率指标

roc = np.round(ROC(stk_price['close'].values, N_INCR_DAYS), 2)

np.nanmax() 取变动率中的最大值

生成 牛股 的交易日期字符串列表。为截取暴涨时间段做准备

输出上市公司名称和 days 数据观察

返回包含 na 的收益率数据中最大值的索引

loc = np.nanargmax(roc)

bull_stks 是由单个牛股列表组成的大列表

单个牛股列表包含：股票代码、股票名称、价格起点、价格终点、收益率

特别注意：价格起点未必是 行情启动点

完全可能出现价格起点之后，跌的更重，然后反弹最终超过涨幅阈值的情况

bull_stks += [[stk, stk_name, days[loc - N_INCR_DAYS], days[loc], roc[loc]]]

cols = ['代码', '名称', '起始', '终止', '涨幅']

bull_stks = pd.DataFrame(bull_stks, columns=cols)

bull_stks 调用 sort_valuse() 方法排序

bull_stks.sort_values(by=['涨幅'], ascending=False, inplace=True)

bull_stks.index.values[ ] = np.arange(1,len(bull_stks) + 1)

输出牛股数量和涨幅中位数

输出全部牛股信息

将牛股数据保存在 CSV 文件中

输出结果展示

print(bull_stks.head(40))

print( bull_stks.head(40) )

bull_stks[bull_stks['起始'].values 大于等于 '2021-01-01']

rows = len(stks2021)

输出2021年以来的牛股数据框

print(stks2021.to_string())

2021年以来共有 79 只股票，一年涨幅达到3倍及以上

10-期货-多品种-双均线-ATR

导入函数库

def initialize(context)

设定账户为期货账户

期货类每笔交易时的手续费

删除手续费设置，还是正常交易

删除保证金比列设置。使用系统默认设置

开盘时运行

收盘后运行

def set_info(context)

参数设置

交易的期货品种信息

set_future_list(context)

遍历待交易期货品种列表中的每一个品种

idx = get_future_code(ins)

dom = get_dominant_future(ins)

g.MappingIndex[ins] = idx

g.MappingReal[ins] = dom

把主力合约名称加入到期货列表中

将新的主力合约加入列表中

开盘时运行函数

遍历待交易期货品种，分析主力合约是否切换

计算、分析交易信号并做交易

初始化指数和主力合约数据，做初步判断

计算两条均线的数据

判断当前 快线、慢线 的交叉情况

收盘后输出当天的成交记录

处理交易的函数

发现了一个非常隐蔽的 BUG

def Trade(context,RealFuture)

context.portfolio.short_positions[RealFuture].total_amount

移仓换月模块逻辑

def replace_old_futures(context,ins,dom)

如果旧合约名称出现在空头持仓中

通过字典数据将 期货品种字符串 与 品种指数 对应起来

def get_future_code(symbol)

交易所信息不同。需要查表解决

def get_lots(context,symbol)

future_Contract_Size

计算交易手数，并且取整

def get_CCFX_end_date(future_code)

11-小零花-沪金周五做多 模型- 原始版

import datetime as dt

import matplotlib.pyplot as plt

因为是 日内交易，收盘平仓 使用 主连合约 没有问题

start_date = '2008-1-9'

end_date = dt.datetime.now()

weekday = 5

读取沪金主连合约的历史行情数据

au_df = get_price(symbol

计算有多少个交易日

以当日开盘价开多单，收盘价平仓

从 DatetimeIndex 中提取星期几数据

au_df['wd']= au_df.index.dayofweek + 1

au_df = au_df[ au_df['wd'] == weekday ]

减去 0.01 是为了扣除开仓手续费

au_df.to_csv('小零花-沪金周五做多模型.csv', float_format='%.2f', encoding='utf-8')

trade_times = len(au_df)

计算盈利交易次数

计算盈利概率

输出沪金做多盈利概率

计算总的盈利金额

print('总盈利：',win_value

计算总的亏损金额

print('总亏损：',lose_value

计算总的盈亏比

计算累计盈亏

计算亏损交易次数

计算单笔盈亏比

单笔交易的盈亏比并不高

plt.figure(dpi=200)

x = au_df.index

y = au_df['delt'].cumsum() 1000

plt.title('小零花-沪金周五做多 模型')

plt.xlabel('年份')

plt.ylabel('累计盈亏金额(一手)')

plt.plot(x, y)

plt.show()

open_low_times = len(au_df[ au_df['open'] == au_df['low'] ])

开盘价就是最低价共出现

绘制散点图

plt.scatter(x, y,c='red',s=0.3)

为什么不设置止损？

如果要设止损，应该参考什么标准比较合适？

是固定止损更好，还是追踪止损更好？

头寸规模如何动态调整，以适应账户盈亏变化？

一定要在开盘时进场吗？

一定要在收盘时出场吗？如果处于浮亏有没有办法解决？

有没有办法继续提高胜率和盈亏比？

一定要每个周五都进场吗？

如果将来这个模型完全失效。周五下跌行情比较多怎么办？

沪金是否在其他日期也有类似效应？

其他品种是否也有类似效应？

天蝎座-除夕-2021年至今

天蝎座-除夕-编译运行，查看情况

导入函数库是基本操作

初始化函数进行系统参数设置

设置每日买入或卖出股票的时间

买入、卖出函数简介

处理日期相关函数

过滤函数

每日初始股票池和相关处理函数

date = transform_date(context.previous_date, 'str')

昨日涨停列表

前一日有涨停股票的要进行处理

获取非连板涨停的股票列表

计算相对位置

读取股票历史数据

计算今日开盘价相对于昨日收盘价的变化率

低开越多风险越大，选择3个多点即可

买入低开股票

def sell(context) 卖出股票操作

获取基础的日期和股票行情数据

上午收盘前卖出有浮盈但又没有涨停的股票