活动介绍
file-type

Python处理价值股数据包的实战指南

ZIP文件

Python
下载需积分: 5 | 10KB | 更新于2025-05-18 | 48 浏览量 | 0 下载量 举报 收藏
download 立即下载
标题和描述均指明了主题为“value-stocks”，即价值股。价值股（Value Stocks）是投资领域中的一个核心概念，指的是那些市场估值低于其内在价值的股票。价值投资的理念由来已久，最早可以追溯到本杰明·格雷厄姆和大卫·多德的著作《证券分析》，而沃伦·巴菲特就是将价值投资理念发扬光大的代表性人物之一。 在描述中，虽然信息重复，并未提供额外的细节，但我们仍然可以从价值股这一主题出发，阐述相关知识点。首先，我们需要理解什么是价值股。价值股通常指市盈率（PE）较低、股息率较高、股价相对账面价值低的股票。相比成长股（Growth Stocks），价值股更注重稳定的分红和低估值，而不是公司收入的高速增长。 接下来，我们会聚焦在Python这一标签上。Python是一种广泛使用的高级编程语言，因其简洁明了的语法和强大的功能而受到程序员的喜爱。在金融领域，Python正成为一种不可或缺的工具，特别是在数据分析、量化交易和机器学习等方面。我们可以借助Python来开发价值股分析的算法和策略。 对于“value-stocks-master”这个压缩包子文件的名称列表，我们可以推测该文件可能包含与价值股相关的Python项目或代码库。从项目命名习惯来看，“master”一般表示这个文件是项目的主版本或主分支。 现在，我们将展开与价值股相关的Python知识点： 1. 财务分析：Python可以用来获取股票数据，并计算出各种财务比率，例如市盈率（PE）、市净率（PB）、股息率等，这些指标都是评估价值股的重要工具。 2. 数据获取：利用Python的库如pandas-datareader、yfinance等，可以方便地获取实时或历史的股票数据、公司财务报告等。 3. 数据处理：Python中的pandas库非常适合数据处理，可以对获取到的财务数据进行清洗、排序、分组等操作，为分析提供准备好的数据集。 4. 回测系统：在构建价值股投资策略时，Python的回测框架（如backtrader、pyalgotrade等）可以用来测试策略在过去一段时间内的表现，帮助投资者评估策略的有效性。 5. 机器学习：Python强大的机器学习库（如scikit-learn、tensorflow、pytorch等）可以用于构建预测模型，预测股票价格，或者帮助识别那些被市场低估的股票。 6. 股票筛选：Python可以用于实现股票筛选系统，帮助投资者根据预设的条件筛选出符合价值股标准的股票池。 7. Web数据抓取：价值投资者往往需要大量市场信息来辅助决策，Python中的requests库和BeautifulSoup库可以用来抓取网页上的相关信息。 8. 数据可视化：matplotlib、seaborn、plotly等Python可视化库可以帮助我们直观地展示数据分析结果，例如画出股票价格走势图、财务指标分布图等。 9. 自动化：Python可以编写脚本来自动化数据下载、分析、报告生成等重复性工作，从而提高工作效率。 10. 云服务和API：Python能够与各种云服务和API接口交互，如Bloomberg API、Interactive Brokers API等，为投资者提供实时的市场数据和执行交易。 通过上述知识点，我们可以看到Python在价值股分析中扮演的重要角色。无论是数据获取、处理、分析、还是回测，Python都提供了丰富且成熟的库和工具，帮助投资者和分析师更深入地理解和操作价值股。需要注意的是，价值投资策略的实施需要深入理解市场机制和公司基本面，而技术工具只是辅助决策的一部分。投资者在利用Python等工具进行投资分析时，也应当结合专业的财务知识和市场理解，以做出更准确的投资决策。

相关推荐

filetype

vba-stocks-tracker

【vba-stocks-tracker】是一个使用VBA（Visual Basic for Applications）编写的程序，它专为Excel设计，用于跟踪和分析股票的价值及其变化。VBA是Microsoft Office套件中的编程语言，允许用户自定义工作流程，自动化...
filetype

Fama-French-5-factor-Model.pdf

The five-factor model's main problem is its failure to capture the low average returns on small stocks whose returns behave like those of firms that invest a lot despite low profitability. The model'...
filetype

在下列代码中，加入股票资金账户，以便实盘交易操作：from qmt import * import numpy as np import pandas as pd # 初始化函数 def initialize(context): # 设置初始账户资金（1000万元） context.set_initial_cash(10000000) # 设置交易参数 context.commission_rate = 0.0003 # 万三手续费 context.tax_rate = 0.001 # 千一印花税 # 设置定时任务 schedule(schedule_func=end_of_month_task, date_rule='last_trading_day', time_rule='14:50:00') schedule(schedule_func=start_of_month_task, date_rule='first_trading_day', time_rule='09:30:00') # 存储选股结果 context.target_stocks = { 'small_market_value': [], # 小市值股票池 'low_turnover': [] # 低换手率股票池 } # 月末任务：卖出持仓并选股 def end_of_month_task(context): # 1. 卖出所有持仓 sell_all_stocks(context) # 2. 执行选股逻辑 select_stocks(context) # 记录账户状态 log_account_status(context) # 月初任务：买入股票 def start_of_month_task(context): # 获取账户总资产 total_assets = context.account().total_assets # 小市值股票分配10%资金 small_mv_stocks = context.target_stocks['small_market_value'] if small_mv_stocks: cash_per_stock = total_assets * 0.1 / len(small_mv_stocks) for stock in small_mv_stocks: # 获取当前价格计算应买数量 price = get_market_data(stock, fields='close', count=1).iloc[-1] amount = int(cash_per_stock / price / 100) * 100 # 整百股 order(stock, amount) # 低换手率股票分配90%资金 low_turn_stocks = context.target_stocks['low_turnover'] if low_turn_stocks: cash_per_stock = total_assets * 0.9 / len(low_turn_stocks) for stock in low_turn_stocks: price = get_market_data(stock, fields='close', count=1).iloc[-1] amount = int(cash_per_stock / price / 100) * 100 order(stock, amount) # 记录交易日志 log_trade_details(context, total_assets) # 高效选股逻辑（使用向量化计算） def select_stocks(context): # 获取所有A股股票（排除ST和退市股） all_stocks = get_stock_list_in_sector('沪深A股') valid_stocks = [s for s in all_stocks if not s.startswith('ST') and not s.startswith('*')] # 批量获取数据（提高效率） market_values = [] turnovers = [] close_prices = [] # 批量获取最新市值和价格 for stock in valid_stocks: data = get_market_data(stock, fields=['total_market_value', 'close'], count=1) market_values.append((stock, data['total_market_value'].iloc[-1])) close_prices.append(data['close'].iloc[-1]) # 批量计算20日换手率 for i, stock in enumerate(valid_stocks): turn_data = get_market_data(stock, fields='turnover_rate', count=20) avg_turn = turn_data.mean().iloc[0] turnovers.append((stock, avg_turn)) # 创建DataFrame进行向量化操作 df = pd.DataFrame({ 'stock': valid_stocks, 'market_value': [mv[1] for mv in market_values], 'turnover': [t[1] for t in turnovers], 'price': close_prices }) # 过滤价格过低和流动性差的股票 df = df[(df['price'] > 1.0) & (df['turnover'] > 0.001)] # 按市值升序排序 df_sorted_mv = df.sort_values(by='market_value').head(10) # 按换手率升序排序 df_sorted_turn = df.sort_values(by='turnover').head(10) # 存储选股结果 context.target_stocks['small_market_value'] = df_sorted_mv['stock'].tolist() context.target_stocks['low_turnover'] = df_sorted_turn['stock'].tolist() # 清空所有持仓 def sell_all_stocks(context): positions = context.account().positions for stock in positions: # 获取持仓数量 hold_amount = positions[stock]['amount'] # 市价卖出 order_target(stock, 0) # 账户状态日志 def log_account_status(context): account = context.account() log(f"月末账户状态 | 总资产: {account.total_assets:.2f} | " f"现金: {account.cash:.2f} | " f"持仓市值: {account.market_value:.2f}") # 交易详情日志 def log_trade_details(context, total_assets): log(f"月初调仓 | 总资金: {total_assets:.2f}") log(f"小市值组合({len(context.target_stocks['small_market_value'])}只): " f"{', '.join(context.target_stocks['small_market_value'])}") log(f"低换手组合({len(context.target_stocks['low_turnover'])}只): " f"{', '.join(context.target_stocks['low_turnover'])}") # 计算分配资金 small_mv_cash = total_assets * 0.1 low_turn_cash = total_assets * 0.9 log(f"资金分配: 小市值组={small_mv_cash:.2f}(10%) | 低换手组={low_turn_cash:.2f}(90%)") # 主函数 def main(): pass

由于我们已经在`end_of_month_task`中调用了`sell_all_stocks`，所以这里我们修改`sell_all_stocks`的实现。 另外，在`start_of_month_task`中，我们使用`order_with_cost`来买入股票。 由于交易成本的计算需要...
filetype

from jqdata import * from jqfactor import get_factor_values import datetime import math from scipy.optimize import minimize import pandas as pd # 初始化函数，设定基准等等 def initialize(context): # 设定沪深300作为基准 set_benchmark("399303.XSHE") # 打开防未来函数 set_option("avoid_future_data", True) # 开启动态复权模式(真实价格) set_option("use_real_price", True) # 输出内容到日志 log.info() log.info("初始函数开始运行") # 过滤掉order系列API产生的比error级别低的log log.set_level("order", "error") # 固定滑点设置ETF 0.001(即交易对手方一档价) set_slippage(FixedSlippage(0.002), type="fund") # 股票交易总成本0.3%(含固定滑点0.02) set_order_cost( OrderCost( open_tax=0, close_tax=0.001, open_commission=0.0003, close_commission=0.0003, close_today_commission=0, min_commission=5, ), type="stock", ) g.hold_list = [] # 记录策略的持仓股票 g.positions = {} # 记录策略的持仓股票 # 持仓股票数 g.stock_sum = 6 # 判断买卖点的行业数量 g.num = 1 # 空仓的月份 g.pass_months = [] # 策略执行计划 run_weekly(adjust, 1, "9:31") run_daily(check, "14:50") # 获取昨日涨停票并卖出 def check(context): # 获取已持有列表 g.hold_list = list(g.positions.keys()) banner_stocks = [] # 获取昨日涨停列表 if g.hold_list != []: df = get_price( g.hold_list, end_date=context.previous_date, frequency="daily", fields=["close", "high_limit"], count=1, panel=False, fill_paused=False, ) df = df[df["close"] == df["high_limit"]] banner_stocks = list(df.code) for stock in banner_stocks: order_target_value_(context, stock, 0) # 获取昨日跌停列表 if g.hold_list != []: df = get_price( g.hold_list, end_date=context.previous_date, frequency="daily", fields=["close", "low_limit"], count=1, panel=False, fill_paused=False, ) df = df[df["close"] == df["low_limit"]] banner_stocks = list(df.code) for stock in banner_stocks: order_target_value_(context, stock, 0) # 获取策略当前持仓市值 def get_total_value(context): return sum(context.portfolio.positions[key].price * value for key, value in g.positions.items()) # 调仓 def adjust(context): target = select(context) # 获取前stock_sum个标的 target = target[:min(len(target), g.stock_sum)] # 获取已持有列表 g.hold_list = list(g.positions.keys()) portfolio = context.portfolio # 调仓卖出 for stock in g.hold_list: if stock not in target: order_target_value_(context, stock, 0) # 调仓买入 count = len(set(target) - set(g.hold_list)) if count == 0: return # 目标市值 target_value = portfolio.total_value # 当前市值 position_value = get_total_value(context) # 可用现金:当前现金 available_cash = portfolio.available_cash # 买入股票的总市值 value = max(0, min(target_value - position_value, available_cash)) # 等价值买入每一个未买入的标的 for security in target: if security not in g.hold_list: order_target_value_(context, security, value / count) # 择时 def select(context): I = get_market_breadth(context) industries = {"银行I", "煤炭I", "采掘I", "钢铁I"} if not industries.intersection(I) and not is_empty_month(context): return filter(context) return [] # 获取市场 def get_market_breadth(context): # 指定日期防止未来数据 yesterday = context.previous_date # 获取初始列表 中证全指（000985.XSHG） stocks = get_index_stocks("000985.XSHG") count = 1 h = get_price( stocks, end_date=yesterday, frequency="1d", fields=["close"], count=count + 20, panel=False, ) h["date"] = pd.DatetimeIndex(h.time).date # 将长表格转换为宽表格，方便按日期分析股票价格。 df_close = h.pivot(index="code", columns="date", values="close").dropna(axis=0) # 计算20日均线 df_ma20 = df_close.rolling(window=20, axis=1).mean().iloc[:, -count:] # 计算偏离程度 df_bias = df_close.iloc[:, -count:] > df_ma20 df_bias["industry_name"] = getStockIndustry(stocks) # 计算行业偏离比例 df_ratio = ((df_bias.groupby("industry_name").sum() * 100.0) / df_bias.groupby("industry_name").count()).round() # 获取偏离程度最高的行业 top_values = df_ratio.loc[:, yesterday].nlargest(g.num) I = top_values.index.tolist() return I # 基础过滤(过滤科创北交、ST、停牌、次新股) def filter_basic_stock(context, stock_list): # 30开头的是深交所的创业板， # 68开头的是上交所的科创板， # 8开头的股票可能指的是北交所的， # 新三板北交所的股票代码通常以43、83、87等开头 # 4开头的股票可能属于退市板块 current_data = get_current_data() return [ stock for stock in stock_list if not current_data[stock].paused and not current_data[stock].is_st and "ST" not in current_data[stock].name and "*" not in current_data[stock].name and "退" not in current_data[stock].name and not (stock[0] == "4" or stock[0] == "8" or stock[:2] == "68") and not context.previous_date - get_security_info(stock).start_date < datetime.timedelta(375) ] # 过滤当前时间涨跌停的股票 def filter_limitup_limitdown_stock(stock_list): current_data = get_current_data() return [ stock for stock in stock_list if current_data[stock].last_price < current_data[stock].high_limit and current_data[stock].last_price > current_data[stock].low_limit ] # 判断今天是在空仓月 def is_empty_month(context): month = context.current_dt.month return month in g.pass_months def getStockIndustry(stocks): # 第一步：获取原始行业数据（假设stocks是股票代码列表） industry = get_industry(stocks) # 第二步：提取申万一级行业名称 return pd.Series({stock: info["sw_l1"]["industry_name"] for stock, info in industry.items() if "sw_l1" in info}) # 过滤股票 def filter(context): stocks = get_index_stocks("399303.XSHE") # 这里的有问题，需要由399303.XSHE代替 stocks = filter_basic_stock(context, stocks) stocks = ( get_fundamentals( query( valuation.code, ) .filter( valuation.code.in_(stocks), # 从现有股票池中筛选 indicator.adjusted_profit > 0, # 要求调整后净利润>0 ) .order_by(valuation.market_cap.asc()) # 按市值升序排列（从小市值开始） ) .head(20) # 取前20只股票 .code # 提取股票代码 ) stocks = filter_limitup_limitdown_stock(stocks) return stocks # 自定义下单(涨跌停不交易) def order_target_value_(context, security, value): current_data = get_current_data() # 检查标的是否停牌、涨停、跌停 if current_data[security].paused: log.info(f"{security}: 今日停牌") return False # 检查是否涨停 if current_data[security].last_price == current_data[security].high_limit: log.info(f"{security}: 当前涨停") return False # 检查是否跌停 if current_data[security].last_price == current_data[security].low_limit: log.info(f"{security}: 当前跌停") return False # 获取当前标的的价格 price = current_data[security].last_price # 获取当前策略的持仓数量 current_position = g.positions.get(security, 0) # 计算目标持仓数量 target_position = (int(value / price) // 100) * 100 if price != 0 else 0 # 计算需要调整的数量 adjustment = target_position - current_position # 检查是否当天买入卖出 closeable_amount = context.portfolio.positions[security].closeable_amount if security in context.portfolio.positions else 0 if adjustment < 0 and closeable_amount == 0: log.info(f"{security}: 当天买入不可卖出") return False # 下单并更新持仓 if adjustment != 0: o = order(security, adjustment) if o: # 更新持仓数量 amount = o.amount if o.is_buy else -o.amount g.positions[security] = amount + current_position # 如果目标持仓为零，移除该证券 if target_position == 0: g.positions.pop(security, None) # 更新持有列表 g.hold_list = list(g.positions.keys()) return True return False （把这个聚宽的代码迁移到backtrade

new_stocks = [d for d in self.datas if d._name in target_stocks and d._name not in self.hold_list] if not new_stocks: return # 等权重分配 weight_per_stock = 1.0 / len(new_stocks) for d in ...
filetype

stocks5

Stocks(CODE, NAME, PRICE, BOOK_VALUE, DIVIDEND_RATE) ``` 其中各属性分别对应：股票代码、股票名称、当前股价、每股净资产和分红比例。 3. **技术分析中的五大维度** 投资者常用的技术分析框架有时会围绕几...
filetype

#coding:gbk """ 高胜率沪深300多因子策略 - 国信iQuant平台优化版 提高信号量版本：放宽买入条件、增加备选信号、优化因子计算 """ import pandas as pd import numpy as np import time import datetime def init(ContextInfo): # 获取沪深300成分股 ContextInfo.s = ContextInfo.get_sector('000300.SH') ContextInfo.set_universe(ContextInfo.s) ContextInfo.day = 0 ContextInfo.holdings = {i:0 for i in ContextInfo.s} ContextInfo.buypoint = {} ContextInfo.money = ContextInfo.capital ContextInfo.profit = 0 ContextInfo.accountID = 'testS' # 添加止损止盈机制 ContextInfo.stop_loss = {} # 止损位记录 ContextInfo.take_profit = {} # 止盈位记录 ContextInfo.max_price = {} # 最高价记录 def handlebar(ContextInfo): d = ContextInfo.barpos current_date = timetag_to_datetime(ContextInfo.get_bar_timetag(d), '%Y%m%d') # 获取当前价格数据 price = ContextInfo.get_history_data(1, '1d', 'close', 1) # 每日更新最高价并检查止损止盈条件 for stock in list(ContextInfo.holdings.keys()): if stock in price and ContextInfo.holdings.get(stock, 0) > 0: current_price = price[stock][0] # 更新最高价 if stock not in ContextInfo.max_price or current_price > ContextInfo.max_price[stock]: ContextInfo.max_price[stock] = current_price # 更新止损位：最高价回撤10% if stock not in ContextInfo.stop_loss: ContextInfo.stop_loss[stock] = ContextInfo.buypoint[stock] * 0.90 else: ContextInfo.stop_loss[stock] = max(ContextInfo.stop_loss[stock], ContextInfo.max_price[stock] * 0.90) # 更新止盈位：动态调整 if stock not in ContextInfo.take_profit: ContextInfo.take_profit[stock] = ContextInfo.buypoint[stock] * 1.20 # 20%止盈 elif current_price > ContextInfo.take_profit[stock]: ContextInfo.take_profit[stock] = current_price * 0.95 # 回撤5%止盈 # 触发止损 if current_price <= ContextInfo.stop_loss[stock]: print(f'止损卖出: {stock}, 价格: {current_price}') order_shares(stock, -ContextInfo.holdings[stock], 'fix', current_price, ContextInfo, ContextInfo.accountID) ContextInfo.money += current_price * ContextInfo.holdings[stock] - 0.0003 * ContextInfo.holdings[stock] * current_price ContextInfo.holdings[stock] = 0 ContextInfo.stop_loss.pop(stock, None) ContextInfo.take_profit.pop(stock, None) ContextInfo.max_price.pop(stock, None) # 触发止盈 elif current_price >= ContextInfo.take_profit[stock]: print(f'止盈卖出: {stock}, 价格: {current_price}') order_shares(stock, -ContextInfo.holdings[stock], 'fix', current_price, ContextInfo, ContextInfo.accountID) ContextInfo.money += current_price * ContextInfo.holdings[stock] - 0.0003 * ContextInfo.holdings[stock] * current_price ContextInfo.holdings[stock] = 0 ContextInfo.stop_loss.pop(stock, None) ContextInfo.take_profit.pop(stock, None) ContextInfo.max_price.pop(stock, None) # 每月调仓 if d > 60 and d % 20 == 0: print(f"调仓日期: {current_date}") # 生成买卖信号 buys, sells = signal(ContextInfo) # 多因子评分：动量 + 价值 + 波动性 factor_scores = {} for stock in ContextInfo.s: if buys.get(stock, 0) == 1: try: # 获取历史数据 close_data = ContextInfo.get_history_data(120, '1d', 'close', 3).get(stock, []) high_data = ContextInfo.get_history_data(60, '1d', 'high', 3).get(stock, []) low_data = ContextInfo.get_history_data(60, '1d', 'low', 3).get(stock, []) if len(close_data) < 120 or len(high_data) < 60 or len(low_data) < 60: continue # 1. 动量因子 (过去3个月收益率) momentum = (close_data[-1] / close_data[-60] - 1) * 100 # 2. 价值因子 (价格相对位置) min_low = np.min(low_data) max_high = np.max(high_data) value_factor = (close_data[-1] - min_low) / (max_high - min_low) if (max_high - min_low) > 0 else 0 # 3. 波动性因子 (使用标准差替代ATR) volatility = np.std(close_data[-60:]) # 60日波动率 volatility_factor = 1 / (volatility + 1e-5) # 波动率越低越好 # 综合得分 (动量40% + 价值30% + 波动性30%) factor_scores[stock] = 0.4 * momentum + 0.3 * value_factor + 0.3 * volatility_factor except Exception as e: print(f"因子计算错误 {stock}: {str(e)}") factor_scores[stock] = -9999 # 无效值 # 选取得分最高的10只股票 buy_stocks = [] if factor_scores: sorted_stocks = sorted(factor_scores.items(), key=lambda x: x[1], reverse=True) # 选择排名前20%的股票 num_stocks = max(1, int(len(sorted_stocks) * 0.2)) # 至少选择1只 buy_stocks = [s[0] for s in sorted_stocks[:num_stocks]] print(f"买入股票数量: {len(buy_stocks)}") # 卖出不在买入名单中的股票 for stock in ContextInfo.s: if ContextInfo.holdings.get(stock, 0) > 0 and stock not in buy_stocks: if stock in price: current_price = price[stock][0] print(f'卖出: {stock}, 数量: {ContextInfo.holdings[stock]}') order_shares(stock, -ContextInfo.holdings[stock], 'fix', current_price, ContextInfo, ContextInfo.accountID) ContextInfo.money += current_price * ContextInfo.holdings[stock] - 0.0003 * ContextInfo.holdings[stock] * current_price ContextInfo.holdings[stock] = 0 if stock in ContextInfo.stop_loss: ContextInfo.stop_loss.pop(stock) if stock in ContextInfo.take_profit: ContextInfo.take_profit.pop(stock) if stock in ContextInfo.max_price: ContextInfo.max_price.pop(stock) # 买入新股票 if buy_stocks: print('买入股票池:', buy_stocks) # 确保不会除以零 num_stocks = len(buy_stocks) if num_stocks > 0: per_stock_money = ContextInfo.money / num_stocks for stock in buy_stocks: if stock in price and ContextInfo.holdings.get(stock, 0) == 0: current_price = price[stock][0] buy_quantity = int(per_stock_money / current_price) if buy_quantity > 0: print(f'买入: {stock}, 数量: {buy_quantity}, 价格: {current_price}') order_shares(stock, buy_quantity, 'fix', current_price, ContextInfo, ContextInfo.accountID) ContextInfo.holdings[stock] = buy_quantity ContextInfo.money -= current_price * buy_quantity + 0.0003 * buy_quantity * current_price ContextInfo.buypoint[stock] = current_price # 设置初始止损止盈 ContextInfo.stop_loss[stock] = current_price * 0.90 # 10%止损 ContextInfo.take_profit[stock] = current_price * 1.20 # 20%止盈 ContextInfo.max_price[stock] = current_price else: print("没有符合条件的股票，保持空仓") # 更新收益曲线 total_value = ContextInfo.money for stock, quantity in ContextInfo.holdings.items(): if stock in price: total_value += price[stock][0] * quantity profit_ratio = (total_value - ContextInfo.capital) / ContextInfo.capital ContextInfo.profit = total_value - ContextInfo.capital if not ContextInfo.do_back_test: ContextInfo.paint('profit_ratio', profit_ratio, -1, 0) def signal(ContextInfo): """优化的买卖信号生成函数 - 提高信号数量""" buy = {i:0 for i in ContextInfo.s} sell = {i:0 for i in ContextInfo.s} # 获取历史数据 data_high = ContextInfo.get_history_data(22, '1d', 'high', 3) data_low = ContextInfo.get_history_data(22, '1d', 'low', 3) data_close = ContextInfo.get_history_data(60, '1d', 'close', 3) data_volume = ContextInfo.get_history_data(20, '1d', 'volume', 3) # 获取沪深300指数数据判断市场趋势 hs300_data = ContextInfo.get_history_data(60, '1d', 'close', 3).get('000300.SH', []) market_up_trend = False if hs300_data and len(hs300_data) >= 60: ma60 = np.mean(hs300_data) market_up_trend = hs300_data[-1] > ma60 buy_count = 0 for stock in ContextInfo.s: # 检查数据是否存在 if stock not in data_high or stock not in data_low or stock not in data_close or stock not in data_volume: continue high_data = data_high[stock] low_data = data_low[stock] close_data = data_close[stock] volume_data = data_volume[stock] # 确保有足够的历史数据 if len(high_data) < 22 or len(low_data) < 22 or len(close_data) < 60 or len(volume_data) < 20: continue try: # 计算技术指标 ma20 = np.mean(close_data[-20:]) # 20日均价 ma60 = np.mean(close_data[-60:]) # 60日均价 current_close = close_data[-1] # 当前收盘价 # 条件1：突破20日高点 condition_breakout = high_data[-1] > max(high_data[-22:-1]) # 条件2：接近20日高点（95%以上） condition_near_high = high_data[-1] > 0.95 * max(high_data[-22:-1]) # 条件3：均线多头排列 condition_ma = (current_close > ma20 > ma60) # 条件4：成交量确认 avg_volume = np.mean(volume_data[-20:]) condition_volume = volume_data[-1] > avg_volume * 1.0 # 不低于平均成交量 # 条件5：短期趋势向上（5日线上穿10日线） ma5 = np.mean(close_data[-5:]) ma10 = np.mean(close_data[-10:]) condition_short_trend = ma5 > ma10 # 买入信号：主要条件 + 辅助条件 # 主要条件：突破20日高点 + 多头排列 main_condition = condition_breakout and condition_ma # 备选条件：接近高点 + 多头排列 + 短期趋势向上 alt_condition = condition_near_high and condition_ma and condition_short_trend # 买入信号：满足主要条件或备选条件，且有成交量支持 if (main_condition or alt_condition) and condition_volume: buy[stock] = 1 buy_count += 1 # 卖出信号条件 sell_condition1 = current_close < ma60 * 0.95 # 跌破60日均线5% sell_condition2 = current_close < ma20 * 0.93 # 跌破20日均线7% sell[stock] = 1 if sell_condition1 or sell_condition2 else 0 except Exception as e: print(f"信号生成错误 {stock}: {str(e)}") # 出错时默认不交易 buy[stock] = 0 sell[stock] = 0 # 调试输出：统计买入信号数量 print(f"生成买入信号数量: {buy_count}") return buy, sell 优化一下以上策略，因为要求比较严格，至买入了一直股票

$$ \text{Buy} = (\text{Value} \leq V_t) \lor (\text{Momentum} \geq M_t) \lor (\text{Volatility} \leq \sigma_t) $$ 2. **参数动态化** 阈值随市场波动率自适应调整： $$ \text{Threshold} = \alpha \...
filetype

import time import datetime import threading from typing import List, Dict, Optional, Set import logging import random import numpy as np # 设置日志 logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('explosive_stock_scanner.log'), logging.StreamHandler() ] ) logger = logging.getLogger(__name__) # ====================== 数据层 ====================== class EnhancedDataLayer: def __init__(self, config: Dict): self.config = config self.stocks = ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'TSLA', 'NVDA', 'PYPL', 'ADBE', 'INTC', 'META'] self.market_index = {'CSI300': {'trend': 'UP', 'value': 4500}} # 模拟大盘指数 self._init_mock_data() def _init_mock_data(self): """初始化模拟数据""" # 技术指标模板 self.tech_template = { 'volume': lambda: random.randint(500000, 2000000), 'volume_ma20': lambda: random.randint(200000, 800000), 'volume_ma5': lambda: random.randint(300000, 1000000), 'chg_pct': lambda: round(random.uniform(0, 15), 2), 'turnover_rate': lambda: round(random.uniform(5, 25), 2), 'close': lambda: round(random.uniform(100, 200), 2), 'high': lambda: round(random.uniform(100, 200), 2), 'upper_boll_10_2.5': lambda: round(random.uniform(100, 200), 2), 'rsi_14': lambda: round(random.uniform(30, 90), 2), 'macd_hist': lambda: round(random.uniform(-1, 1), 3), 'volume_ma5_ma20_ratio': lambda: round(random.uniform(1, 3), 2) } # 基本面模板 self.fund_template = { 'float_market_cap': lambda: round(random.uniform(5e9, 20e9), 2), 'pe_ratio': lambda: round(random.uniform(10, 30), 2), # 市盈率 'net_profit_growth': lambda: round(random.uniform(10, 50), 2) # 净利润增长率(%) } # 资金流模板 self.capital_template = { 'main_net_inflow_3d': lambda: round(random.uniform(0.01, 0.05) * random.randint(1e9, 10e9), 2), 'dragon_tiger_buy_amount': lambda: round(random.uniform(100e6, 500e6), 2), 'northbound_holding_chg_5d': lambda: round(random.uniform(1.0, 4.0), 2), 'institution_net_buy_ratio': lambda: round(random.uniform(20, 50), 2), 'retail_sell_ratio': lambda: round(random.uniform(50, 80), 2) } def get_technical_indicators(self, stock: str) -> Optional[Dict]: """获取技术指标（模拟数据）""" if stock not in self.stocks: return None return {k: v() for k, v in self.tech_template.items()} def get_fundamental_data(self, stock: str) -> Optional[Dict]: """获取基本面数据（模拟数据）""" if stock not in self.stocks: return None return {k: v() for k, v in self.fund_template.items()} def get_capital_flow(self, stock: str) -> Optional[Dict]: """获取资金流数据（模拟数据）""" if stock not in self.stocks: return None return {k: v() for k, v in self.capital_template.items()} def get_market_index(self, index_name: str) -> Optional[Dict]: """获取大盘指数""" return self.market_index.get(index_name) # ====================== 策略引擎 ====================== class StrategyEngine: def __init__(self, data_layer): self.data_layer = data_layer # 行业PE均值（模拟） self.industry_pe_mean = 25.0 def _is_technical_breakout(self, stock: str) -> bool: """技术面：主升浪启动信号""" indicators = self.data_layer.get_technical_indicators(stock) if not indicators: return False # 核心条件：量价齐升 + 突破布林上轨 + RSI强势但未背离 return ( indicators['volume'] > 3 * indicators['volume_ma20'] and # 放量3倍 indicators['close'] > indicators['upper_boll_10_2.5'] and # 突破上轨 70 > indicators['rsi_14'] > 50 and # RSI强势区间 indicators['macd_hist'] > 0 and # MACD金叉 indicators['volume_ma5_ma20_ratio'] > 2.5 # 5日量能是20日均量2.5倍 ) def _is_fundamental_strong(self, stock: str) -> bool: """基本面：高增长低估值""" fundamentals = self.data_layer.get_fundamental_data(stock) if not fundamentals: return False # 核心条件：净利润高增长 + 低市盈率 return ( fundamentals['net_profit_growth'] > 30 and # 净利润增速>30% fundamentals['pe_ratio'] < self.industry_pe_mean # 市盈率低于行业均值 ) def _is_capital_inflow(self, stock: str) -> bool: """资金面：主力资金大幅流入""" capital = self.data_layer.get_capital_flow(stock) if not capital: return False # 核心条件：北向资金连续增持 + 机构净买入比例高 return ( capital['northbound_holding_chg_5d'] > 3.0 and # 北向5日增持>3% capital['institution_net_buy_ratio'] > 40 and # 机构净买入比例>40% capital['dragon_tiger_buy_amount'] > 300e6 # 游资买入>3亿 ) def _is_market_bullish(self) -> bool: """市场环境：大盘处于上升趋势""" index = self.data_layer.get_market_index('CSI300') return index and index['trend'] == 'UP' and index['value'] > 4200 # 大盘>4200点 def select_10pct_stocks(self, candidate_stocks: List[str]) -> List[str]: """筛选10日可涨50%的股票""" target_stocks = [] for stock in candidate_stocks: # 综合评分：技术(40%) + 基本面(30%) + 资金(20%) + 市场(10%) score = ( 0.4 * self._technical_score(stock) + 0.3 * self._fundamental_score(stock) + 0.2 * self._capital_score(stock) + 0.1 * self._market_score() ) # 评分>85分且满足所有硬性条件 if score > 85 and self._is_technical_breakout(stock) and \ self._is_fundamental_strong(stock) and \ self._is_capital_inflow(stock) and \ self._is_market_bullish(): target_stocks.append(stock) return target_stocks # ---------------------- 评分函数 ---------------------- def _technical_score(self, stock: str) -> float: """技术面评分（0-100）""" indicators = self.data_layer.get_technical_indicators(stock) if not indicators: return 0 # 量价齐升（30分）+ 突破上轨（25分）+ RSI强势（20分）+ MACD（15分）+ 量能比（10分） score = 0 if indicators['volume'] > 3 * indicators['volume_ma20']: score += 30 if indicators['close'] > indicators['upper_boll_10_2.5']: score += 25 if 70 > indicators['rsi_14'] > 50: score += 20 if indicators['macd_hist'] > 0: score += 15 if indicators['volume_ma5_ma20_ratio'] > 2.5: score += 10 return min(score, 100) def _fundamental_score(self, stock: str) -> float: """基本面评分（0-100）""" fundamentals = self.data_layer.get_fundamental_data(stock) if not fundamentals: return 0 # 净利润增速（40分）+ 市盈率（60分） score = 0 if fundamentals['net_profit_growth'] > 30: score += 40 if fundamentals['pe_ratio'] < self.industry_pe_mean: score += 60 return min(score, 100) def _capital_score(self, stock: str) -> float: """资金面评分（0-100）""" capital = self.data_layer.get_capital_flow(stock) if not capital: return 0 # 北向增持（40分）+ 机构买入（30分）+ 游资买入（30分） score = 0 if capital['northbound_holding_chg_5d'] > 3.0: score += 40 if capital['institution_net_buy_ratio'] > 40: score += 30 if capital['dragon_tiger_buy_amount'] > 300e6: score += 30 return min(score, 100) def _market_score(self) -> float: """市场环境评分（0-100）""" index = self.data_layer.get_market_index('CSI300') if not index or index['trend'] != 'UP': return 0 # 大盘指数每上涨100点加10分（最高100分） return min((index['value'] - 4000) / 100 * 10, 100) # ====================== 交易执行器 ====================== class TradeExecutor: def __init__(self, data_layer, config: Dict): self.data_layer = data_layer self.config = config self.portfolio: Dict[str, Dict] = {} # 持仓字典 {code: {'position': x, 'entry_price': y}} def execute_trade(self, stock: str, action: str, position: float): """执行交易（买入/卖出）""" if action == '买入': entry_price = self.data_layer.get_technical_indicators(stock)['close'] self.portfolio[stock] = { 'position': position, 'entry_price': entry_price, 'buy_time': datetime.datetime.now() } logger.info(f"买入 {stock} {position}% 仓位，成本价：{entry_price:.2f}") elif action == '卖出': if stock in self.portfolio: del self.portfolio[stock] logger.info(f"卖出 {stock} 全部持仓") def get_portfolio(self) -> Dict[str, Dict]: """获取当前持仓""" return self.portfolio # ====================== 主系统 ====================== class ExplosiveStockScanner: def __init__(self, config: Dict): self.config = config self.data_layer = EnhancedDataLayer(config) self.strategy_engine = StrategyEngine(self.data_layer) self.executor = TradeExecutor(self.data_layer, config) self.candidate_stocks = self._get_candidate_stocks() # 初始候选池 def _get_candidate_stocks(self) -> List[str]: """获取初始候选股票池（全市场股票）""" return self.data_layer.stocks def run_daily_scan(self): """每日扫描并执行交易""" logger.info("===== 开始每日扫描 =====") # 1. 筛选10日可涨50%的股票 target_stocks = self.strategy_engine.select_10pct_stocks(self.candidate_stocks) logger.info(f"筛选出潜在标的：{target_stocks}") # 2. 执行买入操作（假设每个标的买入5%仓位） for stock in target_stocks: if stock not in self.executor.get_portfolio(): self.executor.execute_trade(stock, '买入', 5.0) # 单只最多5%仓位 # 3. 输出当前持仓 logger.info("当前持仓：") for stock, info in self.executor.get_portfolio().items(): （如何将这内容安装在这个平台上？

order_value(stock, 10000) # 每支买入1万元 ``` *关键改造点*： - 替换数据接口（如`your_filter_strategy`接入平台API） - 遵循平台交易函数（`order`/`order_target`） - 添加风控模块（仓位控制、滑点设置...
filetype

我现在有一个模型， 金融时间序列预测问题，常规的做法往往将batch设置为股票数量，或者是重复N次训练来进行三维数据（stocks*features*length）的建模，本文利用状态空间模型的灵活建模优势，以及较高的效率来直接进行三维数据的建模，真正意义上的时序三维建模。并且从时空的两个角度进行建模。将原有的mamba框架，修改为支持三维建模的3Dmamba，通过翻转数据，一个3Dmamba处理B*S*F*L的数据，一个3Dmamba处理B*F*S*L的数据，再将两个数据相加，输入到下一层的HGAT里面；第二个创新点在于HGAT，超图注意力机制，常规的论文往往将图结构静止，输入一个先验的关联矩阵，但是实际的情况是，随着时间的变化，股票的关系会发生一些变化，我从先验的关联矩阵中抽取潜在的关系，并且随着时间的变化，将输入的时间长度分为多个patch，对于每个patch进行了HGAT以后，会对关联矩阵进行一个普通mamba的更新操作，使得关联矩阵能够不断变化。考虑到HGAT一次只能处理一个样本的关联矩阵数据，工程方面我将一个Batch中的多个数据进行合并，将多个图合并成大图，以便能够高效计算。最终再输出最终的预测close价格，转为return计算预测前5名的累计收益率和sharpe值，作为最终的metrics，因为比如论文CI-STHPAN、ALSP-TF等都是用这些指标，而没有使用MSE。 总的来说就是，输入B*N*D*L的数据，进入两个3Dmamba，一个是B*N*D*L，一个是B*D*N*L，然后相加，然后进入DHGAT。DHGAT里面先分patch，对第一个patch使用先验的超图结构，输出提取的特征；然后使用普通mamba更新超图结构，作为下一个patch的输入超图结构，最终将所有提取的特征重新concat成为一个新的序列B*N*D*L，在进行Head的预测 我介绍完我的模型了，现在向你提问 对于Evolving HGAT的部分，利用mamba去更新了关联矩阵以后，原本的关联矩阵本来只有0和1，更新后必然是float的值，我目前的做法是取top k的值设置为1，其他为0，但是感觉不太合适，有没有更合适的方法？代码附给你 def forward(self, x): ''' input: bs x stocks x features x d_model output: bs x stocks x features x d_model ''' bs, stocks, features, d_model = x.shape # do patching x = x.unfold(dimension=-1, size=self.patch_len, step=self.stride) # z_a: tensor [bs x stocks x features x patch_num x patch_len] x = self.value_emb(x) + self.W_pos x = self.dropout(x) x = rearrange(x, 'b s f p l -> b s p (f l)') # step sparse_tensor = self.index_stocks.unsqueeze(0).repeat(bs, 1, 1) z_out = [] for step in range(x.shape[2]): merged_hyperedge_index, batch_offsets = self.merge_hypergraphs(sparse_tensor) x_step = x[:, :, step, :].view(-1, self.patch_len * features) # [bs*stocks, features * patch_len] hgat_out = self.hgat(x_step, merged_hyperedge_index, device=self.device) hgat_out = hgat_out.view(bs, stocks, -1) z_out.append(hgat_out) if x.shape[2] != 1:

好的，我现在需要帮用户解决他们在Evolving HGAT部分遇到的问题。用户提到，在使用Mamba更新关联矩阵后，原本的0-1矩阵变成了浮点值，他们目前的做法是取top k设为1，其余为0，但感觉不合适，想要更好的方法。...
filetype

if (eps_growth[1:] > 0).all(axis=None): # 添加到选股结果中 selected_stocks.append(stock_data) 代码报错：ValueError: The truth value of a DataFrame is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

这个错误是因为在 if 语句中使用了一个 Pandas DataFrame 对象进行布尔运算，导致 Python 无法确定该 DataFrame 对象的真假值。为了解决这个问题，你需要使用 Pandas 提供的... selected_stocks.append(stock_data) ```
filetype

if all(eps_growth[1:] > 0): # 从第二年开始检查 # 添加到选股结果中 selected_stocks.append(stock_data)代码报错：ValueError: The truth value of a DataFrame is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

这个错误是因为 `eps_growth[1:]` 返回的是一个 DataFrame，而 `all()` 函数不能直接作用于 DataFrame。你需要使用 `all()` 函数的某个变体来... selected_stocks.append(stock_data) ``` 这样，就可以避免上述错误。
filetype

import jqdata # 初始化聚宽账号密码 def initialize(context): # 设置回测日期区间 set_benchmark('000300.XSHG') set_option('use_real_price', True) # 设置买入的股票数量上限 g.max_stock_count = 5 def handle_data(context, data): # 获取当前日期 current_date = context.current_dt.date() # 获取股票池中的股票列表 stocks = get_index_stocks('000852.XSHG') # 按照股票池中的股票进行遍历 for stock in stocks: # 判断股票是否满足买入条件 if check_buy_condition(stock, current_date, context): buy_stock(stock, context) # 判断持有的股票是否满足卖出条件 if check_sell_condition(stock, current_date, context): sell_stock(stock, context) def check_buy_condition(stock, current_date, context): # 判断股票是否连续下跌三天 prices = attribute_history(stock,3, 'close', skip_paused=True) if len(prices) == 3 and prices['close'][-1] < prices['close'][-2] < prices['close'][-3]: return True else: return False def buy_stock(stock, context): # 判断当前持仓的股票数量是否已达上限 if len(context.portfolio.positions) >= g.max_stock_count: return # 买入股票 order_value(stock, context.portfolio.cash / g.max_stock_count) def check_sell_condition(stock, current_date, context): # 获取持有股票的买入日期 buy_date = context.portfolio.positions[stock].init_time.date() # 判断是否满足卖出条件 if current_date - buy_date >= 3: # 判断是否亏损超过5% if (context.portfolio.positions[stock].last_price - context.portfolio.positions[stock].avg_cost) / context.portfolio.positions[stock].avg_cost <= -0.05: return True return False def sell_stock(stock, context): # 卖出股票 order_target(stock, 0) 报错count = int(unit[:-1]) ValueError: invalid literal for int() with base 10: 'clos'

这个错误是因为在获取股票价格时，使用了错误的列名。在`attribute_history()`函数中，第三个参数应该是列名，而不是'close'。请将`attribute_history(stock,3, 'close', skip_paused=True)`修改为`attribute_...
filetype

select productNo, productName, Price, If(stocks < 100,”库存不足”,stocks)as 库存 From product;请你判断此mysql语句是否出错

IF函数在MySQL中的语法是IF(condition, value_if_true, value_if_false)。用户的条件是stocks ，如果成立则返回“库存不足”，否则返回stocks。这里需要注意的是，字符串应该用单引号或者双引号括起来，但用户用了...
filetype

%% 原料数据初始化 lengths = [3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, ... 7, 7.5, 8, 8.5, 9, 9.5, 10, 10.5, ... 11, 11.5, 12, 12.5, 13, 13.5, 14, 14.5, ... 15, 15.5, 16, 16.5, 17, 17.5, 18, 18.5, ... 19, 19.5, 20, 20.5, 21, 21.5, 22, 22.5, ... 23, 23.5, 24, 24.5, 25, 25.5]; stocks = [43, 59, 39, 41, 27, 28, 34, 21, ... 24, 24, 20, 25, 21, 23, 21, 18, ... 31, 23, 22, 59, 18, 25, 35, 29, ... 30, 42, 28, 42, 45, 49, 50, 64, ... 52, 63, 49, 35, 27, 16, 12, 2, ... 0, 6, 0, 0, 0, 1]; % 原料分组索引 spec1_direct = 1:8; % 规格1直接使用 (3-6.5m) spec2_direct = 9:22; % 规格2直接使用 (7-13.5m) spec3_direct = 23:46; % 规格3直接使用 (14m+) % 可降级原料索引 downgrade1_idx = []; % 可降级至规格1的原料 (6.5 < len <= 8.5) downgrade2_idx = []; % 可降级至规格2的原料 (13.5 < len <= 22.5) for j = spec2_direct if lengths(j) > 6.5 && lengths(j) <= 8.5 downgrade1_idx = [downgrade1_idx, j]; end end for j = spec3_direct if lengths(j) > 13.5 && lengths(j) <= 22.5 downgrade2_idx = [downgrade2_idx, j]; end end %% 估算最大捆数 total_stocks = sum(stocks); n_max = min([floor(total_stocks/4), ... % 规格3最小根数 floor(total_stocks/7), ... % 规格2最小根数 floor(total_stocks/19)]); % 规格1最小根数 fprintf('最大潜在捆数估算: %d\n', n_max); %% 建立模型基础结构 n = n_max; % 最大潜在捆数 num_vars = 3*n + 46*n + length(downgrade1_idx)*n + length(downgrade2_idx)*n; % 变量索引映射 x_start = 1; % X_ik (3n个变量) c_start = 3*n + 1; % C_ij (46n个变量) d1_start = c_start + 46*n;% D_ij^{(1)} d2_start = d1_start + length(downgrade1_idx)*n; % D_ij^{(2)} %% 第一阶段：最大化总捆数 fprintf('\n=== 第一阶段：最大化总捆数 ===\n'); % 目标函数：最大化总捆数 f = zeros(num_vars, 1); f(x_start:x_start+3*n-1) = 1; % 所有X_ik系数为1 % 约束计数器 constr_count = 0; % 约束1：每个捆选择恰好一种规格 (n个等式约束) A1 = zeros(n, num_vars); for i = 1:n idx = x_start + 3*(i-1); A1(i, idx:idx+2) = 1; end b1 = ones(n, 1); constr_count = constr_count + n; % 约束2：规格1长度约束 (2n个不等式) A2 = zeros(2*n, num_vars); b2 = zeros(2*n, 1); for i = 1:n % 下界约束: 88.5*X_i1 <= sum idx = x_start + 3*(i-1); A2(2*i-1, idx) = -88.5; % -88.5*X_i1 % 上界约束: sum <= 89.5*X_i1 A2(2*i, idx) = 89.5; % 89.5*X_i1 % 原料求和项 for j = spec1_direct var_idx = c_start + 46*(i-1) + j - 1; A2(2*i-1, var_idx) = lengths(j); % 正系数 A2(2*i, var_idx) = -lengths(j); % 负系数 end for j = downgrade1_idx d_idx = find(downgrade1_idx == j); var_idx = d1_start + length(downgrade1_idx)*(i-1) + d_idx - 1; A2(2*i-1, var_idx) = lengths(j); % 正系数 A2(2*i, var_idx) = -lengths(j); % 负系数 end end b2(1:2:end) = 0; % 下界约束 <= 0 b2(2:2:end) = 0; % 上界约束 <= 0 constr_count = constr_count + 2*n; % 约束3：规格2长度约束 (2n个不等式) A3 = zeros(2*n, num_vars); b3 = zeros(2*n, 1); for i = 1:n idx = x_start + 3*(i-1) + 1; % X_i2 A3(2*i-1, idx) = -88.5; % -88.5*X_i2 A3(2*i, idx) = 89.5; % 89.5*X_i2 for j = spec2_direct var_idx = c_start + 46*(i-1) + j - 1; A3(2*i-1, var_idx) = lengths(j); A3(2*i, var_idx) = -lengths(j); end for j = downgrade2_idx d_idx = find(downgrade2_idx == j); var_idx = d2_start + length(downgrade2_idx)*(i-1) + d_idx - 1; A3(2*i-1, var_idx) = lengths(j); A3(2*i, var_idx) = -lengths(j); end end b3(1:2:end) = 0; b3(2:2:end) = 0; constr_count = constr_count + 2*n; % 约束4：规格3长度约束 (2n个不等式) A4 = zeros(2*n, num_vars); b4 = zeros(2*n, 1); for i = 1:n idx = x_start + 3*(i-1) + 2; % X_i3 A4(2*i-1, idx) = -88.5; % -88.5*X_i3 A4(2*i, idx) = 89.5; % 89.5*X_i3 for j = spec3_direct var_idx = c_start + 46*(i-1) + j - 1; A4(2*i-1, var_idx) = lengths(j); A4(2*i, var_idx) = -lengths(j); end end b4(1:2:end) = 0; b4(2:2:end) = 0; constr_count = constr_count + 2*n; % 约束5：库存限制 (46个不等式) A5 = zeros(46, num_vars); b5 = stocks'; for j = 1:46 for i = 1:n % C_ij var_idx = c_start + 46*(i-1) + j - 1; A5(j, var_idx) = 1; % D_ij^{(1)} if ismember(j, downgrade1_idx) d_idx = find(downgrade1_idx == j); var_idx = d1_start + length(downgrade1_idx)*(i-1) + d_idx - 1; A5(j, var_idx) = 1; end % D_ij^{(2)} if ismember(j, downgrade2_idx) d_idx = find(downgrade2_idx == j); var_idx = d2_start + length(downgrade2_idx)*(i-1) + d_idx - 1; A5(j, var_idx) = 1; end end end constr_count = constr_count + 46; % 合并所有约束 A = [A1; A2; A3; A4; A5]; b = [b1; b2; b3; b4; b5]; % 变量边界 lb = zeros(num_vars, 1); ub = Inf(num_vars, 1); % X_ik为0-1变量 ub(x_start:x_start+3*n-1) = 1; % 整数约束：所有变量为整数 intcon = 1:num_vars; % 求解第一阶段 options = optimoptions('intlinprog', 'Display', 'iter', 'MaxTime', 600); [x1, fval1, exitflag1] = intlinprog(-f, intcon, A, b, [], [], lb, ub, options); if exitflag1 <= 0 error('第一阶段求解失败'); end total_bundles = round(fval1); fprintf('第一阶段结果：最大总捆数 = %d\n', total_bundles); %% 第二阶段：最大化第3类捆数 fprintf('\n=== 第二阶段：最大化第3类捆数 ===\n'); % 添加约束：总捆数等于第一阶段结果 A_eq1 = zeros(1, num_vars); A_eq1(x_start:x_start+3*n-1) = 1; b_eq1 = total_bundles; % 目标函数：最大化第3类捆数 f2 = zeros(num_vars, 1); for i = 1:n idx = x_start + 3*(i-1) + 2; % X_i3 f2(idx) = 1; end % 求解第二阶段 [x2, fval2, exitflag2] = intlinprog(-f2, intcon, A, b, A_eq1, b_eq1, lb, ub, options); if exitflag2 <= 0 error('第二阶段求解失败'); end spec3_bundles = round(-fval2); fprintf('第二阶段结果：第3类捆数 = %d\n', spec3_bundles); %% 第三阶段：最大化第2类捆数 fprintf('\n=== 第三阶段：最大化第2类捆数 ===\n'); % 添加约束：第3类捆数等于第二阶段结果 A_eq2 = zeros(1, num_vars); for i = 1:n idx = x_start + 3*(i-1) + 2; % X_i3 A_eq2(idx) = 1; end b_eq2 = spec3_bundles; % 目标函数：最大化第2类捆数 f3 = zeros(num_vars, 1); for i = 1:n idx = x_start + 3*(i-1) + 1; % X_i2 f3(idx) = 1; end % 求解第三阶段 [x3, fval3, exitflag3] = intlinprog(-f3, intcon, A, b, [A_eq1; A_eq2], [b_eq1; b_eq2], lb, ub, options); if exitflag3 <= 0 error('第三阶段求解失败'); end spec2_bundles = round(-fval3); spec1_bundles = total_bundles - spec3_bundles - spec2_bundles; %% 输出最终结果 fprintf('\n=== 最终优化结果 ===\n'); fprintf('总捆数: %d\n', total_bundles); fprintf('规格1捆数: %d\n', spec1_bundles); fprintf('规格2捆数: %d\n', spec2_bundles); fprintf('规格3捆数: %d\n', spec3_bundles); % 计算原料使用率 used = zeros(46, 1); for j = 1:46 for i = 1:n % C_ij idx = c_start + 46*(i-1) + j - 1; used(j) = used(j) + x3(idx); % D_ij^{(1)} if ismember(j, downgrade1_idx) d_idx = find(downgrade1_idx == j); idx = d1_start + length(downgrade1_idx)*(i-1) + d_idx - 1; used(j) = used(j) + x3(idx); end % D_ij^{(2)} if ismember(j, downgrade2_idx) d_idx = find(downgrade2_idx == j); idx = d2_start + length(downgrade2_idx)*(i-1) + d_idx - 1; used(j) = used(j) + x3(idx); end end end utilization = used ./ stocks'; fprintf('\n原料使用情况:\n'); disp(table((1:46)', lengths', stocks', used, utilization, ... 'VariableNames', {'原料ID', '长度', '库存', '使用量', '使用率'})); 第一阶段：最大化总捆数 === LP: Optimal objective value is 0.000000. 找到最优解。 Intlinprog 在根节点处停止，因为 目标值在最优值的间隙容差范围内，options.AbsoluteGapTolerance = 0。intcon 变量是 容差范围内的整数，options.IntegerTolerance = 1e-05。 第一阶段结果：最大总捆数 = 0 === 第二阶段：最大化第3类捆数 === LP: Optimal objective value is 0.000000. 找到最优解。 Intlinprog 在根节点处停止，因为 目标值在最优值的间隙容差范围内，options.AbsoluteGapTolerance = 0。intcon 变量是 容差范围内的整数，options.IntegerTolerance = 1e-05。 第二阶段结果：第3类捆数 = 0 === 第三阶段：最大化第2类捆数 === LP: Optimal objective value is 0.000000. 找到最优解。 Intlinprog 在根节点处停止，因为 目标值在最优值的间隙容差范围内，options.AbsoluteGapTolerance = 0。intcon 变量是 容差范围内的整数，options.IntegerTolerance = 1e-05。 === 最终优化结果 === 总捆数: 0 规格1捆数: 0 规格2捆数: 0 规格3捆数: 0 为什么都是0？

- 注意：即使不激活任何捆，库存约束`A5*x<=stocks`也是满足的（因为左边为0<=stocks）。 - 但是，我们期望通过最大化捆数目标来迫使求解器使用原料并形成捆。 ### 可能问题：约束太紧导致无可行解（除了全0）？ -...
filetype

获取总市值并排序的selected_stocks中没有股票，请优化代码

首先，用户提到的selected_stocks是通过get_lowest_market_value函数得到的，这个函数可能返回空列表。为什么会这样呢？可能的原因有几个： 1. **数据获取问题**：可能在获取股票数据时，某些股票在指定日期没有...
filetype

if len(years_with_price_above_MA200) == len(stock_data): # 计算EPS的年度变化率 eps_growth = stock_data['EPS'].pct_change() # 检查是否满足EPS连续增长的条件 if all(eps_growth[1:] > 0): # 从第二年开始检查 # 添加到选股结果中 selected_stocks.append(stock_data) 代码报错：Traceback (most recent call last): File "C:\Users\29360\PycharmProjects\biyesheji\demo3.py", line 220, in <module> df = get_kline(htsc_code=total_codes, time=[start_time, end_time], File "C:\Users\29360\anaconda3\envs\demo_env\lib\site-packages\insight_python\com\insight\query.py", line 34, in get_kline if htsc_code: File "C:\Users\29360\anaconda3\envs\demo_env\lib\site-packages\pandas\core\generic.py", line 1527, in __nonzero__ raise ValueError( ValueError: The truth value of a DataFrame is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

这个错误是由于在 if 语句中使用了一个 DataFrame，而 DataFrame 不... selected_stocks.append(stock_data) ``` 这个修改会将连续增长 EPS 的条件和 price_above_MA200 的条件同时满足才会将股票加入选中的股票列表。
filetype

@ApiOperation(value="秒杀三(Redis分布式队列-订阅监听)",nickname="科帮网")

HSET seckill:stocks item1 1000 item2 500 ``` 4. **死信队列处理** ```java // 失败请求转移队列 RBlockingQueue<String> deadQueue = redisson.getBlockingQueue("seckill:dead_queue"); if(failedCount >...
filetype

if __name__ == "__main__": filter_positive_stocks()

list: Filtered list including only those entries where price key has positive value. """ filtered = [stock for stock in stock_list if isinstance(stock.get('price'), (int,float)) and stock['price'] ...
filetype

【电子设计竞赛】2018年电子设计大赛A题失真度分析仪：从理论到代码实现全解析

内容概要：本文深入解析了2018年电子设计大赛A题——失真度分析仪的设计与实现。文章首先介绍了题目的背景与要求，包括谐波计算、数据显示和无线传输三个核心任务。接着详细阐述了解题思路，涵盖信号采集（ADC）、FFT分析、失真度计算、显示与无线传输等方面的技术要点。硬件设计部分重点讲解了信号调理电路、ADC电路、显示电路和无线传输电路的具体实现方法。最后提供了软件代码实现，包括ADC采样、FFT计算、失真度计算、数据显示与无线传输的代码示例。; 适合人群：对电子设计感兴趣的初学者、电子工程专业的学生及有一定基础的电子爱好者。; 使用场景及目标：①帮助读者理解失真度分析仪的工作原理和技术实现；②为准备参加类似电子设计竞赛的人提供参考；③通过实例代码加深对电子电路、信号处理和编程的理解。; 其他说明：本文不仅涵盖了理论知识，还提供了详细的代码实现，有助于读者在实践中学习和掌握相关技能。同时，文中提到的一些优化方向也为进一步探索电子设计提供了思路。
filetype

Matlab实现高斯烟羽模型源码：高效且精确的大气扩散模拟工具 Matlab

使用Matlab实现高斯烟羽模型的方法及其应用。首先解释了高斯烟羽模型的基本原理，特别是核心算法部分，包括参数校验、扩散系数的经验公式以及烟羽公式的具体实现。接着讨论了可视化部分，展示了如何利用Matlab进行空间网格生成、浓度分布的动态剖面生成和伪彩色渲染。此外，还探讨了扩散系数对模型精度的影响，并提供了不同大气稳定度条件下的系数调整方法。最后提到了模型验证过程中的一些物理规律和注意事项。 适合人群：环境科学、大气物理学及相关领域的研究人员和技术人员，尤其是那些需要进行大气污染物扩散模拟的人群。 使用场景及目标：适用于化工园区的大气扩散模拟项目，特别是在应急响应场景中预测污染物的扩散情况。目标是帮助用户理解和掌握高斯烟羽模型的实现方法，提高大气扩散模拟的效率和准确性。 其他说明：文中提到的代码片段可以直接用于实际项目中，但需要注意参数的选择和调整，以确保模型的适用性和可靠性。同时，在使用该模型时，应当引用相关文献，尊重知识产权。
filetype

模拟电路--供复习和嵌入式学习

完整的模拟电路学习笔记，也可供嵌入式学习
filetype

企业管理的信息化.doc

企业管理的信息化.doc
ZackRen
  • 粉丝: 38
上传资源 快速赚钱

最新资源