Day Trade vs Swing Trade vs Position Trade 2026: Qual Estratégia Escolher?

def comparar_estrategias():
    """
    Comparativo detalhado entre estratégias de trading
    """
    estrategias = {
        'day_trade': {
            'nome': 'Day Trade',
            'duracao': 'Minutos a horas',
            'operacoes_mes': '20 a 200+',
            'capital_minimo': 'R$ 5.000 a R$ 50.000',
            'dedicacao': '6-8 horas/dia',
            'ir_aliquota': '20%',
            'isencao_20k': False,
            'risco': 'Muito Alto',
            'retorno_potencial': 'Alto (positivo ou negativo)',
            'taxa_sucesso': '~10% dos traders'
        },
        'swing_trade': {
            'nome': 'Swing Trade',
            'duracao': 'Dias a semanas',
            'operacoes_mes': '5 a 20',
            'capital_minimo': 'R$ 10.000 a R$ 50.000',
            'dedicacao': '1-2 horas/dia',
            'ir_aliquota': '15%',
            'isencao_20k': True,
            'risco': 'Alto',
            'retorno_potencial': 'Médio-Alto',
            'taxa_sucesso': '~20-30% dos traders'
        },
        'position_trade': {
            'nome': 'Position Trade',
            'duracao': 'Semanas a meses',
            'operacoes_mes': '2 a 5',
            'capital_minimo': 'R$ 10.000+',
            'dedicacao': '30 min a 1 hora/dia',
            'ir_aliquota': '15%',
            'isencao_20k': True,
            'risco': 'Médio',
            'retorno_potencial': 'Médio',
            'taxa_sucesso': '~40% dos traders'
        },
        'buy_hold': {
            'nome': 'Buy & Hold',
            'duracao': 'Anos a décadas',
            'operacoes_mes': '0 a 2',
            'capital_minimo': 'Qualquer valor',
            'dedicacao': '1-2 horas/semana',
            'ir_aliquota': '15%',
            'isencao_20k': True,
            'risco': 'Baixo-Médio',
            'retorno_potencial': 'Médio (consistente)',
            'taxa_sucesso': '~70-80% dos investidores'
        }
    }
    
    return estrategias

estrategias = comparar_estrategias()

for key, info in estrategias.items():
    print(f"\n=== {info['nome'].upper()} ===")
    print(f"Duração: {info['duracao']}")
    print(f"Operações/mês: {info['operacoes_mes']}")
    print(f"Capital mínimo: {info['capital_minimo']}")
    print(f"Dedicação: {info['dedicacao']}")
    print(f"IR: {info['ir_aliquota']}")
    print(f"Isenção R$ 20k: {'Sim' if info['isencao_20k'] else 'Não'}")
    print(f"Risco: {info['risco']}")
    print(f"Taxa de sucesso: {info['taxa_sucesso']}")

import requests

def exemplo_day_trade(ticker, token):
    """
    Analisa oportunidade de day trade usando dados intradiários
    """
    # Buscar dados do ativo
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        'token': token,
        'interval': '1d',
        'range': '1d'
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    if 'results' in data and len(data['results']) > 0:
        ativo = data['results'][0]
        
        return {
            'ticker': ticker,
            'preco_atual': ativo.get('regularMarketPrice', 0),
            'abertura': ativo.get('regularMarketOpen', 0),
            'maxima': ativo.get('regularMarketDayHigh', 0),
            'minima': ativo.get('regularMarketDayLow', 0),
            'volume': ativo.get('regularMarketVolume', 0),
            'variacao_dia': ativo.get('regularMarketChangePercent', 0)
        }
    
    return None

# Exemplo de cálculo de ganho day trade
def calcular_resultado_day_trade(capital, num_operacoes, taxa_acerto, ganho_medio, perda_media):
    """
    Simula resultado de day trade
    
    Args:
        capital: Capital operacional
        num_operacoes: Número de operações no mês
        taxa_acerto: Percentual de operações vencedoras
        ganho_medio: Ganho médio por operação vencedora (%)
        perda_media: Perda média por operação perdedora (%)
    """
    operacoes_ganhas = int(num_operacoes * taxa_acerto)
    operacoes_perdidas = num_operacoes - operacoes_ganhas
    
    ganho_total = capital * (ganho_medio / 100) * operacoes_ganhas
    perda_total = capital * (perda_media / 100) * operacoes_perdidas
    
    resultado_bruto = ganho_total - perda_total
    ir = max(0, resultado_bruto * 0.20)  # 20% de IR sobre lucro
    resultado_liquido = resultado_bruto - ir
    
    return {
        'capital': capital,
        'operacoes': num_operacoes,
        'taxa_acerto': f"{taxa_acerto * 100}%",
        'ganho_total': round(ganho_total, 2),
        'perda_total': round(perda_total, 2),
        'resultado_bruto': round(resultado_bruto, 2),
        'ir_devido': round(ir, 2),
        'resultado_liquido': round(resultado_liquido, 2),
        'retorno_percentual': round(resultado_liquido / capital * 100, 2)
    }

# Cenário otimista (trader profissional)
print("=== CENÁRIO OTIMISTA (Trader Experiente) ===")
resultado_otimista = calcular_resultado_day_trade(
    capital=50000,
    num_operacoes=40,
    taxa_acerto=0.55,  # 55% de acerto
    ganho_medio=1.5,   # 1.5% de ganho médio
    perda_media=0.8    # 0.8% de perda média
)
for k, v in resultado_otimista.items():
    print(f"{k}: {v}")

print("\n=== CENÁRIO REALISTA (Trader Médio) ===")
resultado_realista = calcular_resultado_day_trade(
    capital=50000,
    num_operacoes=40,
    taxa_acerto=0.45,  # 45% de acerto
    ganho_medio=1.2,   # 1.2% de ganho médio
    perda_media=1.0    # 1.0% de perda média
)
for k, v in resultado_realista.items():
    print(f"{k}: {v}")

def calcular_ir_day_trade(lucros_mensais, prejuizos_acumulados=0):
    """
    Calcula IR devido em operações de day trade
    
    Regras:
    - Alíquota: 20% sobre lucro líquido
    - Prejuízos podem ser compensados
    - NÃO há isenção de R$ 20.000
    - IR retido na fonte: 1% (dedo-duro)
    """
    base_calculo = lucros_mensais - prejuizos_acumulados
    
    if base_calculo <= 0:
        return {
            'lucro_mensal': lucros_mensais,
            'prejuizo_compensado': prejuizos_acumulados,
            'base_calculo': 0,
            'ir_devido': 0,
            'prejuizo_a_compensar': abs(base_calculo)
        }
    
    ir_devido = base_calculo * 0.20
    
    return {
        'lucro_mensal': lucros_mensais,
        'prejuizo_compensado': prejuizos_acumulados,
        'base_calculo': base_calculo,
        'ir_devido': round(ir_devido, 2),
        'prejuizo_a_compensar': 0
    }

# Exemplo
print("=== IR DAY TRADE ===")
ir = calcular_ir_day_trade(5000, 1000)
print(f"Lucro do mês: R$ {ir['lucro_mensal']:,.2f}")
print(f"Prejuízo compensado: R$ {ir['prejuizo_compensado']:,.2f}")
print(f"Base de cálculo: R$ {ir['base_calculo']:,.2f}")
print(f"IR devido (20%): R$ {ir['ir_devido']:,.2f}")

import requests

def identificar_setup_swing(ticker, token):
    """
    Identifica possíveis setups de swing trade
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        'token': token,
        'interval': '1d',
        'range': '1mo'
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    if 'results' in data and len(data['results']) > 0:
        ativo = data['results'][0]
        historico = ativo.get('historicalDataPrice', [])
        
        if len(historico) >= 20:
            # Calcular médias móveis simples
            fechamentos = [h['close'] for h in historico[-20:]]
            mm9 = sum(fechamentos[-9:]) / 9
            mm21 = sum(fechamentos) / len(fechamentos)
            
            preco_atual = fechamentos[-1]
            
            # Identificar tendência
            if mm9 > mm21 and preco_atual > mm9:
                tendencia = 'ALTA'
                setup = 'Aguardar pullback para MM9'
            elif mm9 < mm21 and preco_atual < mm9:
                tendencia = 'BAIXA'
                setup = 'Aguardar repique para venda'
            else:
                tendencia = 'LATERAL'
                setup = 'Aguardar definição'
            
            return {
                'ticker': ticker,
                'preco_atual': preco_atual,
                'mm9': round(mm9, 2),
                'mm21': round(mm21, 2),
                'tendencia': tendencia,
                'setup_sugerido': setup
            }
    
    return None

def calcular_resultado_swing(capital, num_operacoes, taxa_acerto, ganho_medio, perda_media):
    """
    Simula resultado de swing trade mensal
    """
    operacoes_ganhas = int(num_operacoes * taxa_acerto)
    operacoes_perdidas = num_operacoes - operacoes_ganhas
    
    ganho_total = capital * (ganho_medio / 100) * operacoes_ganhas
    perda_total = capital * (perda_media / 100) * operacoes_perdidas
    
    resultado_bruto = ganho_total - perda_total
    
    # Swing trade: 15% de IR, com isenção para vendas até R$ 20k/mês
    # Simplificação: assumindo que ultrapassou R$ 20k
    ir = max(0, resultado_bruto * 0.15)
    resultado_liquido = resultado_bruto - ir
    
    return {
        'capital': capital,
        'operacoes': num_operacoes,
        'taxa_acerto': f"{taxa_acerto * 100}%",
        'ganho_total': round(ganho_total, 2),
        'perda_total': round(perda_total, 2),
        'resultado_bruto': round(resultado_bruto, 2),
        'ir_devido': round(ir, 2),
        'resultado_liquido': round(resultado_liquido, 2),
        'retorno_percentual': round(resultado_liquido / capital * 100, 2)
    }

# Cenário swing trade
print("=== RESULTADO SWING TRADE (Cenário Realista) ===")
resultado = calcular_resultado_swing(
    capital=50000,
    num_operacoes=8,     # 8 operações no mês
    taxa_acerto=0.50,    # 50% de acerto
    ganho_medio=8.0,     # 8% de ganho médio
    perda_media=4.0      # 4% de perda média (2:1 risco/retorno)
)
for k, v in resultado.items():
    print(f"{k}: {v}")

def listar_setups_swing():
    """
    Principais setups usados no swing trade
    """
    setups = {
        'pullback_tendencia': {
            'nome': 'Pullback na Tendência',
            'descricao': 'Comprar na correção de uma tendência de alta',
            'indicadores': ['Médias móveis', 'Fibonacci', 'Suportes'],
            'entrada': 'Próximo a MM21 ou suporte',
            'stop': 'Abaixo do último fundo',
            'alvo': 'Topo anterior ou extensão Fibo',
            'risco_retorno': '1:2 a 1:3'
        },
        'rompimento': {
            'nome': 'Rompimento de Resistência',
            'descricao': 'Comprar no rompimento com volume',
            'indicadores': ['Volume', 'Resistência', 'IFR'],
            'entrada': 'Fechamento acima da resistência',
            'stop': 'Abaixo da resistência rompida',
            'alvo': 'Projeção da congestão',
            'risco_retorno': '1:2'
        },
        'reversao': {
            'nome': 'Reversão com Candle',
            'descricao': 'Candles de reversão em suporte/resistência',
            'indicadores': ['Candlesticks', 'Volume', 'Suporte/Resistência'],
            'entrada': 'Confirmação do candle de reversão',
            'stop': 'Abaixo/acima da sombra do candle',
            'alvo': 'Próxima resistência/suporte',
            'risco_retorno': '1:2 a 1:3'
        },
        'inside_bar': {
            'nome': 'Inside Bar (Barra Interna)',
            'descricao': 'Candle contido dentro do anterior',
            'indicadores': ['Candlesticks', 'Tendência'],
            'entrada': 'Rompimento do inside bar',
            'stop': 'Lado oposto do inside bar',
            'alvo': 'Tamanho do candle mãe',
            'risco_retorno': '1:1.5 a 1:2'
        }
    }
    
    return setups

setups = listar_setups_swing()
for key, setup in setups.items():
    print(f"\n=== {setup['nome'].upper()} ===")
    print(f"Descrição: {setup['descricao']}")
    print(f"Indicadores: {', '.join(setup['indicadores'])}")
    print(f"Entrada: {setup['entrada']}")
    print(f"Stop: {setup['stop']}")
    print(f"Alvo: {setup['alvo']}")
    print(f"Risco/Retorno: {setup['risco_retorno']}")

import requests

def analisar_position_trade(ticker, token):
    """
    Análise para position trade combinando técnico e fundamentalista
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        'token': token,
        'modules': 'defaultKeyStatistics,summaryProfile',
        'interval': '1wk',
        'range': '6mo'
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    if 'results' in data and len(data['results']) > 0:
        ativo = data['results'][0]
        
        # Dados fundamentalistas
        pe = ativo.get('priceToEarnings', 0)
        pb = ativo.get('priceToBook', 0)
        dy = ativo.get('dividendYield', 0)
        
        # Dados técnicos (histórico semanal)
        historico = ativo.get('historicalDataPrice', [])
        
        analise = {
            'ticker': ticker,
            'nome': ativo.get('shortName', ''),
            'preco': ativo.get('regularMarketPrice', 0),
            'variacao_6m': ativo.get('regularMarketChangePercent', 0),
            'fundamentalista': {
                'P/L': pe,
                'P/VP': pb,
                'Dividend Yield': f"{dy:.2f}%"
            }
        }
        
        if len(historico) >= 12:
            fechamentos = [h['close'] for h in historico[-12:]]
            mm12_sem = sum(fechamentos) / 12
            
            analise['tecnico'] = {
                'MM12 semanas': round(mm12_sem, 2),
                'Acima da MM12': fechamentos[-1] > mm12_sem,
                'Tendencia': 'ALTA' if fechamentos[-1] > mm12_sem else 'BAIXA'
            }
        
        return analise
    
    return None

def calcular_resultado_position(capital, operacoes_ano, taxa_acerto, ganho_medio, perda_media):
    """
    Simula resultado de position trade anual
    """
    operacoes_ganhas = int(operacoes_ano * taxa_acerto)
    operacoes_perdidas = operacoes_ano - operacoes_ganhas
    
    ganho_total = capital * (ganho_medio / 100) * operacoes_ganhas
    perda_total = capital * (perda_media / 100) * operacoes_perdidas
    
    resultado_bruto = ganho_total - perda_total
    
    # Position: 15% IR, com isenção R$ 20k/mês
    ir = max(0, resultado_bruto * 0.15)
    resultado_liquido = resultado_bruto - ir
    
    return {
        'capital': capital,
        'operacoes_ano': operacoes_ano,
        'taxa_acerto': f"{taxa_acerto * 100}%",
        'ganho_total': round(ganho_total, 2),
        'perda_total': round(perda_total, 2),
        'resultado_bruto': round(resultado_bruto, 2),
        'ir_devido': round(ir, 2),
        'resultado_liquido': round(resultado_liquido, 2),
        'retorno_anual': round(resultado_liquido / capital * 100, 2)
    }

# Cenário position trade
print("=== RESULTADO POSITION TRADE (Anual) ===")
resultado = calcular_resultado_position(
    capital=100000,
    operacoes_ano=12,    # ~1 operação por mês
    taxa_acerto=0.55,    # 55% de acerto
    ganho_medio=25.0,    # 25% de ganho médio
    perda_media=12.0     # 12% de perda média
)
for k, v in resultado.items():
    print(f"{k}: {v}")

def comparar_tributacao(lucro_mensal, vendas_mensais, tipo_operacao):
    """
    Compara tributação entre diferentes tipos de operação
    
    Args:
        lucro_mensal: Lucro do mês
        vendas_mensais: Total de vendas no mês
        tipo_operacao: 'day_trade', 'swing_trade', 'position'
    """
    if tipo_operacao == 'day_trade':
        # Day trade: 20%, sem isenção
        aliquota = 0.20
        isento = False
        ir_devido = lucro_mensal * aliquota if lucro_mensal > 0 else 0
        
    else:  # swing_trade ou position
        # Operações comuns: 15%, isenção se vendas < R$ 20.000
        aliquota = 0.15
        isento = vendas_mensais <= 20000
        
        if isento:
            ir_devido = 0
        else:
            ir_devido = lucro_mensal * aliquota if lucro_mensal > 0 else 0
    
    return {
        'tipo': tipo_operacao,
        'lucro': lucro_mensal,
        'vendas': vendas_mensais,
        'aliquota': f"{aliquota * 100}%",
        'isento': isento,
        'ir_devido': round(ir_devido, 2),
        'lucro_liquido': round(lucro_mensal - ir_devido, 2)
    }

print("=== COMPARATIVO TRIBUTAÇÃO ===\n")
print("Cenário: R$ 3.000 de lucro\n")

# Day Trade
dt = comparar_tributacao(3000, 50000, 'day_trade')
print(f"Day Trade: IR = R$ {dt['ir_devido']} | Líquido = R$ {dt['lucro_liquido']}")

# Swing Trade com vendas altas
sw_alto = comparar_tributacao(3000, 50000, 'swing_trade')
print(f"Swing (vendas > R$20k): IR = R$ {sw_alto['ir_devido']} | Líquido = R$ {sw_alto['lucro_liquido']}")

# Swing Trade com vendas baixas
sw_baixo = comparar_tributacao(3000, 15000, 'swing_trade')
print(f"Swing (vendas < R$20k): IR = R$ {sw_baixo['ir_devido']} | Líquido = R$ {sw_baixo['lucro_liquido']}")

# Position com vendas baixas
pos = comparar_tributacao(3000, 18000, 'position')
print(f"Position (vendas < R$20k): IR = R$ {pos['ir_devido']} | Líquido = R$ {pos['lucro_liquido']}")

def quiz_perfil_trader():
    """
    Quiz para identificar estratégia ideal
    """
    perguntas = [
        {
            'pergunta': 'Quanto tempo você pode dedicar ao mercado por dia?',
            'opcoes': {
                'a': ('6+ horas em tempo integral', {'day_trade': 3, 'swing_trade': 0, 'position': 0}),
                'b': ('1-2 horas', {'day_trade': 0, 'swing_trade': 3, 'position': 2}),
                'c': ('Menos de 1 hora', {'day_trade': 0, 'swing_trade': 1, 'position': 3})
            }
        },
        {
            'pergunta': 'Qual seu capital inicial disponível?',
            'opcoes': {
                'a': ('Menos de R$ 10.000', {'day_trade': 0, 'swing_trade': 1, 'position': 3}),
                'b': ('R$ 10.000 a R$ 50.000', {'day_trade': 2, 'swing_trade': 3, 'position': 2}),
                'c': ('Mais de R$ 50.000', {'day_trade': 3, 'swing_trade': 2, 'position': 2})
            }
        },
        {
            'pergunta': 'Como você lida com perdas?',
            'opcoes': {
                'a': ('Fico muito ansioso, perco o sono', {'day_trade': 0, 'swing_trade': 1, 'position': 3}),
                'b': ('Fico incomodado mas consigo controlar', {'day_trade': 2, 'swing_trade': 3, 'position': 2}),
                'c': ('Encaro como parte do jogo', {'day_trade': 3, 'swing_trade': 2, 'position': 1})
            }
        },
        {
            'pergunta': 'Você tem outra fonte de renda?',
            'opcoes': {
                'a': ('Sim, emprego fixo', {'day_trade': 0, 'swing_trade': 3, 'position': 3}),
                'b': ('Freelancer/autônomo', {'day_trade': 2, 'swing_trade': 2, 'position': 2}),
                'c': ('Não, quero viver de trading', {'day_trade': 3, 'swing_trade': 1, 'position': 0})
            }
        },
        {
            'pergunta': 'Qual seu objetivo?',
            'opcoes': {
                'a': ('Renda mensal para despesas', {'day_trade': 3, 'swing_trade': 2, 'position': 0}),
                'b': ('Aumentar patrimônio gradualmente', {'day_trade': 0, 'swing_trade': 2, 'position': 3}),
                'c': ('Acelerar crescimento do capital', {'day_trade': 2, 'swing_trade': 3, 'position': 2})
            }
        }
    ]
    
    return perguntas

# Resultado do quiz
def calcular_resultado_quiz(respostas):
    """
    Calcula perfil baseado nas respostas
    respostas: lista de letras ['a', 'b', 'c', ...]
    """
    perguntas = quiz_perfil_trader()
    pontuacao = {'day_trade': 0, 'swing_trade': 0, 'position': 0}
    
    for i, resposta in enumerate(respostas):
        if resposta in perguntas[i]['opcoes']:
            _, pontos = perguntas[i]['opcoes'][resposta]
            for estrategia, pts in pontos.items():
                pontuacao[estrategia] += pts
    
    perfil = max(pontuacao, key=pontuacao.get)
    
    return {
        'pontuacao': pontuacao,
        'perfil_ideal': perfil,
        'compatibilidade': {
            'day_trade': f"{pontuacao['day_trade'] / 15 * 100:.0f}%",
            'swing_trade': f"{pontuacao['swing_trade'] / 15 * 100:.0f}%",
            'position': f"{pontuacao['position'] / 15 * 100:.0f}%"
        }
    }

# Exemplo
respostas_exemplo = ['b', 'b', 'b', 'a', 'c']
resultado = calcular_resultado_quiz(respostas_exemplo)
print("=== RESULTADO DO QUIZ ===")
print(f"Perfil ideal: {resultado['perfil_ideal'].upper()}")
print(f"\nCompatibilidade:")
for est, comp in resultado['compatibilidade'].items():
    print(f"  {est}: {comp}")

def estatisticas_day_trade():
    """
    Estatísticas sobre day traders no Brasil
    Fonte: FGV (2019)
    """
    estatisticas = {
        'periodo_estudo': '2012-2017',
        'amostra': 19.646,  # pessoas físicas
        'resultados': {
            'desistiram_primeiro_dia': '50%',
            'desistiram_300_pregoes': '91%',
            'lucro_medio_persistentes': 'Prejuízo de R$ 36/dia',
            'lucro_top_1_percent': 'R$ 300/dia',
            'percentual_lucro_consistente': '1.1%'
        }
    }
    
    return estatisticas

stats = estatisticas_day_trade()
print("=== ESTATÍSTICAS DAY TRADE (FGV) ===")
print(f"Amostra: {stats['amostra']:,} traders")
for k, v in stats['resultados'].items():
    print(f"{k}: {v}")

import requests

def monitorar_carteira_trading(ativos, token):
    """
    Monitora carteira de trading usando brapi.dev
    """
    tickers = ','.join(ativos)
    
    url = f"https://brapi.dev/api/quote/{tickers}"
    params = {
        'token': token,
        'modules': 'defaultKeyStatistics'
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    resultados = []
    for ativo in data.get('results', []):
        resultados.append({
            'ticker': ativo.get('symbol'),
            'preco': ativo.get('regularMarketPrice'),
            'variacao_dia': ativo.get('regularMarketChangePercent'),
            'volume': ativo.get('regularMarketVolume'),
            'maxima_52sem': ativo.get('fiftyTwoWeekHigh'),
            'minima_52sem': ativo.get('fiftyTwoWeekLow')
        })
    
    return resultados

# Exemplo
# ativos = ['PETR4', 'VALE3', 'ITUB4', 'WEGE3']
# monitorar_carteira_trading(ativos, 'SEU_TOKEN')

# Dados em tempo real
https://brapi.dev/api/quote/PETR4?token=SEU_TOKEN

# Histórico para backtesting
https://brapi.dev/api/quote/PETR4?interval=1d&range=1y&token=SEU_TOKEN

# Múltiplos ativos
https://brapi.dev/api/quote/PETR4,VALE3,ITUB4?token=SEU_TOKEN