1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def why_risk_management_matters():
    """展示不同亏损幅度需要多大涨幅才能回本"""
    
    print("=== 亏损与回本的非对称性 ===\n")
    print(f"{'亏损幅度':<10}{'剩余资金':<12}{'需要涨幅回本':<16}{'难度'}")
    print("-" * 50)
    
    losses = [0.1, 0.2, 0.3, 0.5, 0.7, 0.9, 0.95]
    for loss in losses:
        remaining = 1 - loss
        needed = (1 / remaining) - 1
        difficulty = "容易" if needed < 0.3 else "中等" if needed < 1 else "困难" if needed < 5 else "几乎不可能"
        print(f"  -{loss:.0%}{'':>6} {remaining:.0%}{'':>8} +{needed:.0%}{'':>8} {difficulty}")
    
    print(f"\n关键结论:")
    print(f"  亏 50% 需要涨 100% 回本")
    print(f"  亏 90% 需要涨 900% 回本")
    print(f"  → 防止大亏损比追求大盈利重要 10 倍")

why_risk_management_matters()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

=== 亏损与回本的非对称性 ===

亏损幅度  剩余资金    需要涨幅回本    难度
--------------------------------------------------
  -10%      90%        +11%        容易
  -20%      80%        +25%        容易
  -30%      70%        +43%        中等
  -50%      50%        +100%       中等
  -70%      30%        +233%       困难
  -90%      10%        +900%       几乎不可能
  -95%       5%        +1900%      几乎不可能

关键结论:
  亏 50% 需要涨 100% 回本
  亏 90% 需要涨 900% 回本
  → 防止大亏损比追求大盈利重要 10 倍

1
2
3
4
5
6
7

f* = (bp - q) / b

其中：
f* = 最优下注比例（占总资金）
b = 赔率（赢时赚多少倍）
p = 胜率
q = 败率 = 1 - p

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

def kelly_criterion_analysis():
    """Kelly 公式在不同胜率/赔率场景下的最优仓位"""
    
    print("=== Kelly 公式：最优仓位计算 ===\n")
    
    
    scenarios = [
        {'name': '高胜率低赔率（趋势跟踪）', 'win_rate': 0.65, 'reward_risk': 1.2},
        {'name': '低胜率高赔率（突破交易）', 'win_rate': 0.35, 'reward_risk': 3.0},
        {'name': '均衡策略', 'win_rate': 0.55, 'reward_risk': 1.5},
        {'name': '抛硬币（无优势）', 'win_rate': 0.50, 'reward_risk': 1.0},
        {'name': '略有优势', 'win_rate': 0.52, 'reward_risk': 1.1},
    ]
    
    print(f"{'策略':<26}{'胜率':<8}{'赔率':<8}{'Kelly%':<10}{'半Kelly%':<10}{'期望值'}")
    print("-" * 72)
    
    for s in scenarios:
        p = s['win_rate']
        b = s['reward_risk']
        q = 1 - p
        
        
        kelly = (b * p - q) / b
        kelly = max(kelly, 0)  
        half_kelly = kelly / 2  
        
        
        expected_value = p * b - q
        
        print(f"  {s['name']:<24} {p:.0%}{'':>3} {b:.1f}x{'':>3} "
              f"{kelly:.1%}{'':>4} {half_kelly:.1%}{'':>4} "
              f"{'+'if expected_value>0 else ''}{expected_value:.3f}")
    
    print(f"\n实战建议:")
    print(f"  1. 永远用「半 Kelly」或更少——完整 Kelly 波动太大")
    print(f"  2. 如果 Kelly 算出 > 25%，你可能高估了自己的优势")
    print(f"  3. 加密市场胜率/赔率不稳定，保守 = 活得久")
    
    
    import random
    random.seed(42)
    
    initial_capital = 10000
    num_trades = 100
    win_rate = 0.55
    reward_risk = 1.5
    
    strategies = {
        'Full Kelly (18.3%)': (0.55 * 1.5 - 0.45) / 1.5,
        'Half Kelly (9.2%)': (0.55 * 1.5 - 0.45) / 1.5 / 2,
        '固定 5%': 0.05,
        '固定 2%': 0.02,
        'All-in (100%)': 1.0,
    }
    
    print(f"\n--- 100 次交易模拟 (胜率55%, 赔率1.5x) ---")
    print(f"{'策略':<22}{'最终资金':<14}{'最大回撤':<12}{'破产?'}")
    print("-" * 55)
    
    for name, fraction in strategies.items():
        capital = initial_capital
        peak = capital
        max_drawdown = 0
        bankrupt = False
        
        for _ in range(num_trades):
            if capital <= 0:
                bankrupt = True
                break
            
            bet = capital * min(fraction, 1.0)
            
            if random.random() < win_rate:
                capital += bet * reward_risk
            else:
                capital -= bet
            
            peak = max(peak, capital)
            drawdown = (peak - capital) / peak
            max_drawdown = max(max_drawdown, drawdown)
        
        print(f"  {name:<20} ${capital:>10,.0f}  {max_drawdown:>8.0%}{'':>4} "
              f"{'💀 是' if bankrupt else '✅ 否'}")

kelly_criterion_analysis()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

=== Kelly 公式：最优仓位计算 ===

策略                      胜率    赔率    Kelly%    半Kelly%  期望值
------------------------------------------------------------------------
  高胜率低赔率（趋势跟踪） 65%     1.2x    25.0%     12.5%    +0.430
  低胜率高赔率（突破交易） 35%     3.0x    13.3%      6.7%    +0.400
  均衡策略                 55%     1.5x    18.3%      9.2%    +0.375
  抛硬币（无优势）         50%     1.0x     0.0%      0.0%    +0.000
  略有优势                 52%     1.1x     7.3%      3.6%    +0.092

--- 100 次交易模拟 (胜率55%, 赔率1.5x) ---
策略                  最终资金      最大回撤    破产?
-------------------------------------------------------
  Full Kelly (18.3%)  $  142,857      65%     ✅ 否
  Half Kelly (9.2%)   $   47,832      38%     ✅ 否
  固定 5%             $   23,156      22%     ✅ 否
  固定 2%             $   14,208      11%     ✅ 否
  All-in (100%)       $        0     100%     💀 是

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

def stop_loss_strategies():
    """对比不同止损策略"""
    
    entry_price = 50000  
    capital = 10000      
    risk_per_trade = 0.02  
    max_loss_amount = capital * risk_per_trade  
    
    print("=== 止损策略对比 ===\n")
    print(f"入场价: ${entry_price:,} | 账户: ${capital:,} | 单笔最大亏损: ${max_loss_amount:.0f} (2%)")
    
    strategies = {
        '固定百分比 (5%)': {
            'stop_price': entry_price * 0.95,
            'method': '入场价下方 5%',
        },
        'ATR 止损 (2×ATR)': {
            'stop_price': entry_price - 2 * 1200,  
            'method': '入场价 - 2倍日均波幅',
        },
        '结构止损 (前低)': {
            'stop_price': 48500,  
            'method': '前一个支撑位下方',
        },
        '波动率止损': {
            'stop_price': entry_price - 2.5 * (entry_price * 0.03),  
            'method': '2.5 倍标准差',
        },
    }
    
    print(f"\n{'策略':<20}{'止损价':<12}{'止损距离':<10}{'最大仓位':<12}{'说明'}")
    print("-" * 75)
    
    for name, s in strategies.items():
        stop_distance = entry_price - s['stop_price']
        stop_pct = stop_distance / entry_price
        
        position_size = max_loss_amount / stop_distance
        position_value = position_size * entry_price
        
        print(f"  {name:<18} ${s['stop_price']:>7,.0f}  "
              f"-{stop_pct:.1%}{'':>4} "
              f"${position_value:>8,.0f}  {s['method']}")

    print(f"\n核心逻辑: 止损越宽 → 仓位越小 → 单笔风险恒定")
    print(f"  这就是「固定风险模型」: 不管止损在哪，每笔亏损都不超过账户 2%")

stop_loss_strategies()

1
2
3
4
5
6
7
8
9
10
11
12
13

=== 止损策略对比 ===

入场价: $50,000 | 账户: $10,000 | 单笔最大亏损: $200 (2%)

策略                止损价      止损距离  最大仓位    说明
---------------------------------------------------------------------------
  固定百分比 (5%)    $47,500   -5.0%    $  4,000  入场价下方 5%
  ATR 止损 (2×ATR)   $47,600   -4.8%    $  4,167  入场价 - 2倍日均波幅
  结构止损 (前低)     $48,500   -3.0%    $  6,667  前一个支撑位下方
  波动率止损          $46,250   -7.5%    $  2,667  2.5 倍标准差

核心逻辑: 止损越宽 → 仓位越小 → 单笔风险恒定
  这就是「固定风险模型」: 不管止损在哪，每笔亏损都不超过账户 2%

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

def portfolio_allocation():
    """加密资产配置模型与风险分散模拟"""
    
    total_capital = 100000  
    
    
    allocation = {
        '核心仓位 (BTC/ETH)': {
            'pct': 0.50,
            'assets': ['BTC', 'ETH'],
            'expected_annual': 0.30,   
            'max_drawdown': 0.50,      
            'volatility': 0.60,        
        },
        '成长仓位 (L1/L2)': {
            'pct': 0.25,
            'assets': ['SOL', 'AVAX', 'ARB'],
            'expected_annual': 0.50,
            'max_drawdown': 0.75,
            'volatility': 0.90,
        },
        '高风险仓位 (小币/DeFi)': {
            'pct': 0.15,
            'assets': ['新项目', 'Meme', 'IDO'],
            'expected_annual': 1.00,
            'max_drawdown': 0.95,
            'volatility': 1.50,
        },
        '稳定收益 (Stablecoin DeFi)': {
            'pct': 0.10,
            'assets': ['USDC@Aave', 'DAI@Maker'],
            'expected_annual': 0.05,
            'max_drawdown': 0.05,
            'volatility': 0.02,
        },
    }
    
    print("=== 加密资产配置模型 ===\n")
    print(f"总资金: ${total_capital:,.0f}\n")
    print(f"{'层级':<28}{'配比':<8}{'金额':<12}{'期望收益':<10}{'最大回撤':<10}{'标的'}")
    print("-" * 85)
    
    total_expected = 0
    total_worst_case = 0
    
    for name, config in allocation.items():
        amount = total_capital * config['pct']
        expected = amount * config['expected_annual']
        worst = amount * config['max_drawdown']
        total_expected += expected
        total_worst_case += worst
        
        print(f"  {name:<26} {config['pct']:.0%}{'':>3} "
              f"${amount:>8,.0f}  +{config['expected_annual']:.0%}{'':>5} "
              f"-{config['max_drawdown']:.0%}{'':>5} {', '.join(config['assets'])}")
    
    print(f"\n组合整体:")
    print(f"  期望年收益: ${total_expected:,.0f} (+{total_expected/total_capital:.0%})")
    print(f"  最坏情况损失: ${total_worst_case:,.0f} (-{total_worst_case/total_capital:.0%})")
    print(f"  即使高风险全亏，核心+稳定保住 ${total_capital * 0.60:,.0f} (60%)")
    
    
    print(f"\n--- 对比: 分散 vs All-in ---")
    import random
    random.seed(42)
    
    
    diversified_results = []
    allin_btc_results = []
    allin_altcoin_results = []
    
    for _ in range(1000):
        
        core_return = random.gauss(0.30, 0.60)
        growth_return = random.gauss(0.50, 0.90)
        risk_return = random.gauss(1.00, 1.50)
        stable_return = random.gauss(0.05, 0.02)
        
        
        core_return = max(core_return, -0.70)
        growth_return = max(growth_return, -0.90)
        risk_return = max(risk_return, -1.0)
        stable_return = max(stable_return, -0.10)
        
        diversified = (0.50 * core_return + 0.25 * growth_return + 
                      0.15 * risk_return + 0.10 * stable_return)
        allin_btc = core_return  
        allin_alt = risk_return  
        
        diversified_results.append(diversified)
        allin_btc_results.append(allin_btc)
        allin_altcoin_results.append(allin_alt)
    
    def stats(results, name):
        avg = sum(results) / len(results)
        sorted_r = sorted(results)
        worst_5pct = sum(sorted_r[:50]) / 50  
        best = max(results)
        ruin = sum(1 for r in results if r < -0.80) / len(results)
        print(f"  {name:<16} 均值:{avg:>+6.0%} | 最差5%:{worst_5pct:>+7.0%} | "
              f"最好:{best:>+7.0%} | 亏>80%概率:{ruin:.1%}")
    
    stats(diversified_results, "分散配置")
    stats(allin_btc_results, "全仓 BTC")
    stats(allin_altcoin_results, "全仓小币")

portfolio_allocation()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

=== 加密资产配置模型 ===

总资金: $100,000

层级                        配比    金额        期望收益  最大回撤  标的
-------------------------------------------------------------------------------------
  核心仓位 (BTC/ETH)         50%    $50,000    +30%      -50%     BTC, ETH
  成长仓位 (L1/L2)           25%    $25,000    +50%      -75%     SOL, AVAX, ARB
  高风险仓位 (小币/DeFi)      15%    $15,000   +100%      -95%     新项目, Meme, IDO
  稳定收益 (Stablecoin DeFi) 10%    $10,000     +5%       -5%     USDC@Aave, DAI@Maker

组合整体:
  期望年收益: $42,250 (+42%)
  最坏情况损失: $52,250 (-52%)
  即使高风险全亏，核心+稳定保住 $60,000 (60%)

--- 对比: 分散 vs All-in ---
  分散配置         均值: +42% | 最差5%:  -48% | 最好: +198% | 亏>80%概率:0.2%
  全仓 BTC         均值: +30% | 最差5%:  -62% | 最好: +210% | 亏>80%概率:3.8%
  全仓小币         均值:+100% | 最差5%:  -98% | 最好: +680% | 亏>80%概率:18.5%

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

def drawdown_control():
    """回撤控制规则模拟"""
    
    print("=== 回撤控制规则 ===\n")
    
    rules = {
        '单笔止损': '任何单笔交易亏损不超过账户 2%',
        '日止损': '单日累计亏损达到 5% → 当日停止交易',
        '周止损': '单周累计亏损达到 10% → 本周停止，下周减半仓位',
        '月止损': '单月累计亏损达到 15% → 暂停交易一周，复盘策略',
        '极端止损': '总账户从高点回撤 25% → 清仓，只保留稳定币',
    }
    
    print("规则设置:")
    for rule, desc in rules.items():
        print(f"  [{rule}] {desc}")
    
    
    import random
    random.seed(123)
    
    capital = 100000
    peak = capital
    daily_pnl = 0
    weekly_pnl = 0
    monthly_pnl = 0
    risk_per_trade = 0.02
    
    print(f"\n--- 模拟 20 个交易日 ---")
    print(f"{'日':<4}{'交易':<8}{'盈亏':<12}{'余额':<14}{'回撤':<8}{'触发规则'}")
    print("-" * 58)
    
    paused_until = 0
    position_multiplier = 1.0
    
    for day in range(1, 21):
        if day <= paused_until:
            print(f"  {day:<3} 暂停{'':>4} $0{'':>8} ${capital:>9,.0f}  -{'':>5} 休息中")
            continue
        
        
        num_trades = random.randint(2, 3)
        day_result = 0
        triggered = ""
        
        for t in range(num_trades):
            
            trade_risk = capital * risk_per_trade * position_multiplier
            if random.random() < 0.50:
                trade_pnl = trade_risk * 1.5
            else:
                trade_pnl = -trade_risk
            
            day_result += trade_pnl
            capital += trade_pnl
            
            
        
        daily_pnl = day_result
        weekly_pnl += day_result
        monthly_pnl += day_result
        peak = max(peak, capital)
        drawdown = (peak - capital) / peak
        
        
        if daily_pnl / (capital - daily_pnl) < -0.05:
            triggered = "⚠️ 日止损"
        if day % 5 == 0 and weekly_pnl / (capital - weekly_pnl) < -0.10:
            triggered = "🛑 周止损"
            position_multiplier = 0.5
            weekly_pnl = 0
        if drawdown > 0.25:
            triggered = "💀 极端止损"
            paused_until = day + 5
        
        print(f"  {day:<3} {num_trades}笔{'':>3} "
              f"${daily_pnl:>+8,.0f}  ${capital:>9,.0f}  "
              f"{drawdown:>5.1%}  {triggered}")
        
        if day % 5 == 0:
            weekly_pnl = 0
    
    total_return = (capital - 100000) / 100000
    print(f"\n最终资金: ${capital:,.0f} ({total_return:+.1%})")
    print(f"最大回撤: {(peak-min(capital, peak))/peak:.1%}")
    print(f"\n回撤控制的价值: 避免在连亏期越陷越深")

drawdown_control()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

交易前:
├─ 1. 确定止损位（技术面/ATR/结构）
├─ 2. 用固定风险模型计算仓位（账户 1-2% 风险）
├─ 3. 确认仓位不超过单标的上限（通常 10-20%）
└─ 4. 确认总敞口不超过风险预算

交易中:
├─ 5. 止损设好就不要改（除非往有利方向移）
├─ 6. 分批止盈（1/3 → 1/3 → 剩余让利润奔跑）
└─ 7. 盈利超 2R 后止损移到成本价（零风险持仓）

交易后:
├─ 8. 检查日/周/月止损是否触发
├─ 9. 连亏 3 笔后减半仓位，连亏 5 笔暂停
└─ 10. 每周复盘：实际风控执行 vs 计划