freedakgmail
664 lines
24 KiB
Python
664 lines
24 KiB
Python
"""
|
||
交易信号检测模块（numpy向量化优化版）
|
||
实现7个交易信号：主升浪、日线底背离、龙抬头、真龙、短底背离、老鼠仓、反弹
|
||
|
||
信号按胜率排名：
|
||
1. 主升浪 85% - MACD零上金叉
|
||
2. 日线底背离 80% - 价格新低但MACD不新低（20日版）
|
||
3. 龙抬头 75% - SKDJ超跌金叉
|
||
4. 真龙 70% - 趋势启动确认
|
||
5. 短底背离 65% - 短周期底背离（10日版）
|
||
6. 老鼠仓 60% - 盘中急跌后快速回收
|
||
7. 反弹 55% - EMA3上穿EMA21
|
||
|
||
优化要点：
|
||
- 所有信号检测函数使用 .values numpy原生数组替代 pandas .iloc
|
||
- numpy arr[i] 访问 ~50ns，pandas iloc[i] 访问 ~5μs，提升 ~100x
|
||
- 底背离函数使用 np.argmin 替代 pandas idxmin
|
||
- detect_all_signals 智能跳过已是 float 的类型转换
|
||
- _check_all_signal_status 使用 numpy 数组切片替代 pandas 切片
|
||
"""
|
||
import pandas as pd
|
||
import numpy as np
|
||
from services.technical_indicators import calc_all_indicators
|
||
|
||
|
||
def detect_main_rising_wave(df, lookback=5):
|
||
"""
|
||
主升浪信号（胜率85%）— numpy优化版
|
||
条件：MACD零上金叉 —— DIF和DEA都在零轴上方，DIF从下往上穿越DEA
|
||
含义：趋势走好，进入加速拉升阶段
|
||
"""
|
||
signals = []
|
||
if len(df) < 30:
|
||
return signals
|
||
|
||
dif = df['dif'].values
|
||
dea = df['dea'].values
|
||
dates = df['date'].values
|
||
closes = df['close'].values
|
||
n = len(dif)
|
||
start = max(1, n - lookback)
|
||
|
||
for i in range(start, n):
|
||
if dif[i] > 0 and dea[i] > 0 and dif[i - 1] <= dea[i - 1] and dif[i] > dea[i]:
|
||
signals.append({
|
||
'date': str(dates[i]),
|
||
'type': 'main_rising_wave',
|
||
'name': '主升浪',
|
||
'direction': 'buy',
|
||
'strength': 85,
|
||
'price': float(closes[i]),
|
||
'description': f"MACD零上金叉: DIF={dif[i]:.3f}, DEA={dea[i]:.3f}，进入加速拉升阶段",
|
||
})
|
||
return signals
|
||
|
||
|
||
def detect_daily_bottom_divergence(df, lookback=5, window=20):
|
||
"""
|
||
日线底背离信号（胜率80%）— numpy优化版
|
||
条件：价格创20日新低，但MACD的DIF未创对应新低
|
||
含义：真正跌透，迎来大级别反转
|
||
"""
|
||
signals = []
|
||
if len(df) < window + 10:
|
||
return signals
|
||
|
||
close = df['close'].values.astype(np.float64)
|
||
dif = df['dif'].values.astype(np.float64)
|
||
dates = df['date'].values
|
||
n = len(close)
|
||
start = max(window, n - lookback)
|
||
|
||
for i in range(start, n):
|
||
window_slice = close[i - window:i + 1]
|
||
curr_price = close[i]
|
||
price_min = window_slice.min()
|
||
|
||
if curr_price > price_min * 1.01:
|
||
continue
|
||
|
||
# 当前日必须是窗口内的实际最低点（等价于 idxmin() == index[-1]）
|
||
if np.argmin(window_slice) == len(window_slice) - 1:
|
||
dif_window = dif[i - window:i]
|
||
if len(dif_window) == 0:
|
||
continue
|
||
dif_at_prev_lows = dif_window.min()
|
||
curr_dif = dif[i]
|
||
|
||
if curr_dif > dif_at_prev_lows and curr_dif < 0:
|
||
signals.append({
|
||
'date': str(dates[i]),
|
||
'type': 'daily_bottom_divergence',
|
||
'name': '日线底背离',
|
||
'direction': 'buy',
|
||
'strength': 80,
|
||
'price': float(curr_price),
|
||
'description': f"价格创{window}日新低，但MACD的DIF未创新低(DIF={curr_dif:.3f})，大级别反转信号",
|
||
})
|
||
return signals
|
||
|
||
|
||
def detect_dragon_head(df, lookback=5):
|
||
"""
|
||
龙抬头信号（胜率75%）— numpy优化版
|
||
条件：SKDJ的K值从超跌区域(<20)发生金叉（K上穿D），且信号稳定
|
||
含义：短线起爆点，反弹稳定性强
|
||
"""
|
||
signals = []
|
||
if len(df) < 20:
|
||
return signals
|
||
|
||
sk = df['skdj_k'].values.astype(np.float64)
|
||
sd = df['skdj_d'].values.astype(np.float64)
|
||
dates = df['date'].values
|
||
closes = df['close'].values
|
||
n = len(sk)
|
||
start = max(2, n - lookback)
|
||
|
||
for i in range(start, n):
|
||
oversold = sk[i - 1] < 20 or sk[i] < 30
|
||
golden_cross = sk[i - 1] <= sd[i - 1] and sk[i] > sd[i]
|
||
|
||
stable = True
|
||
if i >= 3:
|
||
recent_k = sk[i - 2:i + 1]
|
||
# ddof=1 与 pandas Series.std() 保持一致
|
||
stable = np.std(recent_k, ddof=1) < 15
|
||
|
||
if oversold and golden_cross and stable:
|
||
signals.append({
|
||
'date': str(dates[i]),
|
||
'type': 'dragon_head',
|
||
'name': '龙抬头',
|
||
'direction': 'buy',
|
||
'strength': 75,
|
||
'price': float(closes[i]),
|
||
'description': f"SKDJ超跌金叉: K={sk[i]:.1f}, D={sd[i]:.1f}，短线起爆点",
|
||
})
|
||
return signals
|
||
|
||
|
||
def detect_true_dragon(df, lookback=5):
|
||
"""
|
||
真龙信号（胜率70%）— numpy优化版
|
||
条件：价格突破MA20，MA5上穿MA20（金叉），MACD柱由负转正，成交量放大
|
||
含义：中期趋势刚刚启动
|
||
"""
|
||
signals = []
|
||
if len(df) < 25:
|
||
return signals
|
||
|
||
close = df['close'].values.astype(np.float64)
|
||
ma5 = df['ma5'].values.astype(np.float64)
|
||
ma20 = df['ma20'].values.astype(np.float64)
|
||
macd = df['macd'].values.astype(np.float64)
|
||
volume = df['volume'].values.astype(np.float64)
|
||
dates = df['date'].values
|
||
n = len(close)
|
||
start = max(2, n - lookback)
|
||
|
||
for i in range(start, n):
|
||
price_above_ma20 = close[i] > ma20[i]
|
||
ma5_cross_ma20 = (ma5[i - 1] <= ma20[i - 1]) and (ma5[i] > ma20[i])
|
||
ma5_above_ma20 = ma5[i] > ma20[i]
|
||
macd_turn_positive = macd[i] > 0 and macd[i - 1] <= 0
|
||
|
||
vol_start = max(0, i - 10)
|
||
vol_avg = volume[vol_start:i].mean() if i > vol_start else 0.0
|
||
volume_up = volume[i] > vol_avg * 1.2 if vol_avg > 0 else False
|
||
|
||
conditions_met = sum([price_above_ma20, ma5_cross_ma20 or ma5_above_ma20, macd_turn_positive, volume_up])
|
||
|
||
if conditions_met >= 3 and price_above_ma20:
|
||
desc_parts = []
|
||
if ma5_cross_ma20:
|
||
desc_parts.append("MA5金叉MA20")
|
||
if macd_turn_positive:
|
||
desc_parts.append("MACD翻红")
|
||
if volume_up:
|
||
desc_parts.append("放量")
|
||
signals.append({
|
||
'date': str(dates[i]),
|
||
'type': 'true_dragon',
|
||
'name': '真龙',
|
||
'direction': 'buy',
|
||
'strength': 70,
|
||
'price': float(close[i]),
|
||
'description': f"趋势启动: {'+'.join(desc_parts)}，中期趋势确立",
|
||
})
|
||
return signals
|
||
|
||
|
||
def detect_short_bottom_divergence(df, lookback=5, window=10):
|
||
"""
|
||
短底背离信号（胜率65%）— numpy优化版
|
||
条件：价格创10日新低，但MACD的DIF未创对应新低
|
||
含义：小级别反弹，灵敏度高但力度偏弱
|
||
"""
|
||
signals = []
|
||
if len(df) < window + 5:
|
||
return signals
|
||
|
||
close = df['close'].values.astype(np.float64)
|
||
dif = df['dif'].values.astype(np.float64)
|
||
dates = df['date'].values
|
||
n = len(close)
|
||
start = max(window, n - lookback)
|
||
|
||
for i in range(start, n):
|
||
window_slice = close[i - window:i + 1]
|
||
curr_price = close[i]
|
||
price_min = window_slice.min()
|
||
|
||
if curr_price > price_min * 1.01:
|
||
continue
|
||
|
||
# 当前日必须是窗口内的实际最低点
|
||
if np.argmin(window_slice) == len(window_slice) - 1:
|
||
dif_window = dif[i - window:i]
|
||
if len(dif_window) == 0:
|
||
continue
|
||
dif_at_prev_lows = dif_window.min()
|
||
curr_dif = dif[i]
|
||
|
||
if curr_dif > dif_at_prev_lows:
|
||
signals.append({
|
||
'date': str(dates[i]),
|
||
'type': 'short_bottom_divergence',
|
||
'name': '短底背离',
|
||
'direction': 'buy',
|
||
'strength': 65,
|
||
'price': float(curr_price),
|
||
'description': f"价格创{window}日新低，但DIF未新低(DIF={curr_dif:.3f})，小级别反弹信号",
|
||
})
|
||
return signals
|
||
|
||
|
||
def detect_rat_trading(df, lookback=5):
|
||
"""
|
||
老鼠仓信号（胜率60%）— numpy优化版
|
||
条件：盘中急跌（最低价大幅低于开盘价），但收盘收回（收盘价接近或高于开盘价），且成交量放大
|
||
含义：主力偷偷吸筹，上涨不具备即时性
|
||
"""
|
||
signals = []
|
||
if len(df) < 10:
|
||
return signals
|
||
|
||
close = df['close'].values.astype(np.float64)
|
||
open_p = df['open'].values.astype(np.float64)
|
||
low = df['low'].values.astype(np.float64)
|
||
high = df['high'].values.astype(np.float64)
|
||
volume = df['volume'].values.astype(np.float64)
|
||
dates = df['date'].values
|
||
n = len(close)
|
||
start = max(1, n - lookback)
|
||
|
||
for i in range(start, n):
|
||
if open_p[i] <= 0:
|
||
continue
|
||
|
||
drop_from_open = (low[i] - open_p[i]) / open_p[i] * 100
|
||
hl_diff = high[i] - low[i]
|
||
recovery = (close[i] - low[i]) / hl_diff * 100 if hl_diff != 0 else 50.0
|
||
close_vs_open = (close[i] - open_p[i]) / open_p[i] * 100
|
||
|
||
vol_start = max(0, i - 10)
|
||
vol_avg = volume[vol_start:i].mean() if i > vol_start else 0.0
|
||
volume_up = volume[i] > vol_avg * 1.3 if vol_avg > 0 else False
|
||
|
||
if drop_from_open < -3 and recovery > 60 and close_vs_open > -1 and volume_up:
|
||
signals.append({
|
||
'date': str(dates[i]),
|
||
'type': 'rat_trading',
|
||
'name': '老鼠仓',
|
||
'direction': 'buy',
|
||
'strength': 60,
|
||
'price': float(close[i]),
|
||
'description': f"盘中急跌{drop_from_open:.1f}%后回收{recovery:.0f}%，放量吸筹信号",
|
||
})
|
||
return signals
|
||
|
||
|
||
def detect_rebound(df, lookback=5):
|
||
"""
|
||
反弹信号（胜率55%）— numpy优化版
|
||
条件：EMA3从下向上穿越EMA21
|
||
含义：普通均线金叉，震荡市适用、熊市易现假反弹
|
||
"""
|
||
signals = []
|
||
if len(df) < 25:
|
||
return signals
|
||
|
||
ema3 = df['ema3'].values.astype(np.float64)
|
||
ema21 = df['ema21'].values.astype(np.float64)
|
||
dates = df['date'].values
|
||
closes = df['close'].values
|
||
n = len(ema3)
|
||
start = max(1, n - lookback)
|
||
|
||
for i in range(start, n):
|
||
if ema3[i - 1] <= ema21[i - 1] and ema3[i] > ema21[i]:
|
||
signals.append({
|
||
'date': str(dates[i]),
|
||
'type': 'rebound',
|
||
'name': '反弹',
|
||
'direction': 'buy',
|
||
'strength': 55,
|
||
'price': float(closes[i]),
|
||
'description': f"EMA3上穿EMA21: EMA3={ema3[i]:.2f}, EMA21={ema21[i]:.2f}，均线金叉反弹",
|
||
})
|
||
return signals
|
||
|
||
|
||
def detect_all_signals(df, lookback=5):
|
||
"""
|
||
检测所有7个交易信号（优化版）
|
||
|
||
参数:
|
||
df: 包含 date, open, high, low, close, volume 列的DataFrame
|
||
lookback: 向后检测的天数（默认检测最近5天）
|
||
|
||
返回:
|
||
dict: {
|
||
'signals': [...], # 检测到的所有信号列表
|
||
'latest_signals': [...], # 最新一天的信号
|
||
'signal_summary': {...}, # 信号统计摘要
|
||
'indicators': {...} # 最新技术指标值
|
||
}
|
||
|
||
优化：智能类型转换，已是 float64 的列直接跳过
|
||
"""
|
||
required_cols = {'date', 'open', 'high', 'low', 'close', 'volume'}
|
||
if not required_cols.issubset(set(df.columns)):
|
||
missing = required_cols - set(df.columns)
|
||
return {'error': f'缺少必要列: {missing}', 'signals': [], 'latest_signals': []}
|
||
|
||
df = df.copy()
|
||
# 智能类型转换：仅在列不是 float 时才做转换（本地DB数据已是 float64，跳过）
|
||
for col in ['open', 'high', 'low', 'close', 'volume']:
|
||
if not np.issubdtype(df[col].dtype, np.floating):
|
||
df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0).astype(np.float64)
|
||
|
||
df = calc_all_indicators(df)
|
||
|
||
all_signals = []
|
||
all_signals.extend(detect_main_rising_wave(df, lookback))
|
||
all_signals.extend(detect_daily_bottom_divergence(df, lookback))
|
||
all_signals.extend(detect_dragon_head(df, lookback))
|
||
all_signals.extend(detect_true_dragon(df, lookback))
|
||
all_signals.extend(detect_short_bottom_divergence(df, lookback))
|
||
all_signals.extend(detect_rat_trading(df, lookback))
|
||
all_signals.extend(detect_rebound(df, lookback))
|
||
|
||
all_signals.sort(key=lambda x: (-x['strength'], x['date']), reverse=False)
|
||
|
||
latest_date = str(df['date'].values[-1]) if len(df) > 0 else ''
|
||
latest_signals = [s for s in all_signals if s['date'] == latest_date]
|
||
|
||
signal_summary = {
|
||
'total_signals': len(all_signals),
|
||
'latest_date': latest_date,
|
||
'latest_count': len(latest_signals),
|
||
'signal_types': {},
|
||
}
|
||
for s in all_signals:
|
||
t = s['type']
|
||
if t not in signal_summary['signal_types']:
|
||
signal_summary['signal_types'][t] = 0
|
||
signal_summary['signal_types'][t] += 1
|
||
|
||
indicators = {}
|
||
if len(df) > 0:
|
||
last = df.iloc[-1]
|
||
indicators = {
|
||
'macd': {'dif': round(float(last.get('dif', 0)), 4),
|
||
'dea': round(float(last.get('dea', 0)), 4),
|
||
'macd': round(float(last.get('macd', 0)), 4)},
|
||
'skdj': {'k': round(float(last.get('skdj_k', 0)), 2),
|
||
'd': round(float(last.get('skdj_d', 0)), 2)},
|
||
'kdj': {'k': round(float(last.get('kdj_k', 0)), 2),
|
||
'd': round(float(last.get('kdj_d', 0)), 2),
|
||
'j': round(float(last.get('kdj_j', 0)), 2)},
|
||
'ema': {'ema3': round(float(last.get('ema3', 0)), 2),
|
||
'ema21': round(float(last.get('ema21', 0)), 2)},
|
||
'ma': {'ma5': round(float(last.get('ma5', 0)), 2),
|
||
'ma10': round(float(last.get('ma10', 0)), 2),
|
||
'ma20': round(float(last.get('ma20', 0)), 2)},
|
||
}
|
||
|
||
signal_status = _check_all_signal_status(df)
|
||
|
||
return {
|
||
'signals': all_signals,
|
||
'latest_signals': latest_signals,
|
||
'signal_summary': signal_summary,
|
||
'indicators': indicators,
|
||
'signal_status': signal_status,
|
||
}
|
||
|
||
|
||
def _check_all_signal_status(df):
|
||
"""
|
||
检查7个信号的当前状态，返回每个信号的就绪程度和说明（numpy优化版）
|
||
"""
|
||
if len(df) < 30:
|
||
return []
|
||
|
||
n = len(df)
|
||
last = df.iloc[-1]
|
||
prev = df.iloc[-2] if n > 1 else last
|
||
|
||
dif = float(last.get('dif', 0))
|
||
dea = float(last.get('dea', 0))
|
||
macd_val = float(last.get('macd', 0))
|
||
prev_dif = float(prev.get('dif', 0))
|
||
prev_dea = float(prev.get('dea', 0))
|
||
sk = float(last.get('skdj_k', 50))
|
||
sd = float(last.get('skdj_d', 50))
|
||
prev_sk = float(prev.get('skdj_k', 50))
|
||
prev_sd = float(prev.get('skdj_d', 50))
|
||
ema3 = float(last.get('ema3', 0))
|
||
ema21 = float(last.get('ema21', 0))
|
||
prev_ema3 = float(prev.get('ema3', 0))
|
||
prev_ema21 = float(prev.get('ema21', 0))
|
||
close = float(last.get('close', 0))
|
||
open_p = float(last.get('open', 0))
|
||
low = float(last.get('low', 0))
|
||
high = float(last.get('high', 0))
|
||
ma5 = float(last.get('ma5', 0))
|
||
ma20 = float(last.get('ma20', 0))
|
||
|
||
status = []
|
||
|
||
# 1. 主升浪
|
||
above_zero = dif > 0 and dea > 0
|
||
golden = prev_dif <= prev_dea and dif > dea
|
||
triggered = bool(above_zero and golden)
|
||
if triggered:
|
||
desc = f"✅ 已触发！DIF={dif:.3f}>0, DEA={dea:.3f}>0, DIF上穿DEA"
|
||
elif dif > 0 and dea > 0:
|
||
desc = f"DIF和DEA均在零上，等待DIF上穿DEA（差值{dif-dea:.3f}）"
|
||
elif dif > dea:
|
||
desc = f"DIF已在DEA上方，但需等待两者都转正（DIF={dif:.3f}）"
|
||
else:
|
||
desc = f"DIF={dif:.3f}, DEA={dea:.3f}，均在零下，距离触发较远"
|
||
status.append({
|
||
'type': 'main_rising_wave', 'name': '主升浪', 'strength': 85,
|
||
'triggered': triggered, 'description': desc,
|
||
'readiness': _calc_readiness(dif, dea, 'main_rising_wave')
|
||
})
|
||
|
||
# 2. 日线底背离 — 使用numpy数组切片替代pandas切片
|
||
close_arr = df['close'].values.astype(np.float64)
|
||
dif_arr = df['dif'].values.astype(np.float64)
|
||
w20_start = max(0, n - 21)
|
||
window_20 = close_arr[w20_start:]
|
||
price_min_20 = float(window_20.min())
|
||
dif_w20 = dif_arr[w20_start:n - 1] if n > w20_start + 1 else dif_arr[:max(0, n - 1)]
|
||
dif_min_20 = float(dif_w20.min()) if len(dif_w20) > 0 else 0.0
|
||
at_low = close <= price_min_20 * 1.01
|
||
is_actual_min = bool(np.argmin(window_20) == len(window_20) - 1)
|
||
dif_diverge = dif > dif_min_20 and dif < 0
|
||
triggered = bool(at_low and is_actual_min and dif_diverge)
|
||
if triggered:
|
||
desc = f"✅ 已触发！价格接近20日新低，DIF({dif:.3f})高于前低({dif_min_20:.3f})"
|
||
elif at_low and not is_actual_min:
|
||
desc = f"价格接近20日低位({price_min_20:.2f})，但非当前最低点"
|
||
elif at_low:
|
||
desc = f"价格在20日低位，但DIF也在低位（DIF={dif:.3f}），暂无背离"
|
||
elif dif < 0:
|
||
desc = f"DIF在零下({dif:.3f})，需等待价格下探至20日新低({price_min_20:.2f})附近"
|
||
else:
|
||
desc = f"DIF={dif:.3f}在零上，价格距20日低点{price_min_20:.2f}较远"
|
||
status.append({
|
||
'type': 'daily_bottom_divergence', 'name': '日线底背离', 'strength': 80,
|
||
'triggered': triggered, 'description': desc,
|
||
'readiness': _calc_readiness_divergence(close, price_min_20, dif, dif_min_20)
|
||
})
|
||
|
||
# 3. 龙抬头
|
||
oversold = prev_sk < 20 or sk < 30
|
||
sk_cross = prev_sk <= prev_sd and sk > sd
|
||
# 稳定性检查：与检测函数一致，最近3根K值标准差 < 15
|
||
sk_arr = df['skdj_k'].values.astype(np.float64)
|
||
stable = True
|
||
if len(sk_arr) >= 3:
|
||
# ddof=1 与 pandas Series.std() 保持一致
|
||
stable = float(np.std(sk_arr[-3:], ddof=1)) < 15
|
||
triggered = bool(oversold and sk_cross and stable)
|
||
if triggered:
|
||
desc = f"✅ 已触发！SKDJ超跌金叉 K={sk:.1f}, D={sd:.1f}"
|
||
elif sk < 20:
|
||
desc = f"K={sk:.1f}在超卖区(<20)，等待K上穿D（K-D={sk-sd:.1f}）"
|
||
elif sk < 30:
|
||
desc = f"K={sk:.1f}接近超卖区(<20)，继续下探可能触发"
|
||
elif sk < 50:
|
||
desc = f"K={sk:.1f}在中位，距超卖区(K<20)还有较大距离"
|
||
else:
|
||
desc = f"K={sk:.1f}偏高，远离超卖区，不满足条件"
|
||
status.append({
|
||
'type': 'dragon_head', 'name': '龙抬头', 'strength': 75,
|
||
'triggered': triggered, 'description': desc,
|
||
'readiness': _calc_readiness_dragon(sk, sd, prev_sk, prev_sd)
|
||
})
|
||
|
||
# 4. 真龙
|
||
cond_price = close > ma20
|
||
cond_ma = ma5 > ma20
|
||
cond_macd = macd_val > 0 and float(prev.get('macd', 0)) <= 0
|
||
vol_arr = df['volume'].values.astype(np.float64)
|
||
vol_avg = float(vol_arr[max(0, n - 11):n - 1].mean()) if n > 10 else float(vol_arr.mean())
|
||
cond_vol = float(vol_arr[-1]) > vol_avg * 1.2 if vol_avg > 0 else False
|
||
met = sum([cond_price, cond_ma, cond_macd, cond_vol])
|
||
triggered = bool(met >= 3 and cond_price)
|
||
parts = []
|
||
if cond_price:
|
||
parts.append(f"价格>{ma20:.2f}(MA20)✓")
|
||
else:
|
||
parts.append(f"价格{close:.2f}<{ma20:.2f}(MA20)✗")
|
||
if cond_ma:
|
||
parts.append("MA5>MA20✓")
|
||
else:
|
||
parts.append(f"MA5({ma5:.2f})<MA20({ma20:.2f})✗")
|
||
if cond_macd:
|
||
parts.append("MACD翻红✓")
|
||
else:
|
||
parts.append(f"MACD={macd_val:.3f}✗")
|
||
if cond_vol:
|
||
parts.append("放量✓")
|
||
else:
|
||
parts.append("未放量✗")
|
||
if triggered:
|
||
desc = f"✅ 已触发！{met}/4条件满足: {', '.join(parts)}"
|
||
else:
|
||
desc = f"{met}/4条件（需≥3）: {', '.join(parts)}"
|
||
status.append({
|
||
'type': 'true_dragon', 'name': '真龙', 'strength': 70,
|
||
'triggered': triggered, 'description': desc,
|
||
'readiness': min(100, met * 25) if cond_price else min(50, met * 15)
|
||
})
|
||
|
||
# 5. 短底背离
|
||
w10_start = max(0, n - 11)
|
||
window_10 = close_arr[w10_start:]
|
||
price_min_10 = float(window_10.min())
|
||
dif_w10 = dif_arr[w10_start:n - 1] if n > w10_start + 1 else dif_arr[:max(0, n - 1)]
|
||
dif_min_10 = float(dif_w10.min()) if len(dif_w10) > 0 else 0.0
|
||
at_low_10 = close <= price_min_10 * 1.01
|
||
is_actual_min_10 = bool(np.argmin(window_10) == len(window_10) - 1)
|
||
dif_div_10 = dif > dif_min_10
|
||
triggered = bool(at_low_10 and is_actual_min_10 and dif_div_10)
|
||
if triggered:
|
||
desc = f"✅ 已触发！价格接近10日新低，DIF({dif:.3f})高于前低({dif_min_10:.3f})"
|
||
elif at_low_10 and not is_actual_min_10:
|
||
desc = f"价格接近10日低位({price_min_10:.2f})，但非当前最低点"
|
||
elif at_low_10:
|
||
desc = f"价格在10日低位，但DIF也在低位，暂无背离"
|
||
else:
|
||
desc = f"价格距10日低点{price_min_10:.2f}尚远，等待回调"
|
||
status.append({
|
||
'type': 'short_bottom_divergence', 'name': '短底背离', 'strength': 65,
|
||
'triggered': triggered, 'description': desc,
|
||
'readiness': _calc_readiness_divergence(close, price_min_10, dif, dif_min_10)
|
||
})
|
||
|
||
# 6. 老鼠仓
|
||
if open_p > 0:
|
||
drop = (low - open_p) / open_p * 100
|
||
recovery = (close - low) / (high - low) * 100 if high != low else 50
|
||
close_vs_open = (close - open_p) / open_p * 100
|
||
vol_avg_10 = float(vol_arr[max(0, n - 11):n - 1].mean()) if n > 10 else float(vol_arr.mean())
|
||
vol_up = float(vol_arr[-1]) > vol_avg_10 * 1.3 if vol_avg_10 > 0 else False
|
||
triggered = bool(drop < -3 and recovery > 60 and close_vs_open > -1 and vol_up)
|
||
if triggered:
|
||
desc = f"✅ 已触发！盘中跌{drop:.1f}%后回收{recovery:.0f}%，放量吸筹"
|
||
else:
|
||
parts = []
|
||
if drop >= -3:
|
||
parts.append(f"盘中最大跌幅{drop:.1f}%(需<-3%)")
|
||
else:
|
||
parts.append(f"盘中跌{drop:.1f}%✓")
|
||
if recovery <= 60:
|
||
parts.append(f"回收{recovery:.0f}%(需>60%)")
|
||
else:
|
||
parts.append(f"回收{recovery:.0f}%✓")
|
||
if not vol_up:
|
||
parts.append("未放量")
|
||
desc = f"{', '.join(parts)}"
|
||
else:
|
||
triggered = False
|
||
desc = "数据异常"
|
||
status.append({
|
||
'type': 'rat_trading', 'name': '老鼠仓', 'strength': 60,
|
||
'triggered': triggered, 'description': desc,
|
||
'readiness': 0
|
||
})
|
||
|
||
# 7. 反弹
|
||
cross = prev_ema3 <= prev_ema21 and ema3 > ema21
|
||
triggered = bool(cross)
|
||
gap = ema3 - ema21
|
||
gap_pct = gap / ema21 * 100 if ema21 > 0 else 0
|
||
if triggered:
|
||
desc = f"✅ 已触发！EMA3({ema3:.2f})上穿EMA21({ema21:.2f})"
|
||
elif ema3 < ema21:
|
||
desc = f"EMA3({ema3:.2f})<EMA21({ema21:.2f})，差{abs(gap_pct):.2f}%，等待上穿"
|
||
else:
|
||
desc = f"EMA3({ema3:.2f})>EMA21({ema21:.2f})，已在上方但非刚穿越"
|
||
status.append({
|
||
'type': 'rebound', 'name': '反弹', 'strength': 55,
|
||
'triggered': triggered, 'description': desc,
|
||
'readiness': _calc_readiness_rebound(ema3, ema21, prev_ema3, prev_ema21)
|
||
})
|
||
|
||
return status
|
||
|
||
|
||
def _calc_readiness(dif, dea, signal_type):
|
||
if dif > 0 and dea > 0 and dif > dea:
|
||
return 100
|
||
elif dif > 0 and dea > 0:
|
||
return 70
|
||
elif dif > dea:
|
||
return 40
|
||
else:
|
||
return max(0, int(20 + dif * 100))
|
||
|
||
|
||
def _calc_readiness_divergence(close, price_min, dif, dif_min):
|
||
price_near = close <= price_min * 1.03
|
||
dif_higher = dif > dif_min
|
||
if price_near and dif_higher:
|
||
return 90
|
||
elif price_near:
|
||
return 50
|
||
elif dif_higher and dif < 0:
|
||
return 30
|
||
return 10
|
||
|
||
|
||
def _calc_readiness_dragon(sk, sd, prev_sk, prev_sd):
|
||
if sk < 20 and sk > sd and prev_sk <= prev_sd:
|
||
return 100
|
||
elif sk < 20:
|
||
return 70
|
||
elif sk < 30:
|
||
return 40
|
||
elif sk < 50:
|
||
return 20
|
||
return 5
|
||
|
||
|
||
def _calc_readiness_rebound(ema3, ema21, prev_ema3, prev_ema21):
|
||
if prev_ema3 <= prev_ema21 and ema3 > ema21:
|
||
return 100
|
||
gap_pct = (ema3 - ema21) / ema21 * 100 if ema21 > 0 else 0
|
||
if gap_pct > 0:
|
||
return 60
|
||
elif gap_pct > -1:
|
||
return 40
|
||
elif gap_pct > -3:
|
||
return 20
|
||
return 5
|