我的想法略有不同，先排除了筛选范围内的ST，退市和停牌股，然后再做选择，保证每次都能选出n支可交易的股票。 ``` def initialize(context): run_daily(period,'every_bar') g.stocksnum = 3 # g.stock_last_list = get_stock() g.period = 7 g.day = 0 def paused_filter(security_list): current_data = get_current_data() security_list = [stock for stock in security_list if not current_data[stock].paused] return security_list def delisted_filter(security_list): current_data = get_current_data() security_list = [stock for stock in security_list if not '退' in current_data[stock].name] return security_list def st_filter(security_list): current_data = get_current_data() security_list = [stock for stock in security_list if not current_data[stock].is_st] return security_list def get_stock(): sc = get_index_stocks('000001.XSHG')+get_index_stocks('399106.XSHE') sc_filter_pd = paused_filter(sc) sc_filter_pdst = st_filter(sc_filter_pd) sc_filter_pdstd = delisted_filter(sc_filter_pdst) q = query(valuation.code).filter(valuation.code.in_(sc_filter_pdstd)).order_by(valuation.market_cap.asc()).limit(g.stocksnum) dq = get_fundamentals(q) return list(dq.code) def period(context): # q = query(valuation.code).order_by(valuation.market_cap.asc()).limit(g.stocksnum) # dq = get_fundamentals(q) if g.day%g.period == 0: stock = get_stock() print(stock) for i in context.portfolio.positions: if i not in stock: order_target(i,0) print('%s is not in stock' % i) Mvalue = context.portfolio.available_cash/g.stocksnum print(Mvalue) for i in stock: if i in stock: print('%s is in stock' % i) order_value(i,Mvalue) print(context.portfolio.positions) g.day = g.day + 1 ```

@肉丸汤 代码写得不错

@TerryZhang 请问参数5和3您是怎么调出来的？

思考g.period，g.stocksnum各自设为多少效果比较好？ 请问这个问题有谁思考？思考的结果是什么？

def initialize(context): run_daily(period,time='every_bar') #设置选股数量，仓位调整周期 g.stocksnum=3 g.times=7 g.circle=0 def period(context): #判断当前账户股票收益与损失大与5%止盈，损失大与10%止损 for j in context.portfolio.positions: cost=context.portfolio.positions[j].avg_cost price=context.portfolio.positions[j].price t=price/cost-1 if (t>=0.05)or(t< =-0.1): order_target(j,0) # if g.circle%g.times==0: stockslist=get_index_stocks("000001.XSHG")+get_index_stocks("399106.XSHE") q=query(valuation.code).filter(valuation.code.in_(stockslist)).order_by(valuation.market_cap.asc()).limit(g.stocksnum) df=get_fundamentals(q) lists=list(df['code']) for i in context.portfolio.positions: if i not in lists: order_target(i,0) avlaiblem=context.portfolio.available_cash/10 for j in lists: order(j,avlaiblem) g.circle=g.circle+1

@肉丸汤 过滤 st/paused/delist 的函数很不错，借鉴了。 最后一个for循环中的 if i in stock 多余了，可以删除。

``` # from https://www.joinquant.com/view/community/detail/7fe7e01ebbe6082101b4c57a4daaac57 # 量化策略学习 from jqdata import * def initialize(context): run_daily(period,time='every_bar') # 代码：设定好要交易的股票数量stocksnum g.stocksnum = 10 g.period = 5 # 每30天操作一次 g.days = 1 # 运行天数计数器 ''' 对选出的股票进行过滤 @param del_paused: 是否剔除停牌股票 @param del_st: 是否剔除st股票 @param del_delist：是否剔除退市股票 @ret 返回一个list类型的股票代码列表 ''' def stock_filter(stock_list, del_paused=False, del_st=False, del_delist=False): current_data = get_current_data() if del_paused: stock_list = [stock for stock in stock_list if not current_data[stock].paused] if del_st: stock_list = [stock for stock in stock_list if not current_data[stock].is_st] if del_delist: stock_list = [stock for stock in stock_list if not '退' in current_data[stock].name] # 可以扩展加入黑名单，比如欺诈发行的、业绩暴雷的，直接规避掉 black_list = [] stock_list = list(set(stock_list) - set(black_list)) return stock_list ''' 获取查询的股票池 ''' def get_stocks(): # 获取上证指数和深证综指的成分股代码并连接，即为全A股市场所有股票的股票代码 # 用加号可以连接两个list scu = get_index_stocks('000001.XSHG')+get_index_stocks('399106.XSHE') stock_list = stock_filter(scu, del_paused=True, del_st=True, del_delist=True) return stock_list ''' 止损 ''' def stop_loss(context): for stock in context.portfolio.positions: price = context.portfolio.positions[stock].price cost = context.portfolio.positions[stock].avg_cost if (price / cost - 1) < -0.15: if order_target(stock, 0): log.error("股票：%s 触发止损：" % (stock)) def period(context): ## 运行到 g.period 天，开始操作 if g.days % g.period == 0: # 代码：找出市值排名最小的前stocksnum只股票作为要买入的股票 scu = get_stocks() q = query(valuation.code)\ .filter(valuation.code.in_(scu), valuation.market_cap > 20)\ .order_by(valuation.market_cap.asc())\ .limit(g.stocksnum) df = get_fundamentals(q) lowcap_list = list(df['code']) portfolio_list = context.portfolio.positions buy_list = set(lowcap_list) - set(portfolio_list) sell_list = set(portfolio_list) - set(lowcap_list) for stock in list(sell_list): # 要考虑一种情况：停牌的股票无法卖出，导致buy清单每只股票可投入资金减少 order_target(stock, 0) # 代码：若已持有的股票的市值已经不够小而不在要买入的股票中，则卖出这股票。 # 代码：买入要买入的股票，买入金额为可用资金的stocksnum分之一 cash = context.portfolio.available_cash / len(buy_list) for stock in list(buy_list): # 要考虑一种情况：集合竞价涨停的股票无法买入。处理办法：无法买入则忽略 order_value(stock, cash) # 每日进行止损，不止盈 stop_loss(context) g.days += 1 ```

@mortred 思考此文中，虽然每次都等资金的买入，为何各股票的持仓价值其实还是不同，而且可能越差越大？ 问题出在卖出时，有些停牌的股票卖不掉，导致每只股票可投入资金减少（可用资金/g.stocksnum中可用资金变少了)。

@TerryZhang 换个回撤时间结果也会差很多

*#综合之前所学写一个策略* def initialize(context): run_daily(period,time='every_bar') # 代码：设定好要交易的股票数量stocksnum g.stocksnum = 7 g.period = 13 g.day = 0 g.per = 0.1 #止盈或止损率 def stop_loss_or_profit(context): #止盈或止损 for stock in context.portfolio.positions: if (context.portfolio.positions[stock].price/ \ context.portfolio.positions[stock].avg_cost-1>g.per): order_target(stock,0) if context.portfolio.positions[stock].total_amount == 0: log.info('股票 %s 已经止盈' % stock) continue if (context.portfolio.positions[stock].price/ \ context.portfolio.positions[stock].avg_cost-1< -g.per): order_target(stock,0) if context.portfolio.positions[stock].total_amount == 0: log.info('股票 %s 已经止损' % stock) def filter_st(stock_list): #过滤ST、停牌、涨停股 curr_data = get_current_data() stock_list = [stock for stock in stock_list if \ (not curr_data[stock].paused) and (not curr_data[stock].is_st) and ('ST' not in curr_data[stock].name) and ('*' not in curr_data[stock].name) and (not curr_data[stock].day_open >= curr_data[stock].high_limit) ] return stock_list def period(context): #如果达到一定的盈利或亏损，则清空仓位 stop_loss_or_profit(context) if g.day % g.period == 0: # 代码：找出市值排名最小的前stocksnum只股票作为要买入的股票 stocks_SHG = get_index_stocks('000001.XSHG') stocks_SHE = get_index_stocks('399106.XSHE') stocks = stocks_SHG + stocks_SHE # print(stocks) stocks = filter_st(stocks) #过滤ST、停牌、涨停股 q = query(valuation.code,valuation.market_cap ).filter(valuation.code.in_(stocks) ).order_by(valuation.market_cap.asc() ).limit(g.stocksnum) w = get_fundamentals(q) buylist = list(w['code']) print(buylist) print(context.portfolio.available_cash) # 代码：若已持有的股票的市值已经不够小而不在要买入的股票中，则卖出这些股票。 for stock in context.portfolio.positions: # print(stock) if stock not in buylist: order_target(stock,0) # print(stock) # 代码：买入要买入的股票，买入金额为可用资金的stocksnum分之一 buy_cash = context.portfolio.available_cash/g.stocksnum print(buy_cash) for stock in buylist: order_value(stock,buy_cash) print(context.portfolio.available_cash) g.day = g.day + 1

问：思考此文中，虽然每次都等资金的买入，为何各股票的持仓价值其实还是不同，而且可能越差越大 答：每次买入，都是买入可用资金按股票支数的平均值，并不会考虑持仓价值

@肉丸汤 确实应该先从池子里先排除st、停牌、涨停的股票。先取最小市值，发现st等删除，按道理还应该再充其他的票进来

@mortred 我认为还有一个原因会使筹码集中度提高，现在的代码逻辑，是只要有剩余资金拆分为固定的10份买入，一直处于市值最小市值列表的股票，会一直获得买入。而后进入市值最小列表的股票因为腾出的资金比较少，分到的资金余额也会偏少，因此先进入列表一直没出来的股票持仓会越来越多

请教一下，为啥单个股票的买入资金是可用资金除以持仓股票数量，难道不应该是可用资金除以卖出的股票数码

@策略炒股 请教一下： 既然已经有了'not curr_data[stock].is_st'这句，又何必在加('ST' not in curr_data[stock].name) and ('*' not in curr_data[stock].name)这句呢？

请教，有没有人帮我看一下，为什么没有股票选进去 from jqdata import * import datetime #初始化 def initialize(context): #设定循环周期为日线 run_daily(period,time = 'every_bar') #设定需要交易的股票数量 g.stocksnum = 7 #设定交易周期 g.period = 13 #记录策略进行天数 g.days = 0 #过滤当天停牌 def paused_filter(security_list): current_data = get_current_data() security_list = [stock for stock in security_list if not current_data[stock].paused] return security_list #过滤ST,*ST def st_filter(security_list): current_data = get_current_data() security_list = [stock for stock in security_list if not current_data[stock].is_st] return security_list #过滤退市 def delisted_filter(security_list): current_data = get_current_data() security_list = [stock for stock in security_list if not '退' in current_data[stock].name] return security_list #过滤涨停的股票 def high_filter(security_list): current_data = get_current_data() security_list = [stock for stock in security_list if not current_data[stock].high_limit] return security_list #最终过滤后股票列表 def filter_stock(): hsa = get_index_stocks('000001.XSHG') + get_index_stocks('399001.XSHE') hsa_pause = paused_filter(hsa) hsa_pause_st = st_filter(hsa_pause) hsa_pause_st_de = delisted_filter(hsa_pause_st) hsa_pause_st_de_hi = high_filter(hsa_pause_st_de) q = query(valuation.code).filter(valuation.code.in_(hsa_pause_st_de_hi)).order_by(valuation.circulating_market_cap.asc()).limit(g.stocksnum) qd = get_fundamentals(q) return list(qd['code']) def period(context): #交易周期为13天，要判断进行天数是否能被轮动频率整除,整除说明正好是13天，可以交易 if g.days % g.period == 0: #定义股票清单为过滤后的股票清单 buylist = filter_stock() print(buylist) #判断，若现有持仓股票市值已经不满足流通市值最小，不在buylist里，则卖出 for stock in context.portfolio.positions: #获得股票持仓成本 cost = context.portfolio.positions[stock].avg_cost #获得股票现价 price = context.portfolio.positions[stock].price #计算收益率 rent = price/cost-1 #打印日志 print('成本价：%s' % cost) print('现价：%s' % price) print('收益率：%s' % rent) if stock not in buylist: order_target(stock,0) #或者收益率超过8%，止盈 else: if rent > 0.05: order_target(stock,0) print('触发止盈') #或者收益率亏损超过5%，止损 elif rent < = -0.03: order_target(stock,0) print('触发止损') #买入股票，金额为可用金额的stocksnum分之1 #将资金分成stocksnum份 stk_cash = context.portfolio.available_cash/g.stocksnum #用分配到的资金买入股票 for stock in buylist: order(stock,stk_cash) print(context.portfolio.positions) g.days = g.days + 1

q=query(valuation.code ).filter( valuation.code.in_(scu) ).order_by( valuation.market_cap.asc() ).limit(g.stocksnum) df = get_fundamentals(q) 这里并没有限制时间，那是以哪个时间为起点的筛选？

@bowenzz 每个交易日，买入10支股票

@悟通 感觉是卖出非最小市值股票的原因。