import pandas as pd import talib from typing import Dict, List, Tuple, Optional import logging from dataclasses import dataclass # 配置日志输出到控制台 logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[ logging.StreamHandler(), # 输出到控制台 logging.FileHandler('technical_analysis.log') # 输出到文件 ], force=True # 强制重新配置日志 ) @dataclass class CoinSignal: symbol: str score: float reason: str entry_price: float stop_loss: float take_profit: float timeframe: str confidence: str strategy_type: str # 短线/中线/长线 holding_period: int # 预期持仓周期（天） risk_reward_ratio: float # 风险回报比 expiry_hours: int # 选币信号有效期（小时） action_suggestion: str # 操作建议 signal_type: str = "LONG" # 新增：信号类型 LONG/SHORT direction: str = "BUY" # 新增：操作方向 BUY/SELL @dataclass class StrategyConfig: name: str primary_timeframe: str confirm_timeframe: str holding_period_days: int expiry_hours: int risk_reward_min: float risk_reward_max: float rsi_period: int macd_fast: int macd_slow: int macd_signal: int class TechnicalAnalyzer: def __init__(self): self.min_score = 60 # 提高最低选币分数，注重质量 self.max_selections = 15 # 适中的选币数量，注重质量而非数量 # 策略配置 - 重新设计时间周期 self.strategies = { '超短线': StrategyConfig( name='超短线', primary_timeframe='5m', confirm_timeframe='1m', holding_period_days=1, expiry_hours=24, risk_reward_min=1.2, risk_reward_max=1.8, rsi_period=5, macd_fast=3, macd_slow=8, macd_signal=2 ), '短线': StrategyConfig( name='短线', primary_timeframe='15m', confirm_timeframe='5m', holding_period_days=3, expiry_hours=72, risk_reward_min=1.5, risk_reward_max=2.5, rsi_period=7, macd_fast=5, macd_slow=13, macd_signal=3 ), '中线': StrategyConfig( name='中线', primary_timeframe='1h', confirm_timeframe='15m', holding_period_days=7, expiry_hours=168, # 7天 risk_reward_min=2.0, risk_reward_max=3.5, rsi_period=14, macd_fast=12, macd_slow=26, macd_signal=9 ), '波段': StrategyConfig( name='波段', primary_timeframe='4h', confirm_timeframe='1h', holding_period_days=15, expiry_hours=360, # 15天 risk_reward_min=2.5, risk_reward_max=4.0, rsi_period=14, macd_fast=12, macd_slow=26, macd_signal=9 ), '长线': StrategyConfig( name='长线', primary_timeframe='1d', confirm_timeframe='4h', holding_period_days=30, expiry_hours=720, # 30天 risk_reward_min=3.0, risk_reward_max=6.0, rsi_period=21, macd_fast=26, macd_slow=50, macd_signal=12 ), '趋势': StrategyConfig( name='趋势', primary_timeframe='1w', confirm_timeframe='1d', holding_period_days=60, expiry_hours=1440, # 60天 risk_reward_min=4.0, risk_reward_max=8.0, rsi_period=21, macd_fast=26, macd_slow=50, macd_signal=12 ) } def get_required_timeframes(self) -> Dict[str, List[str]]: """获取每个策略需要的时间周期""" return { '超短线': ['1m', '5m', '15m'], # 需要更短周期确认 '短线': ['5m', '15m', '1h'], # 短线需要分钟级别 '中线': ['15m', '1h', '4h'], # 中线需要小时级别 '波段': ['1h', '4h', '1d'], # 波段需要日内到日线 '长线': ['4h', '1d', '3d'], # 长线需要日线级别 '趋势': ['1d', '3d', '1w'] # 趋势需要周线级别 } def get_optimal_timeframes_for_analysis(self, market_conditions: Dict = None) -> List[str]: """根据市场条件动态选择最优时间周期组合""" # 基础时间周期组合 - 包含所有策略需要的时间周期 base_timeframes = ['1m', '5m', '15m', '1h', '4h', '1d', '3d', '1w'] # 如果有市场条件信息，可以进一步优化 if market_conditions: volatility = market_conditions.get('volatility', 'medium') trend_strength = market_conditions.get('trend_strength', 'medium') if volatility == 'high': # 高波动市场，增加短周期权重 return ['1m', '5m', '15m', '1h', '4h', '1d'] elif volatility == 'low': # 低波动市场，增加长周期权重 return ['1h', '4h', '1d', '3d', '1w'] return base_timeframes def determine_best_strategy(self, df: pd.DataFrame) -> str: """根据币种特性确定最佳策略 - 增强版""" try: if len(df) < 50: logging.info("数据不足50条，使用默认中线策略") return '中线' # 默认策略 recent_data = df.tail(20) # 1. 计算波动率 volatility = recent_data['close'].std() / recent_data['close'].mean() # 2. 计算价格变化速度 price_change_5d = (df.iloc[-1]['close'] - df.iloc[-5]['close']) / df.iloc[-5]['close'] # 3. 成交量特性 volume_recent = recent_data['volume'].mean() volume_avg = df['volume'].mean() volume_ratio = volume_recent / volume_avg if volume_avg > 0 else 1 logging.info(f"策略选择指标: 波动率={volatility:.3f}, 5日价格变化={price_change_5d:.3f}, 成交量比率={volume_ratio:.2f}") # 添加详细的策略选择调试信息 logging.info(f"策略选择条件判断:") logging.info(f" 超短线: volatility({volatility:.3f}) > 0.20? {volatility > 0.20}, abs_change({abs(price_change_5d):.3f}) > 0.10? {abs(price_change_5d) > 0.10}") logging.info(f" 短线: volatility({volatility:.3f}) > 0.10? {volatility > 0.10}, abs_change({abs(price_change_5d):.3f}) > 0.05? {abs(price_change_5d) > 0.05}") logging.info(f" 中线: volatility({volatility:.3f}) > 0.06? {volatility > 0.06}, volume_ratio({volume_ratio:.2f}) > 1.1? {volume_ratio > 1.1}") logging.info(f" 波段: 0.03 < volatility({volatility:.3f}) <= 0.08? {0.03 < volatility <= 0.08}") # 策略选择逻辑 - 修复条件，确保所有策略都能被选中 if volatility > 0.20 and abs(price_change_5d) > 0.10: # 极高波动，快速变化 → 超短线策略 logging.info("选择超短线策略: 极高波动且快速变化") return '超短线' elif volatility > 0.08 and abs(price_change_5d) > 0.03: # 高波动，较快变化 → 短线策略（进一步降低门槛） logging.info("选择短线策略: 高波动且较快变化") return '短线' elif volatility > 0.06 and volume_ratio > 1.1: # 中等波动，有资金关注 → 中线策略 logging.info("选择中线策略: 中等波动且有资金关注") return '中线' elif volatility > 0.03 and volatility <= 0.08: # 中低波动，适合波段操作 → 波段策略 logging.info("选择波段策略: 中低波动适合波段操作") return '波段' elif volatility <= 0.04 and volume_ratio < 1.0: # 低波动，适合长期持有 → 长线策略 logging.info("选择长线策略: 低波动适合长期持有") return '长线' elif volatility <= 0.02: # 极低波动，趋势跟踪 → 趋势策略 logging.info("选择趋势策略: 极低波动适合趋势跟踪") return '趋势' else: # 根据波动率范围选择策略 if volatility <= 0.03: logging.info("选择趋势策略: 基于波动率范围") return '趋势' elif volatility <= 0.06: logging.info("选择长线策略: 基于波动率范围") return '长线' elif volatility <= 0.10: logging.info("选择波段策略: 基于波动率范围") return '波段' else: logging.info("选择中线策略: 默认选择") return '中线' except Exception as e: logging.warning(f"策略选择失败，使用默认中线策略: {e}") return '中线' def calculate_technical_indicators(self, df: pd.DataFrame, strategy: str = '中线') -> pd.DataFrame: """计算技术指标""" if df.empty or len(df) < 50: return df config = self.strategies[strategy] # 移动平均线 df['ma20'] = talib.SMA(df['close'].values, timeperiod=20) df['ma50'] = talib.SMA(df['close'].values, timeperiod=50) df['ma200'] = talib.SMA(df['close'].values, timeperiod=200) # 根据策略使用不同参数的RSI df['rsi'] = talib.RSI(df['close'].values, timeperiod=config.rsi_period) # 根据策略使用不同参数的MACD df['macd'], df['macd_signal'], df['macd_hist'] = talib.MACD( df['close'].values, fastperiod=config.macd_fast, slowperiod=config.macd_slow, signalperiod=config.macd_signal ) # 布林带 df['bb_upper'], df['bb_middle'], df['bb_lower'] = talib.BBANDS( df['close'].values, timeperiod=20, nbdevup=2, nbdevdn=2, matype=0 ) # 成交量移动平均 df['volume_ma'] = talib.SMA(df['volume'].values, timeperiod=20) # ATR (平均真实波动范围) df['atr'] = talib.ATR(df['high'].values, df['low'].values, df['close'].values, timeperiod=14) return df def calculate_fibonacci_levels(self, df: pd.DataFrame, lookback=50) -> Dict[str, float]: """计算斐波那契回调位""" if len(df) < lookback: return {} recent_data = df.tail(lookback) high = recent_data['high'].max() low = recent_data['low'].min() diff = high - low return { 'fib_0': high, 'fib_236': high - 0.236 * diff, 'fib_382': high - 0.382 * diff, 'fib_500': high - 0.500 * diff, 'fib_618': high - 0.618 * diff, 'fib_786': high - 0.786 * diff, 'fib_100': low } def find_support_resistance(self, df: pd.DataFrame, window=20) -> Tuple[float, float]: """寻找支撑阻力位""" if len(df) < window * 2: return 0, 0 # 寻找局部高点和低点 recent_data = df.tail(window) # 获取最近的支撑和阻力 resistance = recent_data['high'].max() support = recent_data['low'].min() return support, resistance def simple_long_analysis(self, df: pd.DataFrame) -> float: """简化的多头分析 - 只看核心指标""" if len(df) < 10: return 0 score = 0 current = df.iloc[-1] recent_data = df.tail(5) # 1. 价格趋势 (30分) - 最简单直接 price_changes = recent_data['close'].pct_change().dropna() positive_days = (price_changes > 0).sum() recent_return = (current['close'] - df.iloc[-5]['close']) / df.iloc[-5]['close'] if positive_days >= 3: # 5天中3天上涨 score += 15 if 0.02 <= recent_return <= 0.15: # 5日涨幅2%-15% score += 15 # 2. 量能确认 (20分) - 简化量价分析 if 'volume' in df.columns: recent_volume = recent_data['volume'].mean() prev_volume = df.iloc[-10:-5]['volume'].mean() if len(df) >= 10 else recent_volume if recent_volume > prev_volume * 1.2: # 量能放大 score += 20 # 3. 相对位置 (20分) - 避免高位追高 if len(df) >= 20: high_20 = df.tail(20)['high'].max() low_20 = df.tail(20)['low'].min() position = (current['close'] - low_20) / (high_20 - low_20) if high_20 != low_20 else 0.5 if 0.2 <= position <= 0.7: # 中低位置 score += 20 elif position > 0.85: # 过高位置 score -= 10 # 4. 动量指标 (10分) - 只看简单RSI if 'rsi' in df.columns and not df['rsi'].isna().all(): rsi = current.get('rsi', 50) if 40 <= rsi <= 65: # RSI健康区间 score += 10 elif rsi > 75: # 过热 score -= 5 return min(max(score, 0), 70) # 限制区间 def simple_short_analysis(self, df: pd.DataFrame) -> float: """简化的空头分析 - 只看核心指标""" if len(df) < 10: return 0 score = 0 current = df.iloc[-1] recent_data = df.tail(5) # 1. 价格趋势 (30分) - 直接看下跌 price_changes = recent_data['close'].pct_change().dropna() negative_days = (price_changes < 0).sum() recent_return = (current['close'] - df.iloc[-5]['close']) / df.iloc[-5]['close'] if negative_days >= 3: # 5天中3天下跌 score += 15 if -0.15 <= recent_return <= -0.02: # 5日跌幅2%-15% score += 15 # 2. 量能确认 (20分) - 价跌量增 if 'volume' in df.columns: recent_volume = recent_data['volume'].mean() prev_volume = df.iloc[-10:-5]['volume'].mean() if len(df) >= 10 else recent_volume if recent_volume > prev_volume * 1.2: # 量能放大 score += 20 # 3. 相对位置 (20分) - 高位做空 if len(df) >= 20: high_20 = df.tail(20)['high'].max() low_20 = df.tail(20)['low'].min() position = (current['close'] - low_20) / (high_20 - low_20) if high_20 != low_20 else 0.5 if 0.6 <= position <= 0.95: # 高位区间 score += 20 elif position < 0.3: # 过低位置 score -= 10 # 4. 动量指标 (10分) - 只看RSI if 'rsi' in df.columns and not df['rsi'].isna().all(): rsi = current.get('rsi', 50) if 35 <= rsi <= 60: # RSI适中区间 score += 10 elif rsi < 25: # 过度超卖 score -= 5 return min(max(score, 0), 70) # 限制区间 def _analyze_consecutive_moves(self, df: pd.DataFrame) -> float: """分析连续上涨动量""" if len(df) < 10: return 0 score = 0 recent_closes = df['close'].tail(10).values # 计算连续上涨天数 consecutive_up = 0 for i in range(1, len(recent_closes)): if recent_closes[i] > recent_closes[i-1]: consecutive_up += 1 else: break # 计算最近3日涨幅 recent_gain = (recent_closes[-1] - recent_closes[-4]) / recent_closes[-4] if len(recent_closes) >= 4 else 0 # 连续上涨但涨幅适中得高分 if consecutive_up >= 3 and 0.03 <= recent_gain <= 0.12: # 3%-12%涨幅 score += 8 elif consecutive_up >= 2 and 0.02 <= recent_gain <= 0.08: score += 5 elif consecutive_up >= 4: # 连续上涨但可能过热 score += 3 # 价格加速上涨警告 if recent_gain > 0.20: # 超过20%涨幅减分 score -= 5 return max(score, 0) def _analyze_price_breakthrough(self, df: pd.DataFrame) -> float: """分析价格突破情况""" if len(df) < 50: return 0 score = 0 current_price = df.iloc[-1]['close'] # 1. 突破早期高点 (10分) # 计算过去20-50日的高点 historical_data = df.iloc[-50:-10] # 排除最近10天 if len(historical_data) > 0: resistance_levels = [] # 寻找局部高点 for i in range(5, len(historical_data)-5): local_high = historical_data.iloc[i]['high'] is_peak = True for j in range(max(0, i-5), min(len(historical_data), i+6)): if j != i and historical_data.iloc[j]['high'] > local_high: is_peak = False break if is_peak: resistance_levels.append(local_high) # 检查是否突破这些阻力位 for resistance in resistance_levels: if current_price > resistance * 1.01: # 突破且有一定幅度 # 检查突破的时间和幅度 breakthrough_ratio = (current_price - resistance) / resistance if breakthrough_ratio <= 0.05: # 刚刚突破，没有过度追高 score += 8 elif breakthrough_ratio <= 0.10: score += 5 break # 2. 突破近期高点 (5分) recent_high = df.tail(10)['high'].max() if current_price > recent_high * 1.005: # 突破近期高点 score += 5 return min(score, 15) def _analyze_wave_structure(self, df: pd.DataFrame) -> float: """分析波动结构 - 寻找低点抬高模式""" if len(df) < 30: return 0 score = 0 recent_data = df.tail(30) # 寻找近30天的低点 lows = [] highs = [] for i in range(3, len(recent_data)-3): current_low = recent_data.iloc[i]['low'] current_high = recent_data.iloc[i]['high'] # 判断是否为局部低点 is_local_low = True is_local_high = True for j in range(i-3, i+4): if j != i: if recent_data.iloc[j]['low'] < current_low: is_local_low = False if recent_data.iloc[j]['high'] > current_high: is_local_high = False if is_local_low: lows.append((i, current_low)) if is_local_high: highs.append((i, current_high)) # 分析低点抬高趋势 if len(lows) >= 2: # 检查最近两个低点是否抬高 latest_lows = sorted(lows, key=lambda x: x[0])[-2:] if latest_lows[1][1] > latest_lows[0][1]: # 低点抬高 score += 5 # 分析高点突破趋势 if len(highs) >= 2: latest_highs = sorted(highs, key=lambda x: x[0])[-2:] if latest_highs[1][1] > latest_highs[0][1]: # 高点突破 score += 5 return min(score, 10) def analyze_volume_price_relationship(self, df: pd.DataFrame) -> float: """分析量价关系 - 识别资金流入模式 (最高30分)""" if len(df) < 20: return 0 score = 0 # 1. 价涨量增模式分析 (15分) price_volume_score = self._analyze_price_volume_trend(df) score += price_volume_score # 2. 量能突破分析 (10分) volume_breakthrough_score = self._analyze_volume_breakthrough(df) score += volume_breakthrough_score # 3. 资金流入模式 (5分) accumulation_score = self._analyze_accumulation_pattern(df) score += accumulation_score return min(score, 30) def _analyze_price_volume_trend(self, df: pd.DataFrame) -> float: """分析价涨量增模式""" if len(df) < 15: return 0 score = 0 recent_data = df.tail(15) # 计算价格和成交量的相关性 price_changes = recent_data['close'].pct_change().dropna() volume_changes = recent_data['volume'].pct_change().dropna() if len(price_changes) >= 10 and len(volume_changes) >= 10: # 只分析上涨日的量价关系 up_days = price_changes > 0 up_price_changes = price_changes[up_days] up_volume_changes = volume_changes[up_days] if len(up_price_changes) >= 5: # 计算上涨日的量价相关性 correlation = up_price_changes.corr(up_volume_changes) if correlation > 0.5: # 强正相关 score += 10 elif correlation > 0.3: score += 6 elif correlation > 0.1: score += 3 # 分析最近5天的量价配合 recent_5 = df.tail(5) up_days_recent = (recent_5['close'].diff() > 0).sum() avg_volume_recent = recent_5['volume'].mean() avg_volume_before = df.iloc[-20:-5]['volume'].mean() if len(df) >= 20 else avg_volume_recent volume_ratio = avg_volume_recent / avg_volume_before if avg_volume_before > 0 else 1 # 上涨日多且成交量放大 if up_days_recent >= 3 and volume_ratio > 1.2: score += 5 return min(score, 15) def _analyze_volume_breakthrough(self, df: pd.DataFrame) -> float: """分析量能突破""" if len(df) < 30: return 0 score = 0 current_volume = df.iloc[-1]['volume'] avg_volume_30 = df.tail(30)['volume'].mean() avg_volume_10 = df.tail(10)['volume'].mean() # 1. 近期量能突破 volume_ratio_current = current_volume / avg_volume_30 if avg_volume_30 > 0 else 1 volume_ratio_recent = avg_volume_10 / avg_volume_30 if avg_volume_30 > 0 else 1 if volume_ratio_current > 2.0: # 当日爆量 # 检查是否伴随价格上涨 price_change = (df.iloc[-1]['close'] - df.iloc[-2]['close']) / df.iloc[-2]['close'] if price_change > 0.02: # 价涨量增 score += 6 elif price_change > 0: # 价涨但幅度不大 score += 3 if 1.3 <= volume_ratio_recent <= 2.5: # 温和持续放量 score += 4 return min(score, 10) def _analyze_accumulation_pattern(self, df: pd.DataFrame) -> float: """分析资金积累模式""" if len(df) < 20: return 0 score = 0 recent_data = df.tail(20) # 分析OBV(能量潮)趋势 # 简化版OBV计算 obv = [] obv_value = 0 for i in range(len(recent_data)): if i == 0: obv.append(obv_value) continue price_change = recent_data.iloc[i]['close'] - recent_data.iloc[i-1]['close'] volume = recent_data.iloc[i]['volume'] if price_change > 0: obv_value += volume elif price_change < 0: obv_value -= volume obv.append(obv_value) # 分析OBV趋势 if len(obv) >= 10: obv_recent = obv[-5:] # 最近5天 obv_before = obv[-10:-5] # 之前5天 if sum(obv_recent) > sum(obv_before): # OBV上升 score += 3 # 检查价格横盘但量能放大的情况(积累) price_volatility = recent_data['close'].std() / recent_data['close'].mean() volume_avg_recent = recent_data.tail(10)['volume'].mean() volume_avg_before = recent_data.head(10)['volume'].mean() if (price_volatility < 0.08 and # 价格相对稳定 volume_avg_recent > volume_avg_before * 1.2): # 但量能放大 score += 2 return min(score, 5) def analyze_technical_patterns(self, df: pd.DataFrame) -> float: """分析技术形态 - 综合K线形态和价格结构 (最高25分)""" if len(df) < 20: return 0 score = 0 # 1. K线形态识别 (15分) candlestick_score = self._analyze_enhanced_candlestick_patterns(df) score += candlestick_score # 2. 价格结构分析 (10分) structure_score = self._analyze_price_structure(df) score += structure_score return min(score, 25) def _analyze_enhanced_candlestick_patterns(self, df: pd.DataFrame) -> float: """增强型K线形态分析""" if len(df) < 10: return 0 score = 0 # 使用talib的K线形态识别 patterns = { 'hammer': talib.CDLHAMMER(df['open'], df['high'], df['low'], df['close']), 'doji': talib.CDLDOJI(df['open'], df['high'], df['low'], df['close']), 'engulfing': talib.CDLENGULFING(df['open'], df['high'], df['low'], df['close']), 'morning_star': talib.CDLMORNINGSTAR(df['open'], df['high'], df['low'], df['close']), 'three_white_soldiers': talib.CDL3WHITESOLDIERS(df['open'], df['high'], df['low'], df['close']), 'piercing': talib.CDLPIERCING(df['open'], df['high'], df['low'], df['close']), 'harami_bullish': talib.CDLHARAMI(df['open'], df['high'], df['low'], df['close']) } # 检查最近3天的K线形态 recent_signals = 0 for pattern_name, pattern_data in patterns.items(): if len(pattern_data) > 3: # 检查最近3天是否有信号 for i in range(-3, 0): if pattern_data.iloc[i] > 0: # 看涨信号 recent_signals += 1 if pattern_name in ['morning_star', 'three_white_soldiers', 'piercing']: score += 4 # 强看涨形态 elif pattern_name in ['hammer', 'engulfing']: score += 3 # 中度看涨形态 else: score += 2 # 弱看涨形态 break # 手动分析一些简单形态 manual_score = self._analyze_manual_patterns(df.tail(10)) score += manual_score return min(score, 15) def _analyze_manual_patterns(self, df: pd.DataFrame) -> float: """手动分析一些简单形态""" if len(df) < 5: return 0 score = 0 # 分析最近5天的走势 last_5 = df.tail(5) # 1. 阶段性低点上移模式 lows = last_5['low'].tolist() if len(lows) >= 3: # 检查是否有低点逐步抬高的趋势 ascending_lows = True for i in range(1, len(lows)): if lows[i] < lows[i-1] * 0.98: # 允许小幅波动 ascending_lows = False break if ascending_lows: score += 3 # 2. 突破前高点模式 current_high = df.iloc[-1]['high'] prev_highs = df.iloc[-5:-1]['high'].tolist() if current_high > max(prev_highs) * 1.01: # 突破前高 score += 2 return min(score, 5) def _analyze_price_structure(self, df: pd.DataFrame) -> float: """分析价格结构""" if len(df) < 30: return 0 score = 0 # 1. 分析关键支撑位突破 (6分) support_score = self._analyze_support_breakthrough(df) score += support_score # 2. 分析价格区间突破 (4分) range_score = self._analyze_range_breakthrough(df) score += range_score return min(score, 10) def _analyze_support_breakthrough(self, df: pd.DataFrame) -> float: """分析支撑位突破""" if len(df) < 30: return 0 score = 0 current_price = df.iloc[-1]['close'] # 寻找近30天内的重要支撑位 recent_30 = df.tail(30) # 计算支撑位(多次触及的低点) support_levels = [] for i in range(5, len(recent_30)-5): low_price = recent_30.iloc[i]['low'] # 检查这个低点是否被多次测试 test_count = 0 for j in range(len(recent_30)): if abs(recent_30.iloc[j]['low'] - low_price) / low_price < 0.02: # 2%范围内 test_count += 1 if test_count >= 2: # 至少被测试2次 support_levels.append(low_price) # 检查是否突破了这些支撑位 for support in support_levels: if current_price > support * 1.03: # 突破支撑位3%以上 score += 3 break return min(score, 6) def _analyze_range_breakthrough(self, df: pd.DataFrame) -> float: """分析区间突破""" if len(df) < 20: return 0 score = 0 recent_20 = df.tail(20) current_price = df.iloc[-1]['close'] # 计算近20天的价格区间 price_high = recent_20['high'].max() price_low = recent_20['low'].min() price_range = price_high - price_low # 检查是否在盘整后突破 if price_range > 0: # 检查是否经历了盘整阶段 middle_period = recent_20.iloc[5:15] # 中间一段 consolidation_range = middle_period['high'].max() - middle_period['low'].min() # 如果中间阶段波动较小，说明有盘整 if consolidation_range < price_range * 0.6: # 检查是否突破了区间高点 if current_price > price_high * 0.995: # 接近或突破高点 score += 4 return min(score, 4) def analyze_price_behavior(self, df: pd.DataFrame) -> float: """分析价格行为 - 核心指标 (最高35分)""" if len(df) < 30: return 0 score = 0 recent_data = df.tail(20) # 1. 连续上涨动量分析 (12分) consecutive_score = self._analyze_consecutive_moves(df) score += consecutive_score # 2. 价格突破分析 (15分) breakthrough_score = self._analyze_price_breakthrough(df) score += breakthrough_score # 3. 波动结构分析 (8分) wave_score = self._analyze_wave_structure(df) score += wave_score return min(score, 35) def analyze_breakout_potential(self, df: pd.DataFrame) -> float: """分析突破潜力 - 辅助指标 (最高20分)""" if len(df) < 30: return 0 score = 0 current = df.iloc[-1] recent_data = df.tail(20) # 1. 价格位置分析 - 寻找埋伏位置 (8分) recent_high = recent_data['high'].max() recent_low = recent_data['low'].min() price_range = recent_high - recent_low current_position = (current['close'] - recent_low) / price_range if price_range > 0 else 0 # 偏好在区间中下部的币种 if 0.2 <= current_position <= 0.5: # 理想埋伏位置 score += 6 elif 0.5 < current_position <= 0.7: # 次优位置 score += 3 elif current_position > 0.8: # 已经在高位，减分 score -= 5 # 2. 整理形态分析 (6分) volatility = recent_data['close'].std() / recent_data['close'].mean() if 0.05 <= volatility <= 0.12: # 适度整理，蓄势待发 score += 5 elif volatility < 0.03: # 过度整理，缺乏动力 score += 1 elif volatility > 0.20: # 波动过大，风险较高 score -= 3 # 3. 量能配合 (6分) volume_ratio = recent_data['volume'] / recent_data['volume'].rolling(10).mean() moderate_volume_days = ((volume_ratio >= 1.1) & (volume_ratio <= 1.8)).sum() explosive_volume_days = (volume_ratio > 2.5).sum() if moderate_volume_days >= 3: # 持续温和放量 score += 4 if explosive_volume_days <= 1: # 没有过度爆量 score += 2 return max(min(score, 20), 0) def analyze_short_signals(self, df: pd.DataFrame, strategy: str = '中线') -> Optional[CoinSignal]: """分析做空信号 - 识别下跌趋势币种""" if df.empty or len(df) < 50: return None try: df = self.calculate_technical_indicators(df, strategy) config = self.strategies[strategy] total_score = 0 reasons = [] # === 做空信号评分体系 === # 1. 空头价格行为分析 (35分) bear_price_score = self.analyze_bearish_price_behavior(df) if bear_price_score > 0: total_score += bear_price_score if bear_price_score >= 25: reasons.append(f"强势下跌信号({bear_price_score}分)") elif bear_price_score >= 15: reasons.append(f"下跌信号({bear_price_score}分)") # 2. 空头量价关系 (30分) bear_volume_score = self.analyze_bearish_volume_price(df) if bear_volume_score > 0: total_score += bear_volume_score if bear_volume_score >= 20: reasons.append(f"理想空头量价({bear_volume_score}分)") elif bear_volume_score >= 10: reasons.append(f"空头量价({bear_volume_score}分)") # 3. 空头技术形态 (25分) bear_pattern_score = self.analyze_bearish_patterns(df) if bear_pattern_score > 0: total_score += bear_pattern_score if bear_pattern_score >= 15: reasons.append(f"强空头形态({bear_pattern_score}分)") elif bear_pattern_score >= 8: reasons.append(f"空头形态({bear_pattern_score}分)") # 4. 下跌突破潜力 (20分) breakdown_score = self.analyze_breakdown_potential(df) if breakdown_score > 0: total_score += breakdown_score if breakdown_score >= 15: reasons.append(f"高下跌潜力({breakdown_score}分)") elif breakdown_score >= 8: reasons.append(f"下跌潜力({breakdown_score}分)") # 5. 均线空头系统 (10分) bear_ma_score = self.analyze_bearish_moving_average(df) if bear_ma_score > 0: total_score += bear_ma_score if bear_ma_score >= 6: reasons.append(f"均线空头({int(bear_ma_score)}分)") # 过滤低分币种 if total_score < 65: # 做空也需要足够的信号强度 return None # 确定信心等级 if total_score >= 80: confidence = "高" elif total_score >= 65: confidence = "中" else: confidence = "低" # 计算空头入场和出场位 entry_price, stop_loss, take_profit, risk_reward = self.calculate_short_entry_exit_levels(df, strategy) # 生成空头操作建议 current_price = df.iloc[-1]['close'] action_suggestion = self.generate_short_action_suggestion(df, entry_price, current_price, total_score) return CoinSignal( symbol=None, # 将在调用时设置 score=total_score, reason=" | ".join(reasons), entry_price=entry_price, stop_loss=stop_loss, take_profit=take_profit, timeframe=config.primary_timeframe, confidence=confidence, strategy_type=strategy, holding_period=config.holding_period_days, risk_reward_ratio=risk_reward, expiry_hours=config.expiry_hours, action_suggestion=action_suggestion, signal_type="SHORT", direction="SELL" ) except Exception as e: logging.error(f"分析空头信号失败: {e}") return None def analyze_bearish_price_behavior(self, df: pd.DataFrame) -> float: """分析空头价格行为 - 核心指标 (35分)""" if len(df) < 30: return 0 score = 0 recent_data = df.tail(20) # 1. 连续下跌动量 (10分) consecutive_down = 0 recent_closes = recent_data['close'].tail(10).values for i in range(1, len(recent_closes)): if recent_closes[i] < recent_closes[i-1]: consecutive_down += 1 else: break recent_decline = (recent_closes[-1] - recent_closes[-4]) / recent_closes[-4] if len(recent_closes) >= 4 else 0 if consecutive_down >= 3 and -0.12 <= recent_decline <= -0.03: # 3%-12%下跌 score += 8 elif consecutive_down >= 2 and -0.08 <= recent_decline <= -0.02: score += 5 # 2. 价格跌破分析 (15分) current_price = df.iloc[-1]['close'] # 跌破支撑位 historical_data = df.iloc[-50:-10] if len(historical_data) > 0: support_levels = [] for i in range(5, len(historical_data)-5): local_low = historical_data.iloc[i]['low'] is_valley = True for j in range(max(0, i-5), min(len(historical_data), i+6)): if j != i and historical_data.iloc[j]['low'] < local_low: is_valley = False break if is_valley: support_levels.append(local_low) for support in support_levels: if current_price < support * 0.97: # 跌破支撑位3%以上 breakdown_ratio = (support - current_price) / support if breakdown_ratio <= 0.05: # 刚刚跌破 score += 10 elif breakdown_ratio <= 0.10: score += 6 break # 3. 高点逐步下移模式 (10分) recent_highs = [] for i in range(3, len(recent_data)-3): current_high = recent_data.iloc[i]['high'] is_local_high = True for j in range(i-3, i+4): if j != i and recent_data.iloc[j]['high'] > current_high: is_local_high = False break if is_local_high: recent_highs.append((i, current_high)) if len(recent_highs) >= 2: latest_highs = sorted(recent_highs, key=lambda x: x[0])[-2:] if latest_highs[1][1] < latest_highs[0][1]: # 高点下移 score += 8 return min(score, 35) def _comprehensive_long_analysis(self, main_df: pd.DataFrame, timeframe_data: Dict, strategy: str) -> float: """综合多头分析 - 优化策略本身而非降低分数""" if len(main_df) < 30: return 0 total_score = 0 score_details = {} # 用于记录各项得分 # 1. 价格行为分析 (35分) price_score = self.analyze_price_behavior(main_df) total_score += price_score score_details['价格行为'] = price_score # 2. 量价关系 (30分) volume_score = self.analyze_volume_price_relationship(main_df) total_score += volume_score score_details['量价关系'] = volume_score # 3. 技术形态 (25分) pattern_score = self.analyze_technical_patterns(main_df) total_score += pattern_score score_details['技术形态'] = pattern_score # 4. 突破潜力 (20分) breakout_score = self.analyze_breakout_potential(main_df) total_score += breakout_score score_details['突破潜力'] = breakout_score # 5. 多时间框架确认 (15分) - 新增 multi_tf_score = self._analyze_multi_timeframe_confirmation(timeframe_data, strategy, 'LONG') total_score += multi_tf_score score_details['多时间框架确认'] = multi_tf_score # 6. 风险评估调整 (-30到+10分) - 新增 risk_adjustment = self._analyze_risk_factors(main_df, 'LONG') total_score += risk_adjustment score_details['风险评估调整'] = risk_adjustment # 记录详细评分 - 改为100分制 final_score = min(total_score, 100) logging.info(f"多头分析详细评分: 价格行为({price_score:.1f}) + 量价关系({volume_score:.1f}) + " f"技术形态({pattern_score:.1f}) + 突破潜力({breakout_score:.1f}) + " f"多时间框架({multi_tf_score:.1f}) + 风险调整({risk_adjustment:.1f}) = {final_score:.1f}") return final_score def _comprehensive_short_analysis(self, main_df: pd.DataFrame, timeframe_data: Dict, strategy: str) -> float: """综合空头分析 - 优化策略本身而非降低分数""" if len(main_df) < 30: return 0 total_score = 0 score_details = {} # 用于记录各项得分 # 1. 空头价格行为 (35分) bear_price_score = self.analyze_bearish_price_behavior(main_df) total_score += bear_price_score score_details['空头价格行为'] = bear_price_score # 2. 空头量价关系 (30分) bear_volume_score = self.analyze_bearish_volume_price(main_df) total_score += bear_volume_score score_details['空头量价关系'] = bear_volume_score # 3. 空头技术形态 (25分) bear_pattern_score = self.analyze_bearish_patterns(main_df) total_score += bear_pattern_score score_details['空头技术形态'] = bear_pattern_score # 4. 下跌突破潜力 (20分) breakdown_score = self.analyze_breakdown_potential(main_df) total_score += breakdown_score score_details['下跌突破潜力'] = breakdown_score # 5. 多时间框架确认 (15分) - 新增 multi_tf_score = self._analyze_multi_timeframe_confirmation(timeframe_data, strategy, 'SHORT') total_score += multi_tf_score score_details['多时间框架确认'] = multi_tf_score # 6. 风险评估调整 (-30到+10分) - 新增 risk_adjustment = self._analyze_risk_factors(main_df, 'SHORT') total_score += risk_adjustment score_details['风险评估调整'] = risk_adjustment # 记录详细评分 - 改为100分制 final_score = min(total_score, 100) logging.info(f"空头分析详细评分: 空头价格行为({bear_price_score:.1f}) + 空头量价关系({bear_volume_score:.1f}) + " f"空头技术形态({bear_pattern_score:.1f}) + 下跌突破潜力({breakdown_score:.1f}) + " f"多时间框架({multi_tf_score:.1f}) + 风险调整({risk_adjustment:.1f}) = {final_score:.1f}") return final_score def _analyze_multi_timeframe_confirmation(self, timeframe_data: Dict, strategy: str, signal_type: str) -> float: """多时间框架确认分析""" score = 0 config = self.strategies[strategy] # 获取确认时间框架数据 confirm_df = timeframe_data.get(config.confirm_timeframe) if confirm_df is None or len(confirm_df) < 20: return 0 confirm_df = self.calculate_technical_indicators(confirm_df, strategy) if signal_type == 'LONG': # 确认时间框架的多头信号 confirm_price_score = self.simple_long_analysis(confirm_df) if confirm_price_score >= 30: score += 15 elif confirm_price_score >= 20: score += 10 elif confirm_price_score >= 15: score += 5 else: # SHORT # 确认时间框架的空头信号 confirm_price_score = self.simple_short_analysis(confirm_df) if confirm_price_score >= 40: score += 15 elif confirm_price_score >= 30: score += 10 elif confirm_price_score >= 20: score += 5 return score def _analyze_risk_factors(self, df: pd.DataFrame, signal_type: str) -> float: """风险因素分析""" if len(df) < 20: return 0 score = 0 current = df.iloc[-1] recent_data = df.tail(20) # 1. RSI过热/过冷检查 if hasattr(current, 'rsi'): rsi = current['rsi'] if signal_type == 'LONG': if rsi > 80: # 严重超买 score -= 15 elif rsi > 70: # 超买 score -= 8 elif 40 <= rsi <= 65: # 健康区间 score += 5 else: # SHORT if rsi < 20: # 严重超卖 score -= 15 elif rsi < 30: # 超卖 score -= 8 elif 35 <= rsi <= 60: # 健康区间 score += 5 # 2. 价格位置风险 recent_high = recent_data['high'].max() recent_low = recent_data['low'].min() price_range = recent_high - recent_low current_position = (current['close'] - recent_low) / price_range if price_range > 0 else 0.5 if signal_type == 'LONG': if current_position > 0.9: # 极高位置 score -= 20 elif current_position > 0.8: # 高位置 score -= 10 elif 0.2 <= current_position <= 0.6: # 理想位置 score += 5 else: # SHORT if current_position < 0.1: # 极低位置 score -= 20 elif current_position < 0.2: # 低位置 score -= 10 elif 0.4 <= current_position <= 0.8: # 理想位置 score += 5 # 3. 成交量异常检查 if hasattr(current, 'volume') and hasattr(current, 'volume_ma'): volume_ratio = current['volume'] / current['volume_ma'] if current['volume_ma'] > 0 else 1 if volume_ratio > 5: # 异常爆量 score -= 10 elif volume_ratio < 0.3: # 成交量萎缩 score -= 5 return max(min(score, 10), -30) def analyze_volume_accumulation(self, df: pd.DataFrame) -> float: """分析成交量积累模式""" if len(df) < 20: return 0 score = 0 recent_data = df.tail(10) # 寻找温和放量而非暴涨放量 volume_ratio = recent_data['volume'] / recent_data['volume_ma'] # 温和持续放量(1.2-2倍)比突然暴涨放量更好 moderate_volume_days = ((volume_ratio >= 1.2) & (volume_ratio <= 2.0)).sum() explosive_volume_days = (volume_ratio > 3.0).sum() if moderate_volume_days >= 3: # 持续温和放量 score += 15 if explosive_volume_days >= 2: # 已经暴涨放量，减分 score -= 10 return min(score, 20) def check_early_trend_signals(self, df: pd.DataFrame) -> float: """检查早期趋势信号""" if len(df) < 50: return 0 score = 0 current = df.iloc[-1] prev = df.iloc[-2] # 1. 均线金叉但涨幅不大 if (prev['ma20'] <= prev['ma50'] and current['ma20'] > current['ma50']): # 刚刚金叉，还未大涨 recent_gain = (current['close'] - df.iloc[-5]['close']) / df.iloc[-5]['close'] if recent_gain < 0.10: # 5日涨幅小于10% score += 20 elif recent_gain > 0.25: # 已经涨幅过大 score -= 15 # 2. RSI从超卖区域回升但未超买 if 35 <= current['rsi'] <= 55: # 从底部回升但未过热 score += 10 elif current['rsi'] > 70: # 已经超买 score -= 20 # 3. MACD即将金叉或刚刚金叉 if current['macd'] > current['macd_signal']: # 检查金叉时间 macd_cross_days = 0 for i in range(1, min(6, len(df))): if df.iloc[-i]['macd'] <= df.iloc[-i]['macd_signal']: macd_cross_days = i - 1 break if macd_cross_days <= 2: # 刚刚金叉2天内 score += 15 elif macd_cross_days >= 10: # 金叉很久了 score -= 10 return min(score, 25) def analyze_candlestick_patterns(self, df: pd.DataFrame) -> float: """分析K线形态""" if len(df) < 20: return 0 score = 0 # 使用talib的K线形态识别 patterns = { 'hammer': talib.CDLHAMMER(df['open'], df['high'], df['low'], df['close']), 'doji': talib.CDLDOJI(df['open'], df['high'], df['low'], df['close']), 'engulfing': talib.CDLENGULFING(df['open'], df['high'], df['low'], df['close']), 'morning_star': talib.CDLMORNINGSTAR(df['open'], df['high'], df['low'], df['close']), 'three_white_soldiers': talib.CDL3WHITESOLDIERS(df['open'], df['high'], df['low'], df['close']) } # 检查最近的K线形态 recent_signals = 0 for pattern_name, pattern_data in patterns.items(): if len(pattern_data) > 0 and pattern_data.iloc[-1] > 0: recent_signals += 1 if pattern_name in ['morning_star', 'three_white_soldiers']: score += 15 elif pattern_name in ['hammer', 'engulfing']: score += 10 else: score += 5 return min(score, 20) def analyze_moving_average_trend(self, df: pd.DataFrame) -> float: """分析均线系统""" if len(df) < 50: return 0 score = 0 current = df.iloc[-1] # 均线多头排列 if current['close'] > current['ma20'] > current['ma50']: score += 15 # 价格突破关键均线 prev = df.iloc[-2] if prev['close'] <= prev['ma20'] and current['close'] > current['ma20']: score += 10 # 均线斜率向上 ma20_slope = (current['ma20'] - df.iloc[-5]['ma20']) / 5 if ma20_slope > 0: score += 5 return min(score, 25) def analyze_momentum_indicators(self, df: pd.DataFrame) -> float: """分析动量指标""" if len(df) < 20: return 0 score = 0 current = df.iloc[-1] # RSI分析 if 30 <= current['rsi'] <= 50: # RSI从超卖区域回升 score += 10 elif 50 <= current['rsi'] <= 70: # RSI强势但未超买 score += 5 # MACD分析 if current['macd'] > current['macd_signal'] and current['macd_hist'] > 0: score += 10 # MACD金叉 prev = df.iloc[-2] if prev['macd'] <= prev['macd_signal'] and current['macd'] > current['macd_signal']: score += 15 return min(score, 25) def calculate_entry_exit_levels(self, df: pd.DataFrame, fib_levels: Dict, strategy: str) -> Tuple[float, float, float]: """计算入场、止损、止盈位""" current_price = df.iloc[-1]['close'] atr = df.iloc[-1]['atr'] support, resistance = self.find_support_resistance(df) config = self.strategies[strategy] # 入场价策略 - 不使用当前市价，而是基于技术分析 ma20 = df.iloc[-1]['ma20'] ma50 = df.iloc[-1]['ma50'] # 策略1: 均线回踩入场 if current_price > ma20 > ma50: # 多头趋势 # 等待回踩MA20附近入场，给出5%的缓冲 entry_price = ma20 * 1.02 # MA20上方2% else: # 策略2: 突破确认入场 # 等待突破近期阻力位 recent_high = df.tail(10)['high'].max() if current_price >= recent_high * 0.98: # 接近突破 entry_price = recent_high * 1.005 # 突破确认价位 else: # 策略3: 斐波那契回调入场 if fib_levels and 'fib_618' in fib_levels: entry_price = max(fib_levels['fib_618'], current_price * 0.98) else: # 策略4: 当前价格适当下方等待 entry_price = current_price * 0.995 # 当前价下方0.5% # 确保入场价不会过低(距离当前价不超过5%) if entry_price < current_price * 0.95: entry_price = current_price * 0.98 # 止损位: 支撑位下方或ATR的1.5倍 stop_loss_atr = entry_price - (atr * 1.5) stop_loss_support = support * 0.98 if support > 0 else entry_price * 0.92 stop_loss = max(stop_loss_atr, stop_loss_support) # 根据策略动态设置风险回报比 risk = entry_price - stop_loss target_ratio = (config.risk_reward_min + config.risk_reward_max) / 2 take_profit_ratio = entry_price + (risk * target_ratio) # 如果有阻力位，取较小值 if resistance > entry_price: take_profit_resistance = resistance * 0.98 take_profit = min(take_profit_ratio, take_profit_resistance) else: take_profit = take_profit_ratio # 计算实际风险回报比 actual_risk_reward = (take_profit - entry_price) / risk if risk > 0 else target_ratio return entry_price, stop_loss, take_profit, actual_risk_reward def generate_action_suggestion(self, df: pd.DataFrame, signal: CoinSignal, current_price: float) -> str: """根据评分和价格位置生成操作建议""" try: # 计算价格差异百分比 entry_diff = (current_price - signal.entry_price) / signal.entry_price * 100 # 获取技术指标状态 current = df.iloc[-1] recent_data = df.tail(10) # 计算价格在最近区间的位置 recent_high = recent_data['high'].max() recent_low = recent_data['low'].min() price_range = recent_high - recent_low current_position = (current_price - recent_low) / price_range if price_range > 0 else 0.5 # 基于评分等级的基础建议 if signal.score >= 85: # 高分 if entry_diff <= 1: # 接近建议价位 if current_position <= 0.4: # 在低位 return "立即买入" elif current_position <= 0.6: return "现价买入" else: return "等待回调买入" elif entry_diff <= 3: # 稍高于建议价位 if signal.strategy_type == "短线": return "现价买入" else: return "等待回调买入" else: # 明显高于建议价位 return "等待大幅回调" elif signal.score >= 70: # 中等分数 if entry_diff <= -2: # 低于建议价位 return "现价买入" elif entry_diff <= 1: # 接近建议价位 if current_position <= 0.5: return "现价买入" else: return "等待回调买入" elif entry_diff <= 5: # 高于建议价位 return "等待回调买入" else: return "暂时观望" else: # 较低分数 (60-70) if entry_diff <= -3: # 明显低于建议价位 return "分批买入" elif entry_diff <= 0: # 低于或等于建议价位 if current_position <= 0.3: return "小仓位试探" else: return "等待回调买入" elif entry_diff <= 3: return "等待回调买入" else: return "暂时观望" return "等待回调买入" # 默认建议 except Exception as e: logging.error(f"生成操作建议时出错: {e}") return "谨慎观望" def analyze_single_coin(self, symbol: str, timeframe_data: Dict[str, pd.DataFrame], volume_24h_usd: float = 0) -> List[CoinSignal]: """分析单个币种 - 优化策略""" try: logging.info(f"\n=== 开始分析 {symbol} ===") logging.info(f"24小时交易量: ${volume_24h_usd:,.0f}") # 先执行基础分析，即使交易量不够也要显示评分 basic_analysis_executed = False # 24小时交易量过滤 - 但仍然显示评分 if volume_24h_usd < 10_000_000: # 降低到1000万美金进行调试 logging.info(f"{symbol} 交易量不足1000万美金，但仍显示评分") # 继续执行分析以显示评分，但最后返回空列表 basic_analysis_executed = True signals = [] # 首先使用4h数据确定最适合的策略 initial_df = timeframe_data.get('4h') if initial_df is None or len(initial_df) < 20: logging.info(f"{symbol} 4h数据不足，跳过分析") return [] # 确定最佳策略 best_strategy = self.determine_best_strategy(initial_df) config = self.strategies[best_strategy] logging.info(f"{symbol} 选择策略: {best_strategy} (主时间周期: {config.primary_timeframe}, 确认时间周期: {config.confirm_timeframe})") # 检查可用的时间周期数据 available_timeframes = list(timeframe_data.keys()) logging.info(f"{symbol} 可用时间周期: {available_timeframes}") # 获取策略对应的主要时间周期数据 main_df = timeframe_data.get(config.primary_timeframe) if main_df is None or len(main_df) < 20: # 尝试使用该策略的确认时间周期 confirm_df = timeframe_data.get(config.confirm_timeframe) if confirm_df is not None and len(confirm_df) >= 20: main_df = confirm_df logging.info(f"{symbol} 使用确认时间周期{config.confirm_timeframe}替代主时间周期{config.primary_timeframe}") else: # 最后才回退到初始数据和中线策略 main_df = initial_df config = self.strategies['中线'] best_strategy = '中线' logging.info(f"{symbol} 数据不足，回退到中线策略") # 使用策略相应的参数计算技术指标 main_df = self.calculate_technical_indicators(main_df, best_strategy) # === 综合多头信号分析 === logging.info(f"\n--- {symbol} 多头分析 ---") long_score = self._comprehensive_long_analysis(main_df, timeframe_data, best_strategy) # 记录多头分析结果（不管是否通过筛选） logging.info(f"{symbol} 多头分析结果: {long_score:.1f}/100分 (门槛: 70分)") if long_score >= 70: # 70分入选门槛 logging.info(f"✓ {symbol} 多头信号通过筛选") # 计算入场出场位 entry_price, stop_loss, take_profit, risk_reward = self.calculate_entry_exit_levels( main_df, {}, best_strategy ) # 确定信心等级 - 基于100分制 if long_score >= 85: confidence = "高" elif long_score >= 75: confidence = "中" else: confidence = "低" # 生成操作建议 - 基于综合分析 current_price = main_df.iloc[-1]['close'] action_suggestion = "现价买入" if long_score >= 85 else "等待回调买入" logging.info(f"{symbol} 多头信号详情: 入场${entry_price:.4f}, 止损${stop_loss:.4f}, 止盈${take_profit:.4f}, 风险回报比1:{risk_reward:.2f}") long_signal = CoinSignal( symbol=symbol, score=long_score, reason=f"综合多头分析: 高质量信号({long_score}分)", entry_price=entry_price, stop_loss=stop_loss, take_profit=take_profit, timeframe=config.primary_timeframe, confidence=confidence, strategy_type=best_strategy, holding_period=config.holding_period_days, risk_reward_ratio=risk_reward, expiry_hours=config.expiry_hours, action_suggestion=action_suggestion, signal_type="LONG", direction="BUY" ) signals.append(long_signal) else: logging.info(f"✗ {symbol} 多头信号未通过筛选 (差距: {70 - long_score:.1f}分)") # === 综合空头信号分析 === logging.info(f"\n--- {symbol} 空头分析 ---") short_score = self._comprehensive_short_analysis(main_df, timeframe_data, best_strategy) # 记录空头分析结果（不管是否通过筛选） logging.info(f"{symbol} 空头分析结果: {short_score:.1f}/100分 (门槛: 70分)") if short_score >= 70: # 与多头门槛保持一致 logging.info(f"✓ {symbol} 空头信号通过筛选") # 计算入场出场位 entry_price, stop_loss, take_profit, risk_reward = self.calculate_short_entry_exit_levels( main_df, best_strategy ) # 确定信心等级 - 基于100分制 if short_score >= 85: confidence = "高" elif short_score >= 75: confidence = "中" else: confidence = "低" # 生成操作建议 - 基于综合分析 current_price = main_df.iloc[-1]['close'] action_suggestion = "现价做空" if short_score >= 85 else "等待反弹做空" logging.info(f"{symbol} 空头信号详情: 入场${entry_price:.4f}, 止损${stop_loss:.4f}, 止盈${take_profit:.4f}, 风险回报比1:{risk_reward:.2f}") short_signal = CoinSignal( symbol=symbol, score=short_score, reason=f"综合空头分析: 高质量信号({short_score}分)", entry_price=entry_price, stop_loss=stop_loss, take_profit=take_profit, timeframe=config.primary_timeframe, confidence=confidence, strategy_type=best_strategy, holding_period=config.holding_period_days, risk_reward_ratio=risk_reward, expiry_hours=config.expiry_hours, action_suggestion=action_suggestion, signal_type="SHORT", direction="SELL" ) signals.append(short_signal) else: logging.info(f"✗ {symbol} 空头信号未通过筛选 (差距: {70 - short_score:.1f}分)") # 总结该币种分析结果 if signals: signal_types = [s.signal_type for s in signals] logging.info(f"{symbol} 分析完成 - 生成{len(signals)}个信号: {', '.join(signal_types)}") else: logging.info(f"{symbol} 分析完成 - 无符合条件的信号 (多头:{long_score:.1f}, 空头:{short_score:.1f})") # 如果是因为交易量不足而跳过，返回空列表 if basic_analysis_executed: logging.info(f"{symbol} 因交易量不足，不生成实际交易信号") return [] return signals except Exception as e: logging.error(f"分析{symbol}时出错: {e}") return [] def analyze_single_coin_with_strategy(self, symbol: str, timeframe_data: Dict[str, pd.DataFrame], volume_24h_usd: float, strategy_name: str) -> List[CoinSignal]: """使用指定策略分析单个币种""" try: # 24小时交易量过滤 if volume_24h_usd < 50_000_000: return [] # 验证策略是否存在 if strategy_name not in self.strategies: logging.error(f"未知策略: {strategy_name}") return [] config = self.strategies[strategy_name] # 获取策略对应的主要时间周期数据 main_df = timeframe_data.get(config.primary_timeframe) if main_df is None or len(main_df) < 20: return [] # 使用策略相应的参数计算技术指标 main_df = self.calculate_technical_indicators(main_df, strategy_name) signals = [] # 综合多头信号分析 long_score = self._comprehensive_long_analysis(main_df, timeframe_data, strategy_name) if long_score >= 80: # 生成多头信号 entry_price, stop_loss, take_profit, risk_reward = self.calculate_entry_exit_levels( main_df, {}, strategy_name ) confidence = "高" if long_score >= 85 else "中" if long_score >= 75 else "低" action_suggestion = "现价买入" if long_score >= 85 else "等待回调买入" long_signal = CoinSignal( symbol=symbol, score=long_score, reason=f"{strategy_name}策略多头信号({long_score}分)", entry_price=entry_price, stop_loss=stop_loss, take_profit=take_profit, timeframe=config.primary_timeframe, confidence=confidence, strategy_type=strategy_name, holding_period=config.holding_period_days, risk_reward_ratio=risk_reward, expiry_hours=config.expiry_hours, action_suggestion=action_suggestion, signal_type="LONG", direction="BUY" ) signals.append(long_signal) # 综合空头信号分析 short_score = self._comprehensive_short_analysis(main_df, timeframe_data, strategy_name) if short_score >= 90: # 生成空头信号 entry_price, stop_loss, take_profit, risk_reward = self.calculate_short_entry_exit_levels( main_df, strategy_name ) confidence = "高" if short_score >= 85 else "中" if short_score >= 75 else "低" action_suggestion = "现价做空" if short_score >= 85 else "等待反弹做空" short_signal = CoinSignal( symbol=symbol, score=short_score, reason=f"{strategy_name}策略空头信号({short_score}分)", entry_price=entry_price, stop_loss=stop_loss, take_profit=take_profit, timeframe=config.primary_timeframe, confidence=confidence, strategy_type=strategy_name, holding_period=config.holding_period_days, risk_reward_ratio=risk_reward, expiry_hours=config.expiry_hours, action_suggestion=action_suggestion, signal_type="SHORT", direction="SELL" ) signals.append(short_signal) return signals except Exception as e: logging.error(f"使用{strategy_name}策略分析{symbol}时出错: {e}") return [] def _analyze_long_signal(self, symbol: str, main_df: pd.DataFrame, timeframe_data: Dict, config: StrategyConfig, best_strategy: str) -> Optional[CoinSignal]: """分析多头信号 - 原有逻辑""" total_score = 0 reasons = [] # === 核心评分体系：以价格行为和技术形态为主导 === # 1. 价格行为分析 - 最重要 (最高35分) price_behavior_score = self.analyze_price_behavior(main_df) if price_behavior_score > 0: total_score += price_behavior_score if price_behavior_score >= 25: reasons.append(f"强势价格行为({price_behavior_score}分)") elif price_behavior_score >= 15: reasons.append(f"积极价格行为({price_behavior_score}分)") # 2. 量价关系分析 - 核心指标 (最高30分) volume_price_score = self.analyze_volume_price_relationship(main_df) if volume_price_score > 0: total_score += volume_price_score if volume_price_score >= 20: reasons.append(f"理想量价配合({volume_price_score}分)") elif volume_price_score >= 10: reasons.append(f"量价配合({volume_price_score}分)") # 3. 技术形态确认 - 重要指标 (最高25分) pattern_score = self.analyze_technical_patterns(main_df) if pattern_score > 0: total_score += pattern_score if pattern_score >= 15: reasons.append(f"强势技术形态({pattern_score}分)") elif pattern_score >= 8: reasons.append(f"技术形态({pattern_score}分)") # 4. 突破潜力分析 - 寻找爆发机会 (最高20分) breakout_score = self.analyze_breakout_potential(main_df) if breakout_score > 0: total_score += breakout_score if breakout_score >= 15: reasons.append(f"高突破潜力({breakout_score}分)") elif breakout_score >= 8: reasons.append(f"突破潜力({breakout_score}分)") # 5. 均线系统 - 辅助确认 (最高10分，权重降低) ma_score = self.analyze_moving_average_trend(main_df) if ma_score > 0: ma_score = min(ma_score * 0.4, 10) # 大幅降低权重 total_score += ma_score if ma_score >= 6: reasons.append(f"均线支撑({int(ma_score)}分)") # 6. 确认时间周期验证 - 多周期确认 (最高5分) confirm_df = timeframe_data.get(config.confirm_timeframe) if confirm_df is not None and len(confirm_df) > 20: confirm_df = self.calculate_technical_indicators(confirm_df, best_strategy) confirm_score = self.analyze_price_behavior(confirm_df) * 0.2 # 降低权重 if confirm_score > 3: total_score += min(confirm_score, 5) reasons.append(f"{config.confirm_timeframe}确认") # 过滤低分币种 - 适度放宽条件 if price_behavior_score < 5 and volume_price_score < 5: # 降低要求 return None # 适度放宽的分数过滤 min_total_score = 50 # 降低最低门槛 if total_score < min_total_score: return None # 计算新波那契回调位 fib_levels = self.calculate_fibonacci_levels(main_df) # 计算入场和出场位 - 使用对应策略 entry_price, stop_loss, take_profit, risk_reward = self.calculate_entry_exit_levels( main_df, fib_levels, best_strategy ) # 确定信心等级 - 适度放宽标准 if total_score >= 75: # 降低高信心阈值 confidence = "高" elif total_score >= 55: # 降低中等信心阈值 confidence = "中" else: confidence = "低" # 生成操作建议 current_price = main_df.iloc[-1]['close'] temp_signal = CoinSignal( symbol=symbol, score=total_score, reason=" | ".join(reasons), entry_price=entry_price, stop_loss=stop_loss, take_profit=take_profit, timeframe=config.primary_timeframe, confidence=confidence, strategy_type=best_strategy, holding_period=config.holding_period_days, risk_reward_ratio=risk_reward, expiry_hours=config.expiry_hours, action_suggestion="", # 临时占位 signal_type="LONG", direction="BUY" ) # 生成操作建议 action_suggestion = self.generate_action_suggestion(main_df, temp_signal, current_price) return CoinSignal( symbol=symbol, score=total_score, reason=" | ".join(reasons), entry_price=entry_price, stop_loss=stop_loss, take_profit=take_profit, timeframe=config.primary_timeframe, confidence=confidence, strategy_type=best_strategy, holding_period=config.holding_period_days, risk_reward_ratio=risk_reward, expiry_hours=config.expiry_hours, action_suggestion=action_suggestion, signal_type="LONG", direction="BUY" ) def select_coins(self, market_data: Dict[str, Dict]) -> Dict[str, List[CoinSignal]]: """批量选币 - 使用优化策略""" logging.info(f"\n{'='*60}") logging.info(f"开始批量选币分析，共{len(market_data)}个币种") logging.info(f"{'='*60}") long_signals = [] short_signals = [] filtered_count = 0 low_volume_count = 0 strategy_stats = {} # 统计各策略使用次数 all_scores = [] # 记录所有币种的评分 for i, (symbol, data) in enumerate(market_data.items(), 1): logging.info(f"\n进度: {i}/{len(market_data)} - 分析{symbol}") timeframe_data = data.get('timeframes', {}) volume_24h_usd = data.get('volume_24h_usd', 0) # 24小时交易量过滤统计 if volume_24h_usd < 10_000_000: # 降低到1000万进行调试 low_volume_count += 1 logging.info(f"{symbol} 交易量过滤: ${volume_24h_usd:,.0f} < $10,000,000") continue signals = self.analyze_single_coin(symbol, timeframe_data, volume_24h_usd) # 获取该币种的评分信息（用于统计） try: # 重新计算评分用于统计（避免重复计算，这里简化处理） initial_df = timeframe_data.get('4h') if initial_df is not None and len(initial_df) >= 20: best_strategy = self.determine_best_strategy(initial_df) config = self.strategies[best_strategy] main_df = timeframe_data.get(config.primary_timeframe, initial_df) if len(main_df) >= 20: main_df = self.calculate_technical_indicators(main_df, best_strategy) temp_long_score = self._comprehensive_long_analysis(main_df, timeframe_data, best_strategy) temp_short_score = self._comprehensive_short_analysis(main_df, timeframe_data, best_strategy) all_scores.append({ 'symbol': symbol, 'strategy': best_strategy, 'long_score': temp_long_score, 'short_score': temp_short_score, 'volume_24h': volume_24h_usd }) except Exception as e: logging.debug(f"获取{symbol}评分统计信息失败: {e}") for signal in signals: if signal: # 统计策略使用情况 strategy_key = signal.strategy_type if strategy_key not in strategy_stats: strategy_stats[strategy_key] = {'long': 0, 'short': 0, 'total': 0} # 使用统一的70分门槛 if signal.score >= 70: # 统一70分入选门槛 if signal.signal_type == "LONG": long_signals.append(signal) strategy_stats[strategy_key]['long'] += 1 strategy_stats[strategy_key]['total'] += 1 logging.info(f"✓ {symbol} 多头信号入选: {signal.score:.1f}分 ({signal.strategy_type})") elif signal.signal_type == "SHORT": short_signals.append(signal) strategy_stats[strategy_key]['short'] += 1 strategy_stats[strategy_key]['total'] += 1 logging.info(f"✓ {symbol} 空头信号入选: {signal.score:.1f}分 ({signal.strategy_type})") else: filtered_count += 1 logging.info(f"✗ {symbol} {signal.signal_type}信号过滤: {signal.score:.1f}分 < 80分") # 按分数排序 long_signals.sort(key=lambda x: x.score, reverse=True) short_signals.sort(key=lambda x: x.score, reverse=True) # 选择最优信号 - 统一70分门槛 def filter_quality_signals(signals): quality_signals = [] for signal in signals: # 只选择符合70分门槛的信号 if signal.score >= 80: # 优质信号优先 quality_signals.append(signal) elif len(quality_signals) < self.max_selections and signal.score >= 70: # 补充达标信号 quality_signals.append(signal) return quality_signals[:self.max_selections] selected_long_signals = filter_quality_signals(long_signals) selected_short_signals = filter_quality_signals(short_signals) # 详细统计信息 logging.info(f"\n{'='*60}") logging.info("批量选币分析完成 - 详细统计") logging.info(f"{'='*60}") logging.info(f"总币种数量: {len(market_data)}") logging.info(f"交易量过滤: {low_volume_count}个") logging.info(f"分数过滤: {filtered_count}个") logging.info(f"原始信号: 多头{len(long_signals)}个, 空头{len(short_signals)}个") logging.info(f"最终选择: 多头{len(selected_long_signals)}个, 空头{len(selected_short_signals)}个") # 策略分布统计 if strategy_stats: logging.info(f"\n策略使用分布:") for strategy, stats in sorted(strategy_stats.items(), key=lambda x: x[1]['total'], reverse=True): logging.info(f" {strategy}: {stats['total']}个信号 (多头{stats['long']}, 空头{stats['short']})") # 评分分布统计 if all_scores: logging.info(f"\n全部币种评分分布:") long_scores = [item['long_score'] for item in all_scores] short_scores = [item['short_score'] for item in all_scores] # 多头评分统计 long_high = len([s for s in long_scores if s >= 80]) long_medium = len([s for s in long_scores if 60 <= s < 80]) long_low = len([s for s in long_scores if 40 <= s < 60]) long_very_low = len([s for s in long_scores if s < 40]) logging.info(f" 多头评分分布: ≥80分({long_high}个), 60-79分({long_medium}个), 40-59分({long_low}个), <40分({long_very_low}个)") # 空头评分统计 short_high = len([s for s in short_scores if s >= 90]) short_medium = len([s for s in short_scores if 70 <= s < 90]) short_low = len([s for s in short_scores if 50 <= s < 70]) short_very_low = len([s for s in short_scores if s < 50]) logging.info(f" 空头评分分布: ≥90分({short_high}个), 70-89分({short_medium}个), 50-69分({short_low}个), <50分({short_very_low}个)") # 显示前10名多头和空头候选 top_long_candidates = sorted(all_scores, key=lambda x: x['long_score'], reverse=True)[:10] top_short_candidates = sorted(all_scores, key=lambda x: x['short_score'], reverse=True)[:10] logging.info(f"\n前10名多头候选:") for i, item in enumerate(top_long_candidates, 1): status = "✓入选" if any(s.symbol == item['symbol'] and s.signal_type == "LONG" for s in selected_long_signals) else "未选中" logging.info(f" {i:2d}. {item['symbol']:12s}: {item['long_score']:5.1f}分 ({item['strategy']}) - {status}") logging.info(f"\n前10名空头候选:") for i, item in enumerate(top_short_candidates, 1): status = "✓入选" if any(s.symbol == item['symbol'] and s.signal_type == "SHORT" for s in selected_short_signals) else "未选中" logging.info(f" {i:2d}. {item['symbol']:12s}: {item['short_score']:5.1f}分 ({item['strategy']}) - {status}") # 最终信号详情 if selected_long_signals: logging.info(f"\n最终多头信号详情:") for i, signal in enumerate(selected_long_signals, 1): logging.info(f" {i}. {signal.symbol}: {signal.score:.1f}分 ({signal.strategy_type}-{signal.confidence})") if selected_short_signals: logging.info(f"\n最终空头信号详情:") for i, signal in enumerate(selected_short_signals, 1): logging.info(f" {i}. {signal.symbol}: {signal.score:.1f}分 ({signal.strategy_type}-{signal.confidence})") return { 'long': selected_long_signals, 'short': selected_short_signals, 'all': selected_long_signals + selected_short_signals } # === 空头分析方法 === def analyze_bearish_volume_price(self, df: pd.DataFrame) -> float: """分析空头量价关系 (30分)""" if len(df) < 20: return 0 score = 0 recent_data = df.tail(15) # 计算价格和成交量的相关性 price_changes = recent_data['close'].pct_change().dropna() volume_changes = recent_data['volume'].pct_change().dropna() if len(price_changes) >= 10 and len(volume_changes) >= 10: # 分析下跌日的量价关系 down_days = price_changes < 0 down_price_changes = price_changes[down_days] down_volume_changes = volume_changes[down_days] if len(down_price_changes) >= 5: # 计算下跌日的量价相关性 correlation = down_price_changes.corr(down_volume_changes) if correlation < -0.5: # 强负相关（价跌量增） score += 15 elif correlation < -0.3: score += 10 elif correlation < -0.1: score += 5 # 分析最近5天的量价配合 recent_5 = df.tail(5) down_days_recent = (recent_5['close'].diff() < 0).sum() avg_volume_recent = recent_5['volume'].mean() avg_volume_before = df.iloc[-20:-5]['volume'].mean() if len(df) >= 20 else avg_volume_recent volume_ratio = avg_volume_recent / avg_volume_before if avg_volume_before > 0 else 1 # 下跌日多且成交量放大 if down_days_recent >= 3 and volume_ratio > 1.2: score += 15 return min(score, 30) def analyze_bearish_patterns(self, df: pd.DataFrame) -> float: """分析空头技术形态 (25分)""" if len(df) < 20: return 0 score = 0 # 使用talib的K线形态识别（空头形态） patterns = { 'hanging_man': talib.CDLHANGINGMAN(df['open'], df['high'], df['low'], df['close']), 'shooting_star': talib.CDLSHOOTINGSTAR(df['open'], df['high'], df['low'], df['close']), 'dark_cloud': talib.CDLDARKCLOUDCOVER(df['open'], df['high'], df['low'], df['close']), 'evening_star': talib.CDLEVENINGSTAR(df['open'], df['high'], df['low'], df['close']), 'three_black_crows': talib.CDL3BLACKCROWS(df['open'], df['high'], df['low'], df['close']), 'bearish_engulfing': talib.CDLENGULFING(df['open'], df['high'], df['low'], df['close']) } # 检查最近3天的K线形态 for pattern_name, pattern_data in patterns.items(): if len(pattern_data) > 3: # 检查最近3天是否有信号 for i in range(-3, 0): if pattern_data.iloc[i] < 0: # 看跌信号 if pattern_name in ['evening_star', 'three_black_crows', 'dark_cloud']: score += 6 # 强看跌形态 elif pattern_name in ['hanging_man', 'shooting_star']: score += 4 # 中度看跌形态 else: score += 3 # 弱看跌形态 break # 手动分析一些简单空头形态 manual_score = self._analyze_manual_bearish_patterns(df.tail(10)) score += manual_score return min(score, 25) def _analyze_manual_bearish_patterns(self, df: pd.DataFrame) -> float: """手动分析空头形态""" if len(df) < 5: return 0 score = 0 # 分析最近5天的走势 last_5 = df.tail(5) # 1. 阶段性高点下移模式 highs = last_5['high'].tolist() if len(highs) >= 3: # 检查是否有高点逐步下移的趋势 descending_highs = True for i in range(1, len(highs)): if highs[i] > highs[i-1] * 1.02: # 允许小幅波动 descending_highs = False break if descending_highs: score += 4 # 2. 跌破前低点模式 current_low = df.iloc[-1]['low'] prev_lows = df.iloc[-5:-1]['low'].tolist() if current_low < min(prev_lows) * 0.99: # 跌破前低 score += 3 return min(score, 7) def analyze_breakdown_potential(self, df: pd.DataFrame) -> float: """分析下跌突破潜力 (20分)""" if len(df) < 30: return 0 score = 0 current = df.iloc[-1] recent_data = df.tail(20) # 1. 价格位置分析 - 寻找做空机会 (8分) recent_high = recent_data['high'].max() recent_low = recent_data['low'].min() price_range = recent_high - recent_low current_position = (current['close'] - recent_low) / price_range if price_range > 0 else 0 # 偏好在高位的币种 if 0.7 <= current_position <= 0.9: # 高位做空机会 score += 6 elif 0.5 <= current_position < 0.7: score += 3 elif current_position < 0.3: # 已经低位，做空机会不大 score -= 5 # 2. 顶部形态分析 (6分) volatility = recent_data['close'].std() / recent_data['close'].mean() if 0.08 <= volatility <= 0.15: # 高位整理，可能形成顶部 score += 5 elif volatility > 0.20: # 高波动，可能已经开始下跌 score += 3 # 3. 量能衰竭 (6分) volume_ratio = recent_data['volume'] / recent_data['volume'].rolling(10).mean() weak_volume_days = ((volume_ratio < 0.8)).sum() # 量能萱缩 if weak_volume_days >= 3: # 量能持续萱缩 score += 4 return max(min(score, 20), 0) def analyze_bearish_moving_average(self, df: pd.DataFrame) -> float: """分析空头均线系统 (10分)""" if len(df) < 50: return 0 score = 0 current = df.iloc[-1] # 1. 均线空头排列 if current['close'] < current['ma20'] < current['ma50']: score += 6 # 2. 价格跌破关键均线 prev = df.iloc[-2] if prev['close'] >= prev['ma20'] and current['close'] < current['ma20']: score += 3 # 3. 均线斜率向下 ma20_slope = (current['ma20'] - df.iloc[-5]['ma20']) / 5 if ma20_slope < 0: score += 1 return min(score, 10) def calculate_short_entry_exit_levels(self, df: pd.DataFrame, strategy: str) -> Tuple[float, float, float, float]: """计算空头入场、止损、止盈位""" current_price = df.iloc[-1]['close'] atr = df.iloc[-1]['atr'] support, resistance = self.find_support_resistance(df) config = self.strategies[strategy] # 空头入场价策略 ma20 = df.iloc[-1]['ma20'] ma50 = df.iloc[-1]['ma50'] # 策略1: 均线反弹入场 if current_price < ma20 < ma50: # 空头趋势 # 等待反弹至MA20附近做空 entry_price = ma20 * 0.98 # MA20下方2% else: # 策略2: 跌破确认入场 recent_low = df.tail(10)['low'].min() if current_price <= recent_low * 1.02: # 接近跌破 entry_price = recent_low * 0.995 # 跌破确认价位 else: # 策略3: 当前价格适当上方等待 entry_price = current_price * 1.005 # 当前价上方0.5% # 确保入场价不会过高(距离当前价不超过5%) if entry_price > current_price * 1.05: entry_price = current_price * 1.02 # 止损位: 阻力位上方或ATR的1.5倍 stop_loss_atr = entry_price + (atr * 1.5) stop_loss_resistance = resistance * 1.02 if resistance > 0 else entry_price * 1.08 stop_loss = min(stop_loss_atr, stop_loss_resistance) # 根据策略动态设置风险回报比 risk = stop_loss - entry_price target_ratio = (config.risk_reward_min + config.risk_reward_max) / 2 take_profit_ratio = entry_price - (risk * target_ratio) # 如果有支撑位，取较大值 if support > 0 and support < entry_price: take_profit_support = support * 1.02 take_profit = max(take_profit_ratio, take_profit_support) else: take_profit = take_profit_ratio # 计算实际风险回报比 actual_risk_reward = (entry_price - take_profit) / risk if risk > 0 else target_ratio return entry_price, stop_loss, take_profit, actual_risk_reward def generate_short_action_suggestion(self, df: pd.DataFrame, entry_price: float, current_price: float, score: float) -> str: """生成空头操作建议""" try: # 计算价格差异百分比 entry_diff = (current_price - entry_price) / entry_price * 100 # 获取技术指标状态 current = df.iloc[-1] recent_data = df.tail(10) # 计算价格在最近区间的位置 recent_high = recent_data['high'].max() recent_low = recent_data['low'].min() price_range = recent_high - recent_low current_position = (current_price - recent_low) / price_range if price_range > 0 else 0.5 # 基于评分等级的基础建议 if score >= 80: # 高分 if entry_diff >= -1: # 接近或高于建议价位 if current_position >= 0.7: # 在高位 return "立即做空" elif current_position >= 0.5: return "现价做空" else: return "等待反弹做空" elif entry_diff >= -3: # 稍低于建议价位 return "等待反弹做空" else: # 明显低于建议价位 return "等待大幅反弹" elif score >= 65: # 中等分数 if entry_diff <= 2: # 高于建议价位 return "现价做空" elif entry_diff <= -1: # 接近建议价位 if current_position >= 0.6: return "现价做空" else: return "等待反弹做空" elif entry_diff <= -5: # 低于建议价位 return "等待反弹做空" else: return "暂时观望" else: # 较低分数 if entry_diff <= 3: # 明显高于建议价位 return "小仓位做空" elif entry_diff <= 0: if current_position >= 0.8: return "小仓位试探" else: return "等待反弹做空" else: return "暂时观望" return "等待反弹做空" # 默认建议 except Exception as e: logging.error(f"生成空头操作建议时出错: {e}") return "谨慎观望" def test_strategy_distribution(self, market_data: Dict[str, Dict]) -> Dict[str, int]: """测试策略分布，确保所有策略都能被选中""" strategy_counts = {name: 0 for name in self.strategies.keys()} for symbol, data in list(market_data.items())[:20]: # 只测试前20个 timeframe_data = data.get('timeframes', {}) initial_df = timeframe_data.get('4h') if initial_df is not None and len(initial_df) >= 20: strategy = self.determine_best_strategy(initial_df) strategy_counts[strategy] += 1 logging.info(f"测试策略分布: {symbol} -> {strategy}") logging.info(f"策略分布测试结果: {strategy_counts}") return strategy_counts