Stop Loss e Stop Gain: Como Usar Ordens de Stop para Proteger Investimentos

┌─────────────────────────────────────────────────────────────────┐
│                    ORDENS DE STOP EXPLICADAS                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│                         STOP GAIN                               │
│                    (Realização de Lucro)                        │
│                           ▲                                     │
│                           │ +15%                                │
│   ─────────────────────────────────────────  R$ 46,00          │
│                           │                                     │
│                           │                                     │
│   ═══════════════════════════════════════════  R$ 40,00        │
│              PREÇO DE COMPRA                                    │
│                           │                                     │
│                           │                                     │
│   ─────────────────────────────────────────  R$ 36,00          │
│                           │ -10%                                │
│                           ▼                                     │
│                         STOP LOSS                               │
│                    (Limitação de Perda)                         │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

def calcular_recuperacao_necessaria(perda_percentual):
    """
    Calcula quanto precisa subir para recuperar uma perda
    """
    fator_perda = 1 - (perda_percentual / 100)
    recuperacao = (1 / fator_perda - 1) * 100
    
    return round(recuperacao, 1)

perdas = [5, 10, 15, 20, 25, 30, 40, 50, 60, 70, 80, 90]

print("=== MATEMÁTICA DA RECUPERAÇÃO ===\n")
print("Se você perde...  Precisa ganhar para recuperar:")
print("-" * 50)

for perda in perdas:
    recuperacao = calcular_recuperacao_necessaria(perda)
    barra = "█" * min(int(recuperacao / 5), 40)
    print(f"    -{perda}%          →  +{recuperacao}% {barra}")

=== MATEMÁTICA DA RECUPERAÇÃO ===

Se você perde...  Precisa ganhar para recuperar:
--------------------------------------------------
    -5%          →  +5.3% █
    -10%         →  +11.1% ██
    -15%         →  +17.6% ███
    -20%         →  +25.0% █████
    -25%         →  +33.3% ██████
    -30%         →  +42.9% ████████
    -40%         →  +66.7% █████████████
    -50%         →  +100.0% ████████████████████
    -60%         →  +150.0% ██████████████████████████████
    -70%         →  +233.3% ████████████████████████████████████████
    -80%         →  +400.0% ████████████████████████████████████████
    -90%         →  +900.0% ████████████████████████████████████████

CONCLUSÃO: Perder 50% exige ganhar 100% para voltar ao zero!
           É MUITO mais fácil prevenir perdas do que recuperar.

CICLO EMOCIONAL SEM STOP LOSS

Compra a R$ 40,00
     │
     ▼
Cai para R$ 38,00 (-5%)
"É só uma correção, vai voltar"
     │
     ▼
Cai para R$ 34,00 (-15%)
"Agora não posso vender, está muito barato"
     │
     ▼
Cai para R$ 28,00 (-30%)
"Vou fazer preço médio!" (ERRO!)
     │
     ▼
Cai para R$ 20,00 (-50%)
"Estou preso, não vou realizar prejuízo"
     │
     ▼
Cai para R$ 12,00 (-70%)
"Desisti, virou pó mesmo..."
     │
     ▼
Vende no fundo ou empresa quebra

COM STOP LOSS A 10%:
Compra a R$ 40,00 → Stop em R$ 36,00
Acionado: Perde 10%, preserva 90% do capital
Segue para próxima oportunidade!

def calcular_stop_loss_fixo(preco_entrada, percentual_stop):
    """
    Calcula stop loss fixo baseado em percentual
    """
    stop_loss = preco_entrada * (1 - percentual_stop / 100)
    perda_maxima = preco_entrada - stop_loss
    
    return {
        "preco_entrada": preco_entrada,
        "stop_loss": round(stop_loss, 2),
        "percentual": percentual_stop,
        "perda_maxima_por_acao": round(perda_maxima, 2)
    }

# Exemplo
stop = calcular_stop_loss_fixo(preco_entrada=40.00, percentual_stop=10)
print(f"Entrada: R$ {stop['preco_entrada']}")
print(f"Stop Loss: R$ {stop['stop_loss']} (-{stop['percentual']}%)")
print(f"Perda máxima: R$ {stop['perda_maxima_por_acao']} por ação")

def calcular_stop_tecnico(preco_entrada, suporte, margem_seguranca=0.02):
    """
    Calcula stop baseado em suporte técnico
    Adiciona margem de segurança abaixo do suporte
    """
    stop_loss = suporte * (1 - margem_seguranca)
    percentual_risco = ((preco_entrada - stop_loss) / preco_entrada) * 100
    
    return {
        "preco_entrada": preco_entrada,
        "suporte_identificado": suporte,
        "stop_loss": round(stop_loss, 2),
        "margem_seguranca": f"{margem_seguranca*100}%",
        "risco_percentual": round(percentual_risco, 2)
    }

# Exemplo: Suporte em R$ 37,50, entrada em R$ 40,00
stop = calcular_stop_tecnico(
    preco_entrada=40.00,
    suporte=37.50,
    margem_seguranca=0.02
)
print(f"Suporte: R$ {stop['suporte_identificado']}")
print(f"Stop (com margem): R$ {stop['stop_loss']}")
print(f"Risco: {stop['risco_percentual']}%")

STOP TÉCNICO EM SUPORTE

        │
   42 ──┤                    ╭───╮
        │                 ╭──╯   ╰──╮
   40 ──┤ ENTRADA →  ────●          ╰───
        │               ╱              
   38 ──┤           ╭──╯               
        │       ╭───╯                  
   36 ──┤ ══════════════════════════════ SUPORTE
        │  STOP LOSS →  ─ ─ ─ ─ ─ ─ ─ ─ (2% abaixo)
   34 ──┤
        │
        └────────────────────────────────
          Jan   Fev   Mar   Abr   Mai

Lógica: Se perder o suporte, a análise estava errada
        Sair rápido e reavaliar

def simular_trailing_stop(precos, percentual_trailing):
    """
    Simula trailing stop ao longo de uma série de preços
    """
    historico = []
    stop_atual = precos[0] * (1 - percentual_trailing / 100)
    max_preco = precos[0]
    posicao_aberta = True
    
    for i, preco in enumerate(precos):
        if not posicao_aberta:
            historico.append({
                "dia": i + 1,
                "preco": preco,
                "stop": None,
                "status": "Posição encerrada"
            })
            continue
        
        # Atualizar máximo e trailing stop
        if preco > max_preco:
            max_preco = preco
            stop_atual = max_preco * (1 - percentual_trailing / 100)
        
        # Verificar se stop foi acionado
        if preco <= stop_atual:
            posicao_aberta = False
            status = f"STOP ACIONADO em R$ {round(stop_atual, 2)}"
        else:
            status = "Posição aberta"
        
        historico.append({
            "dia": i + 1,
            "preco": round(preco, 2),
            "stop": round(stop_atual, 2),
            "maximo": round(max_preco, 2),
            "status": status
        })
    
    return historico

# Exemplo: Ação subindo e depois corrigindo
precos = [40, 41, 43, 45, 47, 46, 44, 42, 41, 40]
trailing = simular_trailing_stop(precos, percentual_trailing=8)

print("\n=== SIMULAÇÃO TRAILING STOP 8% ===\n")
for dia in trailing:
    print(f"Dia {dia['dia']}: R$ {dia['preco']} | Stop: R$ {dia['stop']} | {dia['status']}")

TRAILING STOP EM AÇÃO

Preço                   Stop Móvel
  │
47├─────────────●────────┐
  │           ╱  ╲       │
45├─────────╱     ╲      ├── Stop sobe para R$ 43,24
  │       ╱        ╲     │
43├─────╱           ╲    ├── Stop sobe para R$ 41,40
  │   ╱              ╲   │
41├──╱                ╲──┼── Stop sobe para R$ 39,56
  │ ╱                  ╲ │
39├●                    ╲├── STOP INICIAL R$ 36,80
  │                      X─── STOP ACIONADO!
37├                       
  │
  └──1──2──3──4──5──6──7──8──Dias

Resultado: Comprou a R$ 40, vendeu a R$ 43,24 (lucro de 8%)
           Máximo foi R$ 47, mas protegeu parte do ganho

def calcular_stop_gain(preco_entrada, alvo_percentual, stop_loss_percentual):
    """
    Calcula stop gain e relação risco/retorno
    """
    stop_gain = preco_entrada * (1 + alvo_percentual / 100)
    stop_loss = preco_entrada * (1 - stop_loss_percentual / 100)
    
    ganho_potencial = stop_gain - preco_entrada
    perda_potencial = preco_entrada - stop_loss
    
    risco_retorno = ganho_potencial / perda_potencial if perda_potencial > 0 else 0
    
    return {
        "preco_entrada": preco_entrada,
        "stop_gain": round(stop_gain, 2),
        "stop_loss": round(stop_loss, 2),
        "ganho_potencial": round(ganho_potencial, 2),
        "perda_potencial": round(perda_potencial, 2),
        "risco_retorno": round(risco_retorno, 2),
        "avaliacao": "Favorável" if risco_retorno >= 2 else "Neutro" if risco_retorno >= 1 else "Desfavorável"
    }

# Exemplo: Entrada R$ 40, alvo +15%, stop -7%
operacao = calcular_stop_gain(
    preco_entrada=40.00,
    alvo_percentual=15,
    stop_loss_percentual=7
)

print("\n=== SETUP DA OPERAÇÃO ===")
print(f"Entrada: R$ {operacao['preco_entrada']}")
print(f"Stop Gain: R$ {operacao['stop_gain']} (+15%)")
print(f"Stop Loss: R$ {operacao['stop_loss']} (-7%)")
print(f"Risco/Retorno: {operacao['risco_retorno']}:1 ({operacao['avaliacao']})")

def calcular_stops_multiplos_metodos(preco_entrada, dados_tecnicos):
    """
    Calcula stop loss usando diferentes metodologias
    """
    suporte = dados_tecnicos.get("suporte", 0)
    atr = dados_tecnicos.get("atr", 0)  # Average True Range
    media_movel = dados_tecnicos.get("media_movel_20", 0)
    
    metodos = {}
    
    # 1. Stop Percentual Fixo
    metodos["percentual_fixo_7%"] = round(preco_entrada * 0.93, 2)
    metodos["percentual_fixo_10%"] = round(preco_entrada * 0.90, 2)
    
    # 2. Stop em Suporte
    if suporte > 0:
        metodos["suporte_menos_2%"] = round(suporte * 0.98, 2)
    
    # 3. Stop por ATR (volatilidade)
    if atr > 0:
        metodos["atr_2x"] = round(preco_entrada - (2 * atr), 2)
        metodos["atr_3x"] = round(preco_entrada - (3 * atr), 2)
    
    # 4. Stop na Média Móvel
    if media_movel > 0:
        metodos["media_movel_20"] = round(media_movel * 0.98, 2)
    
    return metodos

# Exemplo
dados = {
    "suporte": 37.50,
    "atr": 1.20,  # R$ 1,20 de variação média diária
    "media_movel_20": 38.00
}

stops = calcular_stops_multiplos_metodos(40.00, dados)

print("\n=== STOP LOSS POR DIFERENTES MÉTODOS ===\n")
for metodo, valor in sorted(stops.items(), key=lambda x: x[1], reverse=True):
    distancia = round((1 - valor/40) * 100, 1)
    print(f"{metodo:25} R$ {valor:6.2f} (-{distancia}%)")

import requests

API_TOKEN = "seu_token_aqui"
BASE_URL = "https://brapi.dev/api"

def calcular_atr_e_stop(ticker, periodo_atr=14, multiplicador=2):
    """
    Calcula ATR e sugere stop baseado em volatilidade
    """
    url = f"{BASE_URL}/quote/{ticker}"
    params = {"range": "1mo", "interval": "1d"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    
    if response.status_code != 200:
        return None
    
    dados = response.json()["results"][0]
    historico = dados.get("historicalDataPrice", [])
    
    if len(historico) < periodo_atr + 1:
        return None
    
    # Calcular True Range para cada dia
    true_ranges = []
    for i in range(1, len(historico)):
        high = historico[i].get("high", 0)
        low = historico[i].get("low", 0)
        close_anterior = historico[i-1].get("close", 0)
        
        tr = max(
            high - low,
            abs(high - close_anterior),
            abs(low - close_anterior)
        )
        true_ranges.append(tr)
    
    # ATR = média dos últimos N true ranges
    atr = sum(true_ranges[-periodo_atr:]) / periodo_atr
    
    preco_atual = dados.get("regularMarketPrice", 0)
    stop_sugerido = preco_atual - (multiplicador * atr)
    
    return {
        "ticker": ticker,
        "preco_atual": round(preco_atual, 2),
        "atr_14": round(atr, 2),
        "volatilidade_pct": round((atr / preco_atual) * 100, 2),
        "stop_2_atr": round(preco_atual - 2 * atr, 2),
        "stop_3_atr": round(preco_atual - 3 * atr, 2)
    }

# Exemplo
resultado = calcular_atr_e_stop("PETR4")
if resultado:
    print(f"\n=== STOP POR ATR: {resultado['ticker']} ===")
    print(f"Preço atual: R$ {resultado['preco_atual']}")
    print(f"ATR (14 dias): R$ {resultado['atr_14']} ({resultado['volatilidade_pct']}%)")
    print(f"Stop sugerido (2 ATR): R$ {resultado['stop_2_atr']}")
    print(f"Stop sugerido (3 ATR): R$ {resultado['stop_3_atr']}")

def criar_sistema_alertas(posicoes):
    """
    Cria sistema de monitoramento de stops
    """
    alertas = []
    
    for posicao in posicoes:
        ticker = posicao["ticker"]
        preco_entrada = posicao["preco_entrada"]
        stop_loss = posicao["stop_loss"]
        stop_gain = posicao.get("stop_gain")
        
        # Obter preço atual via brapi
        url = f"{BASE_URL}/quote/{ticker}"
        headers = {"Authorization": f"Bearer {API_TOKEN}"}
        response = requests.get(url, headers=headers)
        
        if response.status_code != 200:
            continue
        
        preco_atual = response.json()["results"][0].get("regularMarketPrice", 0)
        
        # Verificar proximidade do stop
        distancia_stop_loss = ((preco_atual / stop_loss) - 1) * 100
        
        alerta = {
            "ticker": ticker,
            "preco_atual": preco_atual,
            "stop_loss": stop_loss,
            "distancia_stop": round(distancia_stop_loss, 2)
        }
        
        if preco_atual <= stop_loss:
            alerta["status"] = "🚨 STOP LOSS ACIONADO"
            alerta["acao"] = "VENDER IMEDIATAMENTE"
        elif distancia_stop_loss < 3:
            alerta["status"] = "⚠️ PRÓXIMO DO STOP"
            alerta["acao"] = "Monitorar de perto"
        elif stop_gain and preco_atual >= stop_gain:
            alerta["status"] = "🎯 STOP GAIN ATINGIDO"
            alerta["acao"] = "Realizar lucro ou subir stop"
        else:
            alerta["status"] = "✅ Normal"
            alerta["acao"] = "Manter posição"
        
        alertas.append(alerta)
    
    return alertas

# Exemplo de uso
minhas_posicoes = [
    {"ticker": "PETR4", "preco_entrada": 38.50, "stop_loss": 35.00, "stop_gain": 45.00},
    {"ticker": "VALE3", "preco_entrada": 62.00, "stop_loss": 56.00, "stop_gain": 72.00},
    {"ticker": "ITUB4", "preco_entrada": 32.00, "stop_loss": 29.00, "stop_gain": 38.00}
]

# alertas = criar_sistema_alertas(minhas_posicoes)

def analisar_risco_retorno(operacoes_historicas):
    """
    Analisa relação risco/retorno de um conjunto de operações
    """
    wins = [op for op in operacoes_historicas if op["resultado"] > 0]
    losses = [op for op in operacoes_historicas if op["resultado"] <= 0]
    
    taxa_acerto = len(wins) / len(operacoes_historicas) * 100
    
    ganho_medio = sum(op["resultado"] for op in wins) / len(wins) if wins else 0
    perda_media = abs(sum(op["resultado"] for op in losses) / len(losses)) if losses else 0
    
    rr_medio = ganho_medio / perda_media if perda_media > 0 else 0
    
    # Expectativa matemática
    expectativa = (taxa_acerto/100 * ganho_medio) - ((100-taxa_acerto)/100 * perda_media)
    
    return {
        "total_operacoes": len(operacoes_historicas),
        "wins": len(wins),
        "losses": len(losses),
        "taxa_acerto": round(taxa_acerto, 1),
        "ganho_medio": round(ganho_medio, 2),
        "perda_media": round(perda_media, 2),
        "risco_retorno": round(rr_medio, 2),
        "expectativa": round(expectativa, 2),
        "sistema_lucrativo": expectativa > 0
    }

# Exemplo
operacoes = [
    {"resultado": 150},   # Win
    {"resultado": -80},   # Loss
    {"resultado": 200},   # Win
    {"resultado": -70},   # Loss
    {"resultado": -90},   # Loss
    {"resultado": 180},   # Win
    {"resultado": 120},   # Win
    {"resultado": -75},   # Loss
    {"resultado": 160},   # Win
    {"resultado": -85}    # Loss
]

analise = analisar_risco_retorno(operacoes)
print("\n=== ANÁLISE DE PERFORMANCE ===")
print(f"Taxa de acerto: {analise['taxa_acerto']}%")
print(f"Ganho médio: R$ {analise['ganho_medio']}")
print(f"Perda média: R$ {analise['perda_media']}")
print(f"Risco/Retorno: {analise['risco_retorno']}:1")
print(f"Expectativa: R$ {analise['expectativa']} por operação")
print(f"Sistema lucrativo: {'Sim ✅' if analise['sistema_lucrativo'] else 'Não ❌'}")

RISCO/RETORNO E TAXA DE ACERTO

Com Risco/Retorno 2:1 (ganho 2x a perda):
├── 40% de acerto = LUCRATIVO
├── 50% de acerto = MUITO LUCRATIVO
└── 60% de acerto = EXCELENTE

Com Risco/Retorno 1:1 (ganho = perda):
├── 50% de acerto = EMPATE
├── 60% de acerto = LUCRATIVO
└── 70% de acerto = MUITO LUCRATIVO

Com Risco/Retorno 0.5:1 (ganho metade da perda):
├── 60% de acerto = PREJUÍZO
├── 70% de acerto = EMPATE
└── 80% de acerto = POUCO LUCRATIVO

CONCLUSÃO: Risco/Retorno mínimo de 2:1 dá margem de erro!

❌ ERROS QUE DESTROEM CAPITAL

1. NÃO USAR STOP
   "Vou esperar voltar..."
   → Prejuízos pequenos viram grandes

2. MOVER O STOP PARA BAIXO
   "Só mais um pouquinho..."
   → Anula a proteção

3. STOP MUITO APERTADO
   "Vou colocar 2% de stop"
   → Acionado por ruído, não tendência

4. STOP MUITO LARGO
   "Vou dar espaço de 30%"
   → Perda grande quando aciona

5. NÃO RESPEITAR O STOP
   "Mas a empresa é boa..."
   → Psicológico vence a disciplina

6. STOP EM NÚMERO REDONDO
   "Stop em R$ 40,00"
   → Concentração de stops, manipulação

□ Defini o stop loss?
□ O risco/retorno é favorável (> 2:1)?
□ A perda máxima é aceitável?
□ Tenho disciplina para executar?
□ O stop não está em número redondo?
□ O stop respeita níveis técnicos?