聚宽策略分享-1年化98国九条后中小板微盘小改

文章声明:本内容为个人的业余研究，和任何单位，机构没有关系，文章出现的股票代码，全部只是测试例子，不做投资参考，投资有风险，代码学习使用，不做商业用途，

聚宽上面有很多策略非常不错，可以利用跟单系统跟踪交易，做一个策略分享的集合，学习使用，网页我上线了，跟单系统，大qmt的，明天给怎么样实盘的教程

mini的量化研究---强大索普量化交易网页使用教程

分享的策略集合

我们看一下策略的回测结果，更长的时间自己测试

策略的原理分析

这是一个以"国九条"（中国资本市场改革政策）为背景，面向中小盘股（以中小板指数 399101.XSHE 为基准）的高换手、市值轮动、严格风控的量化交易策略。其核心目标是捕捉中小市值股票的短期波动机会，并通过多层次的规则来规避风险和锁定收益。策略的逻辑架构可以从以下几个方面进行详细分析：

一、核心投资逻辑与选股理念

市值下沉与"微盘"风格 ：策略明确将股票池限定在总市值 10亿至100亿 的范围内，并按市值升序排列（order_by(valuation.market_cap.asc())），优先买入市值最小的几只股票。这本质上是一种"微盘股"或"小市值因子"投资，理论基础是A股历史上小盘股长期存在超额收益（小盘股效应），且流动性较弱，价格易受资金推动产生较大波动。
响应"国九条"政策导向：在选股中加入了符合"国九条"精神的财务质量过滤：
- 剔除近一年净利润为负的股票。
- 剔除营业收入低于1亿元的股票。
- 剔除了审计意见为负面或无法表示意见的股票（可选）。
- 这些过滤旨在规避基本面恶化、有退市风险或财务质量差的"壳股"，使策略更贴合监管层鼓励价值投资、提高上市公司质量的方向。

二、策略运行的主要流程与模块

策略运行以周度（每周二） 为主要调仓周期，日内有多次检查和操作。

盘前准备（prepare_stock_list， 9:05）：
- 识别昨日持仓中涨停的股票 ，加入观察列表（g.yesterday_HL_list）。
- 判断当日是否为可交易日（基于月份过滤逻辑）。
周度核心调仓（weekly_adjustment，每周二10:00）：
- 卖出：卖出所有不在目标持仓列表 中且昨日未涨停的持仓股。
- 买入：买入所有在目标持仓列表中但尚未持有的股票。
- 动态调整持股数量 ：根据中小板指数（399101）收盘价与其10日均线的偏离程度，动态决定本周持股数量（3-6只）。指数低于均线越多（市场越弱），持股数量越多（分散风险）；指数高于均线越多（市场越强），持股数量越少（集中进攻）。这是一种简单的市场状态自适应机制。
- 生成目标股票池 ：调用get_stock_list函数，经过市值筛选、财务质量过滤、价格过滤（单价不超过50元）、次新股过滤（上市满375天）、非ST/非停牌过滤后，选出符合条件的最小市值股票列表，并取前g.stock_num只作为本周目标持仓。
- 执行调仓：
- 空仓月份处理：如果根据月份规则判断为空仓期，则清仓股票，全仓买入货币ETF（银华日利511880）。
盘中监控与调整（trade_afternoon， 14:00）：
- 涨停板管理 ：对于昨日涨停的持仓股，持续监控其今日价格。如果在下午2点前打开涨停板，则立即卖出；若仍封死涨停，则继续持有，享受可能的连板收益。这是策略捕捉短期动量、锁定涨停收益的关键规则。
- 现金再平衡 ：检查因止损、涨停板卖出或调仓失败导致的现金闲置，并用这些现金补仓目标股票池中尚未买入的股票（补足至目标持股数）。若有因止损产生的现金，则买入货币ETF，体现了风险规避后先求稳的思路。
风险管理与止损（stop_loss， 10:00）：
- 个股止损/止盈 ：对每只持仓股，若亏损达到 9% （g.stoploss_limit）则坚决止损；若盈利达到 100% 则止盈卖出。这是控制单笔交易最大回撤、锁定丰厚利润的经典手段。
- 市场趋势止损 ：计算中小板指数所有成分股开盘至昨收的平均跌幅。若平均跌幅超过 5% （g.stoploss_market），则视为市场系统性大跌，将清空所有股票持仓，以规避极端市场风险。
收盘前清理（close_account， 14:50）：
- 在判断为空仓的月份，于收盘前强制卖出所有非货币ETF的持仓，确保"空仓"逻辑得到严格执行。

三、策略的关键特性与创新点

"涨停持有-开板即卖"规则：这是策略的一大亮点。它不完全遵循周度调仓，而是给予强势股（涨停股）特殊的持有待遇，试图捕捉短期的连续上涨行情，增强了策略的进攻性。
多层次、多维度的风险控制：
- 个股层面：严格的9%止损线。
- 组合层面：根据市场趋势动态调整持股数量。
- 市场层面：5%的系统性大跌清仓规则。
- 时间层面：在预设的月份（如1月、4月，可能与财报季、政策窗口期有关）进行选择性空仓。
- 标的层面：通过财务指标和审计意见过滤垃圾股。
市值轮动与完全再平衡 ：策略每周都重新筛选当前市值最小的一批股票，并调整至等权配置。这意味着它不断卖出已上涨（可能市值变大）的股票，买入新进入最小市值区间的股票，完成了完整的"高抛低吸"和市值轮动循环。
对流动性和交易限制的务实处理：过滤了涨跌停、停牌、ST股票，并在收盘前为空仓月份处理卖不掉的股票（跌停股除外）提供了预案，增强了策略在实际交易中的可行性。

四、策略可能存在的风险与考量

小市值因子失效风险：策略高度依赖小盘股的超额收益。如果市场风格彻底转向大盘蓝筹（如"漂亮50"行情），或监管政策导致微盘股流动性枯竭、估值体系重构，策略可能长期表现不佳。
高换手与交易成本：周度调仓加上盘中交易，换手率极高。虽然设置了较低的交易佣金（万2.5），但冲击成本和滑点（策略设置了固定万3滑点）在实盘中仍可能显著侵蚀收益。
过拟合风险：策略中包含了大量参数（如市值区间、持股数量范围、止损止盈阈值、空仓月份、均线参数等）。这些参数在历史回测中可能被优化至最佳状态，但在未来市场环境变化时可能失效。
容量限制：由于聚焦于市值10-100亿的小盘股，策略的资金容量有限。大资金入场容易产生较大的冲击成本，并可能因买入行为推高股价而影响策略逻辑本身。
极端行情下的流动性风险：在市场恐慌性下跌时，小盘股更容易出现跌停而无法卖出的情况，此时止损规则可能无法执行，导致实际亏损超过预设值。

总结来说，这是一个风格鲜明、规则复杂且进攻性较强的中小盘量化策略。它通过严格的市值筛选、财务过滤和独特的涨停板管理来创造alpha，同时又通过多层级的动态风控机制（个股止损、市场止损、月份空仓、持股数调整）来严密守护下行风险。其本质是试图在"小市值溢价"和"高质量财务"的交集中，通过高频轮动和严格的交易纪律，实现高夏普比率和高收益的目标。然而，其高换手、强依赖市场风格的特性，也要求投资者必须对其潜在风险有充分认知。

源代码我全部上传了，可以直接下载使用

python 复制代码

# 克隆自聚宽文章：https://www.joinquant.com/post/47946
# 标题：国九条后中小板微盘小改，年化135.40%
# 作者：子匀

from jqdata import *
from jqfactor import *
import numpy as np
import pandas as pd
from datetime import time,date
from jqdata import finance

#初始化函数 
def initialize(context):
    # 开启防未来函数
    set_option('avoid_future_data', True)
    # 成交量设置
    #set_option('order_volume_ratio', 0.10)
    # 设定基准
    set_benchmark('399101.XSHE')
    # 用真实价格交易
    set_option('use_real_price', True)
    # 将滑点设置为0
    set_slippage(FixedSlippage(3/10000))
    # 设置交易成本万分之三，不同滑点影响可在归因分析中查看
    set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=2.5/10000, close_commission=2.5/10000, close_today_commission=0, min_commission=5),type='stock')
    # 过滤order中低于error级别的日志
    log.set_level('order', 'error')
    log.set_level('system', 'error')
    log.set_level('strategy', 'debug')
    #初始化全局变量 bool
    g.trading_signal = True  # 是否为可交易日
    g.run_stoploss = True  # 是否进行止损
    g.filter_audit = False  # 是否筛选审计意见
    g.adjust_num = True  # 是否调整持仓数量
    #全局变量list
    g.hold_list = [] #当前持仓的全部股票    
    g.yesterday_HL_list = [] #记录持仓中昨日涨停的股票
    g.target_list = []
    g.pass_months = [1, 4]  # 空仓的月份
    g.limitup_stocks = []   # 记录涨停的股票避免再次买入
    #全局变量float/str
    g.min_mv = 10  # 股票最小市值要求
    g.max_mv = 100  # 股票最大市值要求
    g.stock_num = 4  # 持股数量

    g.stoploss_list = []  # 止损卖出列表
    g.other_sale    = []  # 其他卖出列表
    g.stoploss_strategy = 3  # 1为止损线止损，2为市场趋势止损, 3为联合1、2策略
    g.stoploss_limit = 0.09  # 止损线
    g.stoploss_market = 0.05  # 市场趋势止损参数
    g.highest = 50  # 股票单价上限设置
    g.money_etf = '511880.XSHG'  # 空仓月份持有银华日利ETF
    # 设置交易运行时间
    run_daily(prepare_stock_list, '9:05')
    run_daily(trade_afternoon, time='14:00', reference_security='399101.XSHE') #检查持仓中的涨停股是否需要卖出
    run_daily(stop_loss, time='10:00') # 止损函数
    run_daily(close_account, '14:50')
    run_weekly(weekly_adjustment,2,'10:00')
    #run_weekly(print_position_info, 5, time='15:10', reference_security='000300.XSHG')

#1-1 准备股票池
def prepare_stock_list(context):
    #获取已持有列表
    g.limitup_stocks = []
    g.hold_list = list(context.portfolio.positions)
    #获取昨日涨停列表
    if g.hold_list:
        df = get_price(g.hold_list, end_date=context.previous_date, frequency='daily', fields=['close','high_limit','low_limit'], count=1, panel=False, fill_paused=False)
        df = df[df['close'] == df['high_limit']]
        g.yesterday_HL_list = df['code'].tolist()
    else:
        g.yesterday_HL_list = []
    #判断今天是否为账户资金再平衡的日期
    g.trading_signal = today_is_between(context)

#1-2 选股模块
def get_stock_list(context):
    final_list = []
    MKT_index = '399101.XSHE'
    initial_list = filter_stocks(context, get_index_stocks(MKT_index))
    # 国九更新：过滤近一年净利润为负且营业收入小于1亿的
    # 国九更新：过滤近一年期末净资产为负的 (经查询没有为负数的，所以直接pass这条)
    # 国九更新：过滤近一年审计建议无法出具或者为负面建议的 (经过净利润等筛选，审计意见几乎不会存在异常)
    q = query(
        valuation.code,
    ).filter(
        valuation.code.in_(initial_list),
        valuation.market_cap.between(g.min_mv,g.max_mv),  # 总市值 circulating_market_cap/market_cap 单位：亿元
        income.np_parent_company_owners > 0,   # 归属于母公司所有者的净利润(元)
        income.net_profit > 0,  # 净利润(元)
        income.operating_revenue > 1e8  # 营业收入 (元)
    ).order_by(valuation.market_cap.asc()).limit(g.stock_num*3)
    df = get_fundamentals(q)
    # 如果筛选审计意见会大幅度增加回测时长，实测增加此项筛选不影响选股
    if g.filter_audit:
        before_audit_filter = len(df)
        df['audit'] = df['code'].apply(lambda x: filter_audit(context, x))
        df_audit = df[df['audit'] == True]
        log.info('去除掉了存在审计问题的股票{}只'.format(len(df)-before_audit_filter))
    final_list = df['code'].tolist()

    if final_list:
        last_prices = history(1, unit='1d', field='close', security_list=final_list)
        return [stock for stock in final_list if stock in g.hold_list or last_prices[stock][-1] <= g.highest]
    else:
        # 由于有时候选股条件苛刻，所以会没有股票入选，这时买入银华日利ETF
        log.info('无适合股票，买入ETF')
        return [g.money_etf]        

#1-3 整体调整持仓
def weekly_adjustment(context):
    if g.trading_signal:
        if g.adjust_num:
            new_num = adjust_stock_num(context)
            g.stock_num = new_num
            log.info(f'持仓数量修改为{new_num}')
        g.target_list = get_stock_list(context)[:g.stock_num]
        log.info(str(g.target_list))

        sell_list = [stock for stock in g.hold_list if stock not in g.target_list and stock not in g.yesterday_HL_list]
        hold_list = [stock for stock in g.hold_list if stock in g.target_list or stock in g.yesterday_HL_list]
        log.info("卖出[%s]" % (str(sell_list)))
        log.info("已持有[%s]" % (str(hold_list)))

        for stock in sell_list:
            order_target_value(stock, 0)

        buy_list = [stock for stock in g.target_list if stock not in g.hold_list]
        buy_security(context, buy_list,len(buy_list))

    else:
        buy_security(context, [g.money_etf],1)
        log.info('该月份为空仓月份，持有银华日利ETF')


#1-4 调整昨日涨停股票
def check_limit_up(context):
    now_time = context.current_dt
    if g.yesterday_HL_list != []:
        #对昨日涨停股票观察到尾盘如不涨停则提前卖出，如果涨停即使不在应买入列表仍暂时持有
        for stock in g.yesterday_HL_list:
            current_data = get_price(stock, end_date=now_time, frequency='1m', fields=['close','high_limit'], skip_paused=False, fq='pre', count=1, panel=False, fill_paused=True)
            if current_data.iloc[0,0] <    current_data.iloc[0,1]:
                log.info("[%s]涨停打开，卖出" % (stock))
                order_target_value(stock, 0)
                g.other_sale.append(stock)
                g.limitup_stocks.append(stock)
            else:
                log.info("[%s]涨停，继续持有" % (stock))

#1-5 如果昨天有股票卖出或者买入失败造成空仓，剩余的金额当日买入
def check_remain_amount(context):
    addstock_num = len(g.other_sale)
    loss_num = len(g.stoploss_list)
    empty_num = addstock_num + loss_num

    g.hold_list = context.portfolio.positions
    if len(g.hold_list) < g.stock_num:   
        # 计算需要买入的股票数量，止损仓位补足货币etf
        # 可替换下一行代码以更换逻辑：改为将清空仓位全部补足股票，而非原作中止损仓位补充货币etf
        # num_stocks_to_buy = min(empty_num,g.stock_num-len(g.hold_list))
        num_stocks_to_buy = min(addstock_num,g.stock_num-len(g.hold_list))
        target_list = [stock for stock in g.target_list if stock not in g.limitup_stocks][:num_stocks_to_buy]
        log.info('有余额可用'+str(round((context.portfolio.cash),2))+'元。买入'+ str(target_list))
        buy_security(context,target_list,len(target_list))
        if loss_num !=0:
            log.info('有余额可用'+str(round((context.portfolio.cash),2))+'元。买入货币基金'+ str(g.money_etf))
            buy_security(context,[g.money_etf],loss_num)

    g.stoploss_list = []
    g.other_sale    = []

#1-6 下午检查交易
def trade_afternoon(context):
    if g.trading_signal:
        check_limit_up(context)
        check_remain_amount(context)
        buy_security(context,[g.money_etf],1)

#1-7 止盈止损
def stop_loss(context):
    if g.run_stoploss:
        current_positions = context.portfolio.positions
        if g.stoploss_strategy == 1 or g.stoploss_strategy == 3:
            for stock in current_positions.keys():
                price = current_positions[stock].price
                avg_cost = current_positions[stock].avg_cost
                # 个股盈利止盈
                if price >= avg_cost * 2:
                    order_target_value(stock, 0)
                    log.debug("收益100%止盈,卖出{}".format(stock))
                    g.other_sale.append(stock)
                # 个股止损
                elif price < avg_cost * (1 - g.stoploss_limit):
                    order_target_value(stock, 0)
                    log.debug("收益止损,卖出{}".format(stock))
                    g.stoploss_list.append(stock)

        if g.stoploss_strategy == 2 or g.stoploss_strategy == 3:
            stock_df = get_price(security=get_index_stocks('399101.XSHE')
                        ,end_date=context.previous_date, frequency='daily'
                        ,fields=['close', 'open'], count=1, panel=False)
            # 计算成分股平均涨跌，即指数涨跌幅
            down_ratio = (1 - stock_df['close'] / stock_df['open']).mean()
            # 市场大跌止损
            if down_ratio >= g.stoploss_market:
                g.stoploss_list.append(stock)
                log.debug("大盘惨跌,平均降幅{:.2%}".format(down_ratio))
                for stock in current_positions.keys():
                    order_target_value(stock, 0)


#1-8 动态调仓代码
def adjust_stock_num(context):
    ma_para = 10  # 设置MA参数
    today = context.previous_date
    index_df = get_price('399101.XSHE', end_date=today,count = ma_para,fields = 'close', frequency='daily')
    ma = index_df['close'].mean()
    last_row = index_df['close'].iloc[-1]
    diff = last_row - ma
    # 根据差值结果返回数字
    result = 3 if diff >= 500 else \
             3 if 200 <= diff < 500 else \
             4 if -200 <= diff < 200 else \
             5 if -500 <= diff < -200 else \
             6
    return result


#2 过滤各种股票
def filter_stocks(context, stock_list):
    current_data = get_current_data()
        # 涨跌停和最近价格的判断
    last_prices = history(1, unit='1m', field='close', security_list=stock_list)
        # 过滤标准
    filtered_stocks = []
    for stock in stock_list:
        if current_data[stock].paused:  # 停牌
            continue
        if current_data[stock].is_st:  # ST
            continue
        if '退' in current_data[stock].name:  # 退市
            continue
        if stock.startswith('30') or stock.startswith('68') or stock.startswith('8') or stock.startswith('4'):  # 市场类型
            continue
        if not (stock in context.portfolio.positions or last_prices[stock][-1] < current_data[stock].high_limit):  # 涨停
            continue
        if not (stock in context.portfolio.positions or last_prices[stock][-1] > current_data[stock].low_limit):  # 跌停
            continue
        # 次新股过滤
        start_date = get_security_info(stock).start_date
        if context.previous_date - start_date < timedelta(days=375):
            continue
        filtered_stocks.append(stock)
    return filtered_stocks

#2.1 筛选审计意见
def filter_audit(context, code):
    # 获取审计意见，近三年内如果有不合格(report_type为2、3、4、5)的审计意见则返回False，否则返回True
    lstd = context.previous_date
    last_year = lstd.replace(year=lstd.year - 3, month=1, day=1)
    q=query(finance.STK_AUDIT_OPINION.code, finance.STK_AUDIT_OPINION.report_type
          ).filter(finance.STK_AUDIT_OPINION.code==code,finance.STK_AUDIT_OPINION.pub_date>=last_year)
    df=finance.run_query(q)
    df['report_type'] = df['report_type'].astype(str)
    contains_nums = df['report_type'].str.contains(r'2|3|4|5')
    return not contains_nums.any()


#3-4 买入模块
def buy_security(context,target_list,num):
    #调仓买入
    position_count = len(context.portfolio.positions)
    target_num = num
    if target_num !=0:
        value = context.portfolio.cash / target_num
        for stock in target_list:
            order_target_value(stock, value)
            log.info("买入[%s]（%s元）" % (stock,value))
            if len(context.portfolio.positions) == g.stock_num:
                break


#4-1 判断今天是否跳过月份
def today_is_between(context):
    # 根据g.pass_month跳过指定月份
    month = context.current_dt.month
    # 判断当前月份是否在指定月份范围内
    if month in g.pass_months:
        code = '399303.XSHE'
        close = history(count = 3, unit='1d', field='close', security_list= [code], df = False, skip_paused = False, fq = 'none')[code]
        if close[-1] > close[-2] * 0.995 and close[-1] > close[-3] * 0.994:
            return True
        # 判断当前日期是否在指定日期范围内
        return False
    else:
        return True

def close_account(context):
    if not g.trading_signal:
        curr_data = get_current_data()
        if len(g.hold_list) != 0 and g.hold_list != [g.money_etf]:
            for stock in g.hold_list:
                if stock == g.money_etf:
                    continue
                if curr_data[stock].last_price == curr_data[stock].low_limit or curr_data[stock].paused:
                    continue
                order_target_value(stock, 0)
                log.info("卖出[%s]" % (stock))

def print_position_info(context):
    for position in list(context.portfolio.positions.values()):
        securities=position.security
        cost=position.avg_cost
        price=position.price
        ret=100*(price/cost-1)
        value=position.value
        amount=position.total_amount    
        print('代码:{}'.format(securities))
        print('成本价:{}'.format(format(cost,'.2f')))
        print('现价:{}'.format(price))
        print('收益率:{}%'.format(format(ret,'.2f')))
        print('持仓(股):{}'.format(amount))
        print('市值:{}'.format(format(value,'.2f')))
    print('---------------------------------------------------------------------------------------------------------------------分割线------------------------------------------------------------------------------------------------------------------')