Este artigo apresenta um guia prático para a criação de um sistema de recomendação de operações de trading em Python, combinando técnicas de aprendizado de máquina e análise de sentimento de notícias. Incialmente, são tratadas as motivações históricas e o papel fundamental do Python na popularização da IA. Também são demonstrados exemplos concretos de raspagem de dados de ações na B3, construção de modelos preditivos com Scikit‑Learn e previsões de preços via Yahoo Finance, além do uso de pipelines de NLP da Hugging Face para captar o humor do mercado. Por fim, é apresentada a implementação de um agente de IA completo — incluindo cache de dados, avaliação de tendência de preços e interface interativa em Streamlit — capaz de recomendar compra ou venda de ações.

Inteligência Artificial: o que o Python tem a ver com isso?

A Inteligência Artificial (IA) na última década tomou um impulso gigantesco, não porque seja uma novidade, pois os primeiros modelos computacionais para redes neurais foram criados por Warren McCulloch e Walter Pitts e o termo Inteligência Artificial foi proposto na Conferência de Dartmouth, em 1956 por John McCarthy, mas porque os estudos alcançaram um nível de maturidade tal que hoje vemos seus benefícios em um aspirador de pó doméstico, na possibilidade de qualquer pessoa criar um agente de IA e chegando aos carros e drones autônomos. A vida das pessoas hoje é diretamente impactada pela IA em suas atividades rotineiras ou profissionais.

E a linguagem Python teve um papel crucial nessa evolução recente da IA. O Python foi criado no final dos anos 1980 por Guido van Rossum incomodado com suas experiências prévias com outras linguagens de programação, como ABC. Cansado de programações complexas e muito distantes da linguagem e da lógica natural, van Rossum queria criar uma linguagem de programação que fosse legível, intuitiva e divertida de usar. Com isso, programar em Python deixou de ser uma tarefa complexa e chata e passou a ser um trabalho mais natural, mais próximo da linguagem humana e com resultados mais rápidos e diretos.

Somado a essa característica, a linguagem passou a ser amplamente adotada pela comunidade de desenvolvedores, que de maneira colaborativa começaram a expandir suas aplicações e compartilhar soluções através da criação de bibliotecas, que poderiam ser fácil e rapidamente adotadas por qualquer pessoa. Com isso, ela passou a ser uma ferramenta poderosa no desenvolvimento em áreas como desenvolvimento web, ciência de dados, inteligência artificial, automação e muitas outras.

As aplicações iniciais na área de IA do Python estavam voltadas para automação de processos e análise de dados. Assim, permitiu com poucas linhas de código que um programador sem muito conhecimento de programação fizesse a captura de dados e sua consequente estruturação e análise. Isso inclusive contribuiu para a instituição dos chatos verificadores de atividade humana. Quem nunca passou horas tentando descobrir letras ou acertar os ônibus e faixas de pedestres até xingar quem inventou isso? Pois é, com Python conseguir de maneira automatizada capturar grandes bases de dados envolvia pouquíssimas linhas de código.

Veja um exemplo da criação de um robô para a captura das informações de fechamento das ações negociadas na B3. Lembrando que é necessário instalar as bibliotecas antes de utilizá-las em Python. Em seguida, o código acesa a página, faz sua leitura e salva a tabela existente em um arquivo “.csv”.

# Instalação das bibliotecas
# pip install pandas requests

import requests
import pandas as pd

# URL com os dados
url = "https://www.fundamentus.com.br/resultado.php"

# Cabeçalhos simulando um navegador real
headers = {
  "User-Agent": "Mozilla/5.0"
}

# Envia a requisição
response = requests.get(url, headers=headers)

# Usa pandas para ler diretamente as tabelas HTML da resposta
dfs = pd.read_html(response.text, decimal=",", thousands=".")

# A tabela principal é geralmente a primeira
df = dfs[0]

# Exibe as 5 primeiras linhas
print(df.head())

# Salva o resultado em CSV
df.to_csv("acoes_b3.csv", index=False, encoding="utf-8-sig")

print("Arquivo salvo como 'acoes_b3.csv'")

Como pode ser visto pelo exemplo acima, o Python por ser uma linguagem que preza pela simplicidade e objetividade, passou a contar com uma ampla gama de entusiastas e rapidamente começou a ser aplicada a áreas mais avançadas, especialmente pela crescente capacidade de suas bibliotecas para lidar com questões cada vez mais complexas. Assim, conseguiu avanços rápidos em áreas relacionadas à inteligência artificial com o surgimento de bibliotecas especializadas em aprendizado de máquina (machine learning) e em aprendizado profundo (deep learning). 

Bibliotecas como Scikit-learn facilitaram a análise de dados e a criação de modelos preditivos, enquanto frameworks como TensorFlow e PyTorch abriram as portas para o aprendizado de máquina e o desenvolvimento de redes neurais profundas. Com isso, a curva de aprendizagem de desenvolvedores da área de IA passou a ser caracterizada por pulos gigantescos: com um pouco de interesse e dedicação, até desenvolvedores novatos são capazes de desenvolver modelos preditivos e criar soluções baseadas em Inteligência Artificial.

Continuando o exemplo, vamos utilizar a biblioteca Scikit-learn para a partir das informações históricas realizar uma previsão do valor de um papel a partir de um código informado pelo usuário.

# Instalação das bibliotecas
# pip install pandas numpy yfinance scikit-learn

import pandas as pd
import numpy as np
import yfinance as yf
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

def baixar_historico(ticker: str, period: str = "1y") -> pd.DataFrame:
  """
  Baixa o histórico de preços diários do ticker no Yahoo Finance,
  sem ajuste automático nos preços (usa coluna 'Close' bruta).
  """
  df = yf.download(
      ticker,
      period=period,
      progress=False,
      auto_adjust=False,      # evita o warning e mantém 'Close' bruto
      threads=True
  )
  if df.empty:
      raise ValueError(f"Nenhum dado encontrado para o ticker '{ticker}'.")
  return df

def criar_features_lag(df: pd.DataFrame, nlags: int = 5) -> pd.DataFrame:
  df_feat = df[['Close']].copy()
  for lag in range(1, nlags+1):
      df_feat[f'Close_lag{lag}'] = df_feat['Close'].shift(lag)
  return df_feat.dropna()

def treinar_modelo(df_feat: pd.DataFrame):
  X = df_feat.drop(columns=['Close']).values
  y = df_feat['Close'].values
  X_train, X_test, y_train, y_test = train_test_split(
      X, y, test_size=0.2, shuffle=False
  )
  modelo = LinearRegression().fit(X_train, y_train)
  return modelo

def prever_proximo(modelo, df_feat: pd.DataFrame) -> float:
  ultimo_X = df_feat.drop(columns=['Close']).iloc[[-1]].values
  return float(modelo.predict(ultimo_X)[0])

def main():
  papel = input("Digite o ticker (ex: PETR4.SA): ").strip().upper()
  try:
      df = baixar_historico(papel, period="1y")
  except ValueError as e:
      print(e)
      return

  df_feat = criar_features_lag(df, nlags=5)
  modelo = treinar_modelo(df_feat)

  # Extrai o último fechamento como float
  ultimo_preco = float(df['Close'].iloc[-1])

  previsao = prever_proximo(modelo, df_feat)

  data_ultimo = df.index[-1].date()

  print(f"\nÚltimo fechamento ({data_ultimo}): R$ {ultimo_preco:.2f}")

  print(f"Previsão para o próximo pregão: R$ {previsao:.2f}")

if __name__ == "__main__":
  main()

Como fazer as máquinas entenderem a linguagem dos humanos?

Uma das motivações de Guido van Rossum para criar o Python foi justamente reduzir a grande distância entre a forma como os humanos se comunicam e a maneira como interagem com as máquinas por meio de códigos. Com o avanço da inteligência artificial, essa preocupação ganhou uma nova dimensão: como fazer as máquinas entenderem e processarem nossa linguagem sem a necessidade de um pré-processamento extenso e complexo a cada interação? Ou seja, como falar com os computadores e receber uma resposta sem depender de um transdutor ou tradutor?

Essa questão impulsionou os avanços extraordinários recentes no ramo da Inteligência Artificial que estuda o Processamento de Linguagem Natural (NLP), que busca encontrar os meios para que as máquinas possam entender, interpretar e gerar linguagem humana.

Levantaria até a questão aqui se, dado esse desenvolvimento, o questionamento de Turing que iniciou esses estudos na década de 1950 faz sentido nos dias atuais? A capacidade de entender, interpretar e gerar texto em linguagem natural, inclusive adotando diferentes estilos de escrita, chegou a um ponto tal, que a Inteligência Artificial consegue produzir textos com qualidades avançadas de coerência, objetiva e correção, sendo irrelevante se foi gerado por uma máquina. Negar a capacidade das máquinas de se comunicar em linguagem natural é contraproducente nos dias de hoje.

Mais uma vez o Python trouxe uma contribuição altamente relevante para o NLP. Bibliotecas como NLTK e SpaCy fornecem um conjunto tão completo de ferramentas, como tokenização e análise sintática, que permitiram desenvolvedores sem grande experiência criarem soluções que utilizam como dados de entrada diversas fontes em linguagem natural e apresentam como retorno os mais diversos produtos incluindo diferentes formas de comunicação como textos, áudios, vídeos, imagens, ações automáticas etc.

Mais recentemente, a biblioteca Hugging Face Transformers revolucionou o NLP com modelos pré-treinados, como BERT e GPT. Antes de 2017, os modelos de NLP usavam arquiteturas recorrentes para processar o texto palavra por palavra, em sequência. A maior dificuldade desse modelo é a persistência: eles tinham dificuldades de manter relações de significado entre estruturas distantes no texto, além de, por serem sequenciais, tornarem o treinamento mais lento.

Os transformers, introduzidos por Vaswani et al. no artigo “Attention is All You Need” (2017), abandonaram o processamento sequencial com o uso do self-attention (atenção própria), que passou a analisar a frase em seu contexto global, processando todas as palavras ao mesmo tempo. Com isso, a capacidade dos modelos de NLP sofreram um salto imenso, alcançado o estado atual com criação autônoma de traduções simultâneas, chatbots, sistemas de recomendação, análise de sentimentos, geração de textos, poemas, músicas e códigos.



E o Python teve papel crucial nessa revolução, pois suas bibliotecas passaram, como as disponibilizadas pelo repositório Hugging Face, a permitir o acesso a diferentes modelos de processamento com custo zero. 

Veja como é simples utilizar uma biblioteca do Hugging Face para realizar análise de sentimentos de um conjunto de textos. No exemplo abaixo, utilizamos uma biblioteca que irá realizar a análise de sentimentos de um conjunto de notícias, informando se elas são negativas ou positivas.

from transformers import pipeline

def obter_noticias_b3(ticker):
  return [
      f"Investidores mostram otimismo com os lucros da {ticker}",
      f"Críticas à gestão da {ticker} após queda nas ações",
      f"Perspectivas positivas para o setor de energia impulsionam {ticker}",
      f"Preço do petróleo aumenta e {ticker} aumenta valor da gasolina",
      f"Preço do petróleo despenca e {ticker} diminui valor da gasolina"
  ]

def main():
  ticker = input("Digite o ticker da empresa (ex: PETR4.SA): ").strip().upper()

  print(f"\nBuscando notícias para {ticker}...\n")

  noticias = obter_noticias_b3(ticker)

  analisador = pipeline("sentiment-analysis", model="pysentimiento/robertuito-sentiment-analysis")

  for noticia in noticias:
      resultado = analisador(noticia)[0]
      print(f"Notícia: {noticia}")
      print(f"Sentimento: {resultado['label']} (confiança: {resultado['score']:.2f})\n")

if __name__ == "__main__":
  main()

inclusive, essa funcionalidade poderia ser somada às anteriores para incrementar as variáveis a serem ponderadas no momento de decisão pela compra ou venda de um conjunto de papeis na bolsa de valores do exemplo apresentado e que veremos acontecer mais à frente neste artigo.

Criando máquinas inteligentes: os Agentes de IA

No contexto mais recente dos avanços da Inteligência Artificial, a capacidade de utilização de seus avanços para a criação de soluções trouxe o conceito de Agentes de IA, que são sistemas autônomos capazes de perceber o ambiente, aprender, tomar decisões e agir de maneira totalmente autônoma em ambientes complexos. Os primeiros exemplos foram os agentes criados para disputar jogos como xadrez, damas, go e que rapidamente suplantaram os maiores campeões humanos desses jogos. Em seguida, os agentes autônomos passaram a desempenhar funções cada vez mais complexas como automatizar processos industriais ou conduzir veículos autônomos.

Veja um resumo dos passos para criar um agente de IA com Python:

• Antes de programar, é necessário definir o objetivo do agente, respondendo às seguintes perguntas: Qual problema ele resolve? Que decisões ele tomará? Que dados ele vai usar?
• Passa-se à coleta dos dados, o que pode ser feito pela raspagem de dados, por APIs ou por acesso a base de dados ou arquivos.
• Depois, deve ser feita a preparação dos dados com técnicas de limpeza, padronização e normalização.
• Com base nos dados e no problema, deve ser feita a escolha do tipo de IA que será empregada, que pode ser de: regressão ou classificação; decisões com o ambiente; processamentod e linguagem natural; análise de dados; ou visão computacional.
• Em seguida, parte-se para a etapa de construção, treinamento, avaliação e ajuste fino do agente de IA.
• O agente deve então ser integrado com uma interface web, eventos do sistema (automações) ou com bots.
• Por fim, o agente é implantado e disponiblizado, devendo ser realizado seu monitoramento e melhorias constantes.

O Python que nos primórdios permitiu o desenvolvimento de robôs que automatizavam a criação de bancos de dados a partir da raspagem de páginas sobre os preços das ações, passou a permitir o denvolvimento de robôs inteligentes que fazem captura, análise e indicação das variações dos preços das ações, somados a uma análise das notícias recentes sobre as empresas negociadas em bolsa, indicam o grau de probabilidade de sucesso na aquisição ou na venda de ativos e a partir disso podem realizar a negociação automática de ações com base nos parâmetros de aceitabilidade definidos. Você verá uma parte desse robô autônomo para verificação de tendências do mercado de ações no exemplo prático deste artigo.

Criando um robô de IA para recomendar a compra ou venda de ações

⚠️ Antes de partir para a demonstração, fica um alerta importante: esse artigo tem o caráter educativo de falar sobre a aplicação da inteligência artificial em uma atividade real. Assim, caso queira aplicar o conhecimento para investir na compra e venda de ações, lembre-se que essa é uma atividade de risco e por isso mesmo seu modelo irá trabalhar com probabilidades de ganho ou perda, não havendo garantia de lucro. A atividade de trading envolve muito estudo e dedicação tanto dos assuntos tratados nesse artigo quanto da atividade de negociação em bolsa, até para que o modelo possa ser devidamente aprimorado e refinado. Até por isso, e apesar de ter sido testado e validado o funcionamento do sistema aqui proposto, os índices e valores de referência para negociação de ações empregados têm caráter meramente educacional, não tendo qualquer embasamento prático ou teórico.

Dado esse alerta, vamos colocar a mão na massa!

Abaixo temos um agente de IA que realiza as seguintes tarefas:

• utiliza a biblioteca yfinance para obter informações referentes às 50 principais ações comercializadas na B3;
• utililza uma api para capturar notícias sobre essas empresas;
• realiza a análise de sentimentos das notícias recuperadas, classificando como positiva, negativa ou neutra;
• salva todas as informações em cache para aprimorar a performance do modelo;
• avaliar a variação do preço das ações como de alta, de baixa ou neutro;
• por fim, utiliza-se a biblioteca streamlit para gerar uma interface de visualização das recomendações obtidas.

Foi utilizada no exemplo para fins didáticos a api de notícias da página https://newsapi.org, que oferece na versão gratuíta um número limitado de consultas diárias.

# Instalação das dependências
# pip install yfinance transformers requests datetime pandas streamlit logging

import yfinance as yf
from transformers.pipelines import pipeline
import requests
from datetime import datetime, timedelta
import pandas as pd
import streamlit as st
import logging

# Opcional: silenciar warning do watcher do torch
logging.getLogger("streamlit.watcher.local_sources_watcher").setLevel(logging.ERROR)

# Configurações
CACHE_DURATION = timedelta(minutes=10)
API_KEY = "DIGITE AQUI SUA API KEY OBTIDA EM https://newsapi.org"

# Lista expandida das 50 maiores ações da B3
tickers = {
  "ABEV3.SA": "Ambev S/A", "ASAI3.SA": "Assaí", "AZUL4.SA": "Azul",
  "B3SA3.SA": "B3", "BBSE3.SA": "BB Seguridade", "BBDC4.SA": "Bradesco",
  "BBAS3.SA": "Banco do Brasil", "BRAV3.SA": "Brava", "BRFS3.SA": "BRF",
  "BPAC11.SA": "BTG Pactual", "CRFB3.SA": "Carrefour Brasil", "CMIG4.SA": "Cemig",
  "CPLE6.SA": "Copel", "CSAN3.SA": "Cosan", "CYRE3.SA": "Cyrela",
  "ELET3.SA": "Eletrobras ON", "EMBR3.SA": "Embraer", "ENGI11.SA": "Energisa",
  "ENEV3.SA": "Eneva", "EQTL3.SA": "Equatorial", "GGBR4.SA": "Gerdau",
  "NTCO3.SA": "Natura", "HAPV3.SA": "Hapvida", "HYPE3.SA": "Hypera",
  "ITSA4.SA": "Itausa", "ITUB4.SA": "Itaú Unibanco", "JBSS3.SA": "JBS",
  "KLBN11.SA": "Klabin", "RENT3.SA": "Localiza", "LREN3.SA": "Lojas Renner",
  "MGLU3.SA": "Magalu", "MRFG3.SA": "Marfrig", "MOTV3.SA": "Motiva",
  "MULT3.SA": "Multiplan", "PETR3.SA": "Petrobras ON", "PETR4.SA": "Petrobras PN",
  "PRIO3.SA": "PetroRio", "RADL3.SA": "Raia Drogasil", "RDOR3.SA": "Rede D’Or",
  "RAIL3.SA": "Rumo", "SBSP3.SA": "Sabesp", "CSNA3.SA": "CSN",
  "SUZB3.SA": "Suzano", "VIVT3.SA": "Telefônica Brasil", "TIMS3.SA": "TIM",
  "TOTS3.SA": "TOTVS", "UGPA3.SA": "Ultrapar", "VALE3.SA": "Vale",
  "VBBR3.SA": "Vibra Energia", "WEGE3.SA": "WEG"
}

# Inicializa modelo de sentimento
sentiment_model = pipeline(
  "sentiment-analysis",
  model="pysentimiento/robertuito-sentiment-analysis"
)

# Caches
defense = {}
cache_news = {}
cache_trend = {}
cache_sentiment = {}

# Função genérica de cache
def cached_fetch(cache, key, fetch_fn):
  now = datetime.utcnow()
  if key in cache:
      ts, value = cache[key]
      if now - ts < CACHE_DURATION:
          return value
  value = fetch_fn()
  cache[key] = (now, value)
  return value

# Coleta de notícias
def get_news(company_name):
  def fetch():
      url = (
          f"https://newsapi.org/v2/everything?"
          f"q={company_name}&language=pt&sortBy=publishedAt&pageSize=5&apiKey={API_KEY}"
      )
      resp = requests.get(url).json().get('articles', [])
      texts = []
      for art in resp:
          title = art.get('title') or ''
          desc = art.get('description') or ''
          texts.append(f"{title}. {desc}" if desc else title)
      return texts
  return cached_fetch(cache_news, company_name, fetch)

# Tendência de preço
def get_trend(ticker):
  def fetch():
      df = yf.download(ticker, period="7d", interval="1d", auto_adjust=False)
      if df.empty or 'Close' not in df:
          return 'NEUTRO'
      close = df['Close']
      if isinstance(close, pd.DataFrame):
          close = close.iloc[:, 0]
      close = close.dropna()
      if len(close) < 2:
          return 'NEUTRO'
      first, last = float(close.iat[0]), float(close.iat[-1])
      return 'ALTA' if last > first else 'BAIXA'
  return cached_fetch(cache_trend, ticker, fetch)

# Análise de sentimento
def analyze_sentiment(texts):
  key = tuple(texts)
  def fetch():
      results = sentiment_model(texts)
      scores = {'POS': 0, 'NEG': 0, 'NEU': 0}
      for r in results:
          scores[r['label']] += 1
      return max(scores, key=scores.get)
  return cached_fetch(cache_sentiment, key, fetch)

# Gera recomendação
def recomendar_acao(ticker, nome):
  news = get_news(nome)
  sent = analyze_sentiment(news) if news else 'NEU'
  trend = get_trend(ticker)
  motivo = f"Sentimento {'POSITIVO' if sent=='POS' else 'NEGATIVO' if sent=='NEG' else 'NEUTRO'} e tendência de {trend}"
  if sent == 'POS' and trend == 'ALTA':
      rec = 'COMPRA'
  elif sent == 'NEG' and trend == 'BAIXA':
      rec = 'VENDA'
  else:
      rec = 'INDEFINIDA'
  return rec, motivo

# Interface Streamlit
st.title("Orientador de Investimentos - B3 40 Maiores")
if st.button("Atualizar Recomendações"):
  cache_news.clear()
  cache_trend.clear()
  cache_sentiment.clear()

recs = []

for ticker, name in tickers.items():
  rec, motivo = recomendar_acao(ticker, name)
  recs.append({'Ticker': ticker, 'Empresa': name, 'Recomendação': rec, 'Motivo': motivo})

df_recs = pd.DataFrame(recs)

st.dataframe(df_recs)

st.write("Última atualização: ", datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC"))

Salve o código acima em um arquivo com o nome “recomendador_streamlit.py”.

Para executar o streamlit, digite:

streamlit run recomendador_streamlit.py

O objetivo desse artigo foi demonstrar de maneira prática como o Python e os Agentes de IA se popularizaram, em especial pela característica fundamental da linguagem de simplicidade e praticidade. Como pôde ser visto, com poucas linhas de código e através do uso de bibliotecas públicas compartilhadas pela profícua comunidade de desenvolvedores Python é possível criar agentes de IA.

Pronto, agora você sabe que a curva de aprendizagem da IA com Python é bem menos ingreme do que parece, não precisa temer. Dedique-se e para alavancar sua vontade de aprender e desenvolver soluções.

Aproveite esse conhecimento e desenvolva agentes que automatizem ou realizem tarefas de maneira autônoma para antender suas necessidades ou de seus clientes.