TA.STDDEV() - 标准差

TA.STDDEV(close, timeperiod=5, nbdev=1)

标准差 = √(Σ(x - μ)² / N)

其中：
x = 每个价格
μ = 平均价格
N = 周期数

def main():
    while True:
        records = exchange.GetRecords()
        if len(records) < 50:
            Sleep(1000)
            continue
        
        closes = [r['Close'] for r in records]
        current_price = closes[-1]
        
        # 计算20周期标准差
        stddev = TA.STDDEV(closes, 20)
        current_std = stddev[-1]
        
        # 标准差占价格的百分比
        std_percent = (current_std / current_price) * 100
        
        Log(f"标准差: {current_std:.2f}")
        Log(f"标准差百分比: {std_percent:.2f}%")
        
        # 波动率判断
        if std_percent > 5:
            Log("⚠️ 高波动性市场")
        elif std_percent < 2:
            Log("💤 低波动性市场")
        else:
            Log("📊 正常波动性市场")
        
        # 波动率变化
        if stddev[-1] > stddev[-2] * 1.5:
            Log("波动率急剧上升")
        
        Sleep(60000)

def main():
    position = None
    entry_price = 0
    stop_loss = 0
    
    while True:
        records = exchange.GetRecords()
        if len(records) < 50:
            Sleep(1000)
            continue
        
        closes = [r['Close'] for r in records]
        current_price = closes[-1]
        
        # 计算标准差
        stddev = TA.STDDEV(closes, 20)
        current_std = stddev[-1]
        
        # 开仓
        if position is None:
            # 假设买入条件满足
            position = "long"
            entry_price = current_price
            stop_loss = entry_price - 2 * current_std
            Log(f"✅ 开仓: {entry_price}")
            Log(f"止损: {stop_loss} (-2σ)")
        
        # 止损检查
        elif position == "long":
            if current_price < stop_loss:
                Log(f"❌ 触发止损: {current_price}")
                position = None
            else:
                # 跟踪止损
                new_stop = current_price - 2 * current_std
                if new_stop > stop_loss:
                    stop_loss = new_stop
                    Log(f"📈 移动止损: {stop_loss}")
        
        Sleep(5000)

def main():
    while True:
        records = exchange.GetRecords()
        if len(records) < 100:
            Sleep(1000)
            continue
        
        highs = [r['High'] for r in records]
        lows = [r['Low'] for r in records]
        closes = [r['Close'] for r in records]
        current_price = closes[-1]
        
        # 标准差
        stddev = TA.STDDEV(closes, 20)
        std_avg = sum(stddev[-20:]) / 20
        
        # 检测低波动
        if stddev[-1] < std_avg * 0.6:
            Log("💤 低波动环境，准备突破")
            
            # 等待突破
            resistance = max(highs[-20:])
            support = min(lows[-20:])
            
            if current_price > resistance:
                Log("✅ 向上突破")
                # exchange.Buy(...)
            elif current_price < support:
                Log("❌ 向下突破")
                # exchange.Sell(...)
        
        Sleep(60000)

stddev = TA.STDDEV(closes, 20)
upper, middle, lower = TA.BBANDS(closes, 20, 2, 2)

# 布林带宽度 = 4 × 标准差
bb_width = upper[-1] - lower[-1]
Log(f"布林带宽度: {bb_width:.2f}")
Log(f"4倍标准差: {4 * stddev[-1]:.2f}")

stddev = TA.STDDEV(closes, 20)
atr = TA.ATR(highs, lows, closes, 14)

# 双重确认波动性
if stddev[-1] > sum(stddev[-20:])/20 * 1.5:
    if atr[-1] > sum(atr[-20:])/20 * 1.5:
        Log("标准差 + ATR 双重确认高波动")