O Que São Ações em 2026: Guia Completo para Iniciantes na Bolsa de Valores

Imagine a Petrobras como uma pizza:
    
    🍕 Pizza inteira = Empresa (Petrobras)
    🍕 Cada fatia = Uma ação (PETR4)
    
    Comprando 1 fatia, você:
    - É dono de parte da pizza (empresa)
    - Ganha quando a pizza cresce (valorização)
    - Recebe parte dos lucros (dividendos)

import requests

def consultar_acao(ticker: str):
    """
    Consulta dados de uma ação brasileira via brapi.dev
    
    Args:
        ticker: Código da ação (ex: PETR4, VALE3, ITUB4)
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    
    response = requests.get(url)
    data = response.json()
    
    if 'results' in data and len(data['results']) > 0:
        acao = data['results'][0]
        
        print("=" * 60)
        print(f"DADOS DA AÇÃO: {ticker}")
        print("=" * 60)
        print(f"Nome: {acao.get('longName', 'N/A')}")
        print(f"Preço Atual: R$ {acao.get('regularMarketPrice', 0):.2f}")
        print(f"Variação Dia: {acao.get('regularMarketChangePercent', 0):.2f}%")
        print(f"Volume: {acao.get('regularMarketVolume', 0):,.0f}")
        print(f"Máxima 52 sem: R$ {acao.get('fiftyTwoWeekHigh', 0):.2f}")
        print(f"Mínima 52 sem: R$ {acao.get('fiftyTwoWeekLow', 0):.2f}")
        
        return acao
    
    return None

# Exemplo: Consultar Petrobras
acao = consultar_acao("PETR4")

1. EMPRESA ABRE CAPITAL (IPO)
   Petrobras decide vender ações ao público
   ↓
2. OFERTA PÚBLICA
   Ações são vendidas pela primeira vez
   Dinheiro vai para a empresa
   ↓
3. MERCADO SECUNDÁRIO
   Ações são negociadas entre investidores
   Dinheiro vai de um investidor para outro
   ↓
4. VOCÊ COMPRA
   Abre conta em corretora → transfere dinheiro → compra ações
   ↓
5. VOCÊ É SÓCIO
   - Recebe dividendos (quando empresa distribui lucros)
   - Pode vender quando quiser
   - Ganha se ação subir, perde se cair

def comparar_on_pn(ticker_base: str):
    """
    Compara versões ON e PN de uma mesma empresa
    """
    on = ticker_base + "3"
    pn = ticker_base + "4"
    
    url_on = f"https://brapi.dev/api/quote/{on}"
    url_pn = f"https://brapi.dev/api/quote/{pn}"
    
    response_on = requests.get(url_on)
    response_pn = requests.get(url_pn)
    
    data_on = response_on.json()
    data_pn = response_pn.json()
    
    if 'results' in data_on and 'results' in data_pn:
        acao_on = data_on['results'][0]
        acao_pn = data_pn['results'][0]
        
        print(f"COMPARAÇÃO {ticker_base}3 vs {ticker_base}4")
        print("=" * 60)
        print(f"{'Característica':<25} {'ON (3)':<15} {'PN (4)':<15}")
        print("-" * 60)
        print(f"{'Preço':<25} R$ {acao_on.get('regularMarketPrice', 0):.2f}{'':<8} R$ {acao_pn.get('regularMarketPrice', 0):.2f}")
        print(f"{'Variação Dia':<25} {acao_on.get('regularMarketChangePercent', 0):.2f}%{'':<10} {acao_pn.get('regularMarketChangePercent', 0):.2f}%")
        print(f"{'Volume':<25} {acao_on.get('regularMarketVolume', 0):,.0f}{'':<5} {acao_pn.get('regularMarketVolume', 0):,.0f}")
        print("-" * 60)
        print(f"{'Direito a voto':<25} {'Sim':<15} {'Não'}")
        print(f"{'Tag Along':<25} {'80% mínimo':<15} {'Pode não ter'}")
        print(f"{'Prioridade dividendos':<25} {'Não':<15} {'Sim'}")

# Comparar Petrobras ON vs PN
comparar_on_pn("PETR")

   PETR4
   ↓↓↓↓↓
   ||||└─ Tipo: 3=ON, 4=PN, 11=Unit/ETF/FII
   |||└── 
   ||└───
   |└────
   └───── 4 letras = Nome da empresa

def listar_acoes_disponiveis():
    """
    Lista ações disponíveis para consulta na B3
    """
    url = "https://brapi.dev/api/quote/list"
    
    response = requests.get(url)
    data = response.json()
    
    if 'stocks' in data:
        print("AÇÕES DISPONÍVEIS NA B3")
        print("=" * 60)
        
        # Mostrar primeiras 20
        for acao in data['stocks'][:20]:
            print(f"{acao['stock']:<10} - {acao.get('name', 'N/A')[:40]}")
        
        print(f"\n... e mais {len(data['stocks']) - 20} ações")
        print(f"Total: {len(data['stocks'])} ações listadas")
        
        return data['stocks']
    
    return []

acoes = listar_acoes_disponiveis()

Corretoras populares no Brasil:
├── XP Investimentos
├── Rico
├── Clear (taxa zero)
├── NuInvest (Nubank)
├── BTG Pactual Digital
├── Inter Invest
└── Toro Investimentos

Documentos necessários:
- CPF
- RG ou CNH
- Comprovante de residência
- Selfie (algumas corretoras)

Sua conta bancária
       ↓ TED ou PIX
Conta na corretora
       ↓
Dinheiro disponível para investir

def simular_compra(ticker: str, quantidade: int, preco_limite: float = None):
    """
    Simula uma ordem de compra de ações
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    response = requests.get(url)
    data = response.json()
    
    if 'results' in data:
        preco_atual = data['results'][0]['regularMarketPrice']
        
        print("=" * 60)
        print("SIMULAÇÃO DE ORDEM DE COMPRA")
        print("=" * 60)
        print(f"Ação: {ticker}")
        print(f"Preço Atual: R$ {preco_atual:.2f}")
        print(f"Quantidade: {quantidade}")
        print("-" * 60)
        
        total_bruto = preco_atual * quantidade
        
        # Custos (variam por corretora)
        corretagem = 0  # Muitas são taxa zero hoje
        emolumentos = total_bruto * 0.000325  # B3
        
        total_final = total_bruto + corretagem + emolumentos
        
        print(f"Subtotal: R$ {total_bruto:.2f}")
        print(f"Corretagem: R$ {corretagem:.2f}")
        print(f"Emolumentos: R$ {emolumentos:.2f}")
        print("-" * 60)
        print(f"TOTAL: R$ {total_final:.2f}")
        
        return {
            'ticker': ticker,
            'quantidade': quantidade,
            'preco': preco_atual,
            'total': total_final
        }
    
    return None

# Simular compra de 100 PETR4
simular_compra("PETR4", 100)

Antes (até 2019): Mínimo de 100 ações (lote padrão)
Hoje: Pode comprar 1 ação (mercado fracionário)

Exemplo PETR4 a R$ 38:
- 1 ação = R$ 38
- 10 ações = R$ 380
- 100 ações = R$ 3.800

def calcular_carteira_iniciante(valor_disponivel: float, tickers: list):
    """
    Monta uma carteira para iniciantes com valor disponível
    """
    # Consultar preços
    tickers_str = ",".join(tickers)
    url = f"https://brapi.dev/api/quote/{tickers_str}"
    
    response = requests.get(url)
    data = response.json()
    
    if 'results' in data:
        print("=" * 70)
        print(f"CARTEIRA PARA INICIANTE - R$ {valor_disponivel:,.2f}")
        print("=" * 70)
        
        # Dividir igualmente
        valor_por_acao = valor_disponivel / len(tickers)
        
        total_investido = 0
        
        print(f"{'Ação':<10} {'Preço':<12} {'Qtd':<8} {'Total':<15} {'%'}")
        print("-" * 70)
        
        for acao in data['results']:
            ticker = acao['symbol']
            preco = acao['regularMarketPrice']
            quantidade = int(valor_por_acao / preco)
            total = quantidade * preco
            total_investido += total
            percentual = (total / valor_disponivel) * 100
            
            print(f"{ticker:<10} R$ {preco:<9.2f} {quantidade:<8} R$ {total:<12.2f} {percentual:.1f}%")
        
        print("-" * 70)
        print(f"{'TOTAL':<10} {'':<12} {'':<8} R$ {total_investido:<12.2f}")
        print(f"Sobra: R$ {valor_disponivel - total_investido:.2f}")
        
        return total_investido
    
    return 0

# Exemplo: Carteira diversificada com R$ 1.000
calcular_carteira_iniciante(1000, ["PETR4", "VALE3", "ITUB4", "WEGE3", "ABEV3"])

Compra: PETR4 a R$ 30
Venda: PETR4 a R$ 40
Lucro: R$ 10 por ação (33%)

def consultar_dividendos(ticker: str):
    """
    Consulta dividendos de uma ação
    """
    url = f"https://brapi.dev/api/quote/{ticker}?modules=dividendsData"
    
    response = requests.get(url)
    data = response.json()
    
    if 'results' in data:
        acao = data['results'][0]
        
        print(f"DIVIDENDOS - {ticker}")
        print("=" * 60)
        
        if 'dividendsData' in acao and 'cashDividends' in acao['dividendsData']:
            dividendos = acao['dividendsData']['cashDividends'][:10]
            
            total_12m = 0
            
            print(f"{'Data':<15} {'Tipo':<15} {'Valor'}")
            print("-" * 60)
            
            for div in dividendos:
                data_pag = div.get('paymentDate', 'N/A')[:10]
                tipo = div.get('type', 'Dividendo')
                valor = div.get('rate', 0)
                total_12m += valor
                
                print(f"{data_pag:<15} {tipo:<15} R$ {valor:.4f}")
            
            print("-" * 60)
            
            # Dividend Yield
            preco = acao.get('regularMarketPrice', 1)
            dy = (total_12m / preco) * 100
            
            print(f"Total últimos dividendos: R$ {total_12m:.4f}")
            print(f"Preço atual: R$ {preco:.2f}")
            print(f"Dividend Yield estimado: {dy:.2f}%")
            
        else:
            print("Dividendos não disponíveis")

consultar_dividendos("PETR4")

def analisar_volatilidade(ticker: str):
    """
    Analisa a volatilidade histórica de uma ação
    """
    url = f"https://brapi.dev/api/quote/{ticker}?interval=1d&range=1y"
    
    response = requests.get(url)
    data = response.json()
    
    if 'results' in data:
        acao = data['results'][0]
        
        print(f"ANÁLISE DE VOLATILIDADE - {ticker}")
        print("=" * 60)
        
        preco_atual = acao.get('regularMarketPrice', 0)
        maxima_52 = acao.get('fiftyTwoWeekHigh', 0)
        minima_52 = acao.get('fiftyTwoWeekLow', 0)
        
        variacao_total = ((maxima_52 / minima_52) - 1) * 100
        queda_maxima = ((preco_atual / maxima_52) - 1) * 100
        alta_minima = ((preco_atual / minima_52) - 1) * 100
        
        print(f"Preço Atual: R$ {preco_atual:.2f}")
        print(f"Máxima 52 semanas: R$ {maxima_52:.2f}")
        print(f"Mínima 52 semanas: R$ {minima_52:.2f}")
        print("-" * 60)
        print(f"Variação total no ano: {variacao_total:.1f}%")
        print(f"Distância da máxima: {queda_maxima:.1f}%")
        print(f"Alta desde mínima: {alta_minima:.1f}%")
        print("-" * 60)
        
        if variacao_total > 50:
            print("⚠️ ALTA VOLATILIDADE - Ação oscila muito")
        elif variacao_total > 25:
            print("Volatilidade MODERADA")
        else:
            print("Volatilidade BAIXA - Ação mais estável")

analisar_volatilidade("PETR4")

CENÁRIO POSITIVO:
Você compra R$ 10.000 em ações
Em 10 anos, vira R$ 50.000 (valorização + dividendos)

CENÁRIO NEGATIVO:
Você compra R$ 10.000 em ações
Empresa tem problemas, ação cai 70%
Você tem R$ 3.000

CENÁRIO EXTREMO:
Empresa vai à falência
Você perde todo o investimento

⚠️ NUNCA invista o que não pode perder!
⚠️ Diversifique SEMPRE

def comparar_investimentos():
    """
    Compara ações com outros investimentos
    """
    investimentos = {
        'Poupança': {
            'risco': 'Muito Baixo',
            'retorno_esperado': '6-7% ao ano',
            'liquidez': 'Diária',
            'ir': 'Isento',
            'protecao_fgc': 'Sim (R$ 250k)'
        },
        'CDB': {
            'risco': 'Baixo',
            'retorno_esperado': '10-14% ao ano',
            'liquidez': 'Varia',
            'ir': '15-22,5%',
            'protecao_fgc': 'Sim (R$ 250k)'
        },
        'Tesouro Selic': {
            'risco': 'Muito Baixo',
            'retorno_esperado': '~13% ao ano',
            'liquidez': 'D+1',
            'ir': '15-22,5%',
            'protecao_fgc': 'Governo'
        },
        'Ações': {
            'risco': 'Alto',
            'retorno_esperado': '10-15% ao ano (histórico)',
            'liquidez': 'D+2',
            'ir': '15% (vendas > R$20k/mês)',
            'protecao_fgc': 'Não'
        },
        'Fundos Imobiliários': {
            'risco': 'Médio-Alto',
            'retorno_esperado': '8-12% ao ano',
            'liquidez': 'D+2',
            'ir': 'Isento (dividendos)',
            'protecao_fgc': 'Não'
        }
    }
    
    print("COMPARATIVO DE INVESTIMENTOS")
    print("=" * 80)
    print(f"{'Investimento':<18} {'Risco':<15} {'Retorno Esperado':<20} {'Liquidez'}")
    print("-" * 80)
    
    for inv, dados in investimentos.items():
        print(f"{inv:<18} {dados['risco']:<15} {dados['retorno_esperado']:<20} {dados['liquidez']}")

comparar_investimentos()

Estratégia de Warren Buffett:
1. Escolha boas empresas
2. Compre a preços razoáveis
3. Segure por anos/décadas
4. Reinvista os dividendos
5. Ignore oscilações de curto prazo

def simular_aportes_regulares(
    ticker: str, 
    aporte_mensal: float, 
    meses: int,
    preco_medio: float
):
    """
    Simula aportes mensais em uma ação
    (Usando preço médio para simplificação)
    """
    total_investido = 0
    total_acoes = 0
    
    print(f"SIMULAÇÃO DE APORTES REGULARES - {ticker}")
    print("=" * 60)
    
    for mes in range(1, meses + 1):
        # Variação de preço simulada (±10%)
        import random
        variacao = random.uniform(-0.10, 0.10)
        preco_mes = preco_medio * (1 + variacao)
        
        acoes_compradas = aporte_mensal / preco_mes
        total_acoes += acoes_compradas
        total_investido += aporte_mensal
        
        if mes <= 6 or mes > meses - 3:
            print(f"Mês {mes:02d}: R$ {aporte_mensal:.2f} → {acoes_compradas:.2f} ações a R$ {preco_mes:.2f}")
        elif mes == 7:
            print("...")
    
    preco_medio_pago = total_investido / total_acoes
    
    print("-" * 60)
    print(f"Total Investido: R$ {total_investido:,.2f}")
    print(f"Total de Ações: {total_acoes:.2f}")
    print(f"Preço Médio: R$ {preco_medio_pago:.2f}")
    
    # Simular valorização de 50% ao final
    valor_final = total_acoes * (preco_medio * 1.5)
    lucro = valor_final - total_investido
    
    print(f"\nCenário +50%: R$ {valor_final:,.2f} (Lucro: R$ {lucro:,.2f})")

simular_aportes_regulares("PETR4", 500, 24, 38)

def carteira_diversificada():
    """
    Exemplo de carteira diversificada por setor
    """
    carteira = {
        'Bancos': ['ITUB4', 'BBDC4', 'BBAS3'],
        'Petróleo': ['PETR4'],
        'Mineração': ['VALE3'],
        'Energia': ['ELET3', 'TAEE11'],
        'Consumo': ['ABEV3', 'MGLU3'],
        'Indústria': ['WEGE3'],
        'Saneamento': ['SAPR11']
    }
    
    print("CARTEIRA DIVERSIFICADA POR SETOR")
    print("=" * 60)
    
    for setor, acoes in carteira.items():
        print(f"{setor}: {', '.join(acoes)}")
    
    print("\nRegras de ouro:")
    print("1. Não concentre mais de 10% em uma ação")
    print("2. Não concentre mais de 25% em um setor")
    print("3. Tenha pelo menos 10 ações diferentes")
    print("4. Considere adicionar FIIs e ETFs")

carteira_diversificada()

def calcular_ir_acoes(vendas_mes: float, lucro: float, tipo: str = "swing"):
    """
    Calcula o IR devido na venda de ações
    
    Args:
        vendas_mes: Total de vendas no mês
        lucro: Lucro nas operações
        tipo: "swing" ou "daytrade"
    """
    print("CÁLCULO DE IR - AÇÕES")
    print("=" * 60)
    print(f"Total de Vendas: R$ {vendas_mes:,.2f}")
    print(f"Lucro: R$ {lucro:,.2f}")
    print(f"Tipo: {tipo.upper()}")
    print("-" * 60)
    
    if tipo == "daytrade":
        # Day trade: sempre 20%
        ir = lucro * 0.20
        print(f"Alíquota: 20%")
    else:
        # Swing trade: isento até R$ 20k em vendas
        if vendas_mes <= 20000:
            ir = 0
            print(f"Vendas ≤ R$ 20.000 → ISENTO")
        else:
            ir = lucro * 0.15
            print(f"Vendas > R$ 20.000 → Alíquota: 15%")
    
    print("-" * 60)
    print(f"IR DEVIDO: R$ {ir:,.2f}")
    
    if ir > 0:
        print("\n⚠️ Pagar via DARF até último dia útil do mês seguinte")
        print("   Código: 6015 (swing) ou 6015 (day trade)")
    
    return ir

# Exemplos
print("\n--- Cenário 1: Venda pequena ---")
calcular_ir_acoes(15000, 3000, "swing")

print("\n--- Cenário 2: Venda acima de R$ 20k ---")
calcular_ir_acoes(50000, 10000, "swing")

print("\n--- Cenário 3: Day Trade ---")
calcular_ir_acoes(5000, 500, "daytrade")

def monitorar_carteira(carteira: dict):
    """
    Monitora uma carteira de ações
    
    Args:
        carteira: Dict com ticker e quantidade
    """
    tickers = ",".join(carteira.keys())
    url = f"https://brapi.dev/api/quote/{tickers}"
    
    response = requests.get(url)
    data = response.json()
    
    if 'results' in data:
        print("=" * 75)
        print("MONITORAMENTO DE CARTEIRA")
        print("=" * 75)
        
        total_atual = 0
        total_variacao_dia = 0
        
        print(f"{'Ação':<10} {'Qtd':<8} {'Preço':<12} {'Total':<15} {'Var. Dia'}")
        print("-" * 75)
        
        for acao in data['results']:
            ticker = acao['symbol']
            quantidade = carteira[ticker]
            preco = acao['regularMarketPrice']
            variacao = acao.get('regularMarketChangePercent', 0)
            
            total = quantidade * preco
            total_atual += total
            
            var_str = f"+{variacao:.2f}%" if variacao >= 0 else f"{variacao:.2f}%"
            
            print(f"{ticker:<10} {quantidade:<8} R$ {preco:<9.2f} R$ {total:<12.2f} {var_str}")
        
        print("-" * 75)
        print(f"{'TOTAL':<10} {'':<8} {'':<12} R$ {total_atual:<12,.2f}")

# Exemplo de carteira
minha_carteira = {
    'PETR4': 100,
    'VALE3': 50,
    'ITUB4': 80,
    'WEGE3': 30,
    'ABEV3': 60
}

monitorar_carteira(minha_carteira)