Ferramentas Python para Data Science: Guia Completo 2026 | python.dev.br

Python é a linguagem número um para ciência de dados — e não é por acaso. O ecossistema de ferramentas e bibliotecas para análise, visualização e machine learning é o mais completo e maduro que existe. Neste guia, vamos revisar as ferramentas essenciais para quem trabalha (ou quer trabalhar) com data science em Python, com comparativos práticos e recomendações para 2026.

Ambientes de Desenvolvimento

Jupyter Notebook e JupyterLab

O Jupyter Notebook é o ambiente interativo padrão para ciência de dados. Permite executar código em células, intercalando código Python, texto em Markdown, equações LaTeX e visualizações:

import pandas as pd
import matplotlib.pyplot as plt

# Carregar dados
df = pd.read_csv("vendas_2026.csv")

# Análise rápida
df.groupby("região")["receita"].sum().plot(kind="bar")
plt.title("Receita por Região")
plt.show()

O JupyterLab é a evolução do Notebook clássico — interface moderna, abas múltiplas, terminal integrado e extensões. Em 2026, o JupyterLab é a versão recomendada. Confira nosso guia de configuração do Jupyter.

Google Colab

Para quem precisa de GPU gratuita ou quer compartilhar notebooks sem configurar ambiente local, o Google Colab é a melhor opção. Roda na nuvem, já vem com todas as bibliotecas de data science instaladas e permite colaboração em tempo real.

VS Code com Jupyter

O VS Code também suporta notebooks Jupyter nativamente, combinando o melhor dos dois mundos: a interatividade do Jupyter com o autocomplete, debugging e Git do VS Code. Veja nosso guia de VS Code para Python.

Manipulação de Dados

Pandas — O Canivete Suíço

O Pandas é a biblioteca mais usada para manipulação de dados tabulares. Com DataFrames poderosos, ele permite carregar, limpar, transformar e analisar dados de praticamente qualquer fonte:

import pandas as pd

# Leitura de dados
df = pd.read_csv("dados.csv")
df_excel = pd.read_excel("planilha.xlsx")
df_json = pd.read_json("api_response.json")

# Limpeza e transformação
df = df.dropna(subset=["salario"])
df["salario_mensal"] = df["salario_anual"] / 12
df["senioridade"] = df["anos_exp"].apply(
    lambda x: "Sênior" if x >= 5 else "Pleno" if x >= 2 else "Júnior"
)

# Agregações
resumo = df.groupby("senioridade").agg(
    media_salarial=("salario_mensal", "mean"),
    total_vagas=("id", "count")
).round(2)

Para um guia detalhado, confira Introdução ao Pandas e o guia de análise de dados com Pandas.

Polars — A Alternativa Ultrarrápida

O Polars é a alternativa moderna ao Pandas, escrita em Rust, que oferece performance massivamente superior para datasets grandes:

import polars as pl

# Polars usa lazy evaluation por padrão
df = (
    pl.scan_csv("dados_grandes.csv")
    .filter(pl.col("estado") == "SP")
    .group_by("cargo")
    .agg(
        pl.col("salario").mean().alias("media_salarial"),
        pl.col("id").count().alias("total")
    )
    .sort("media_salarial", descending=True)
    .collect()  # Executa o plano otimizado
)

DuckDB — SQL para Analytics

O DuckDB traz o poder do SQL para análise de dados local, sem precisar de servidor:

import duckdb

# SQL direto em arquivos CSV e Parquet
resultado = duckdb.sql("""
    SELECT estado, AVG(salario) as media
    FROM 'dados.parquet'
    GROUP BY estado
    ORDER BY media DESC
    LIMIT 10
""").df()

Comparativo de Ferramentas de Dados

Polars e DuckDB são escritos em Rust — a linguagem que está revolucionando performance em ferramentas de dados. Conheça Rust em rustlang.com.br.

Computação Numérica

NumPy

O NumPy é a base de todo o ecossistema científico do Python. Fornece arrays multidimensionais eficientes e operações vetorizadas:

import numpy as np

# Arrays e operações vetorizadas
precos = np.array([29.90, 49.90, 99.90, 149.90])
precos_com_desconto = precos * 0.85  # 15% de desconto em todos

# Estatísticas
print(f"Média: R$ {precos.mean():.2f}")
print(f"Desvio padrão: R$ {precos.std():.2f}")

# Álgebra linear
matriz = np.array([[1, 2], [3, 4]])
inversa = np.linalg.inv(matriz)
autovalores = np.linalg.eigvals(matriz)

NumPy é usado internamente por praticamente toda biblioteca de data science — Pandas, scikit-learn, TensorFlow, PyTorch.

Visualização de Dados

Matplotlib

O Matplotlib é a biblioteca de visualização mais tradicional e completa do Python. Oferece controle total sobre cada aspecto do gráfico:

import matplotlib.pyplot as plt
import numpy as np

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# Gráfico de barras
categorias = ["Python", "JavaScript", "Go", "Rust", "Kotlin"]
salarios = [12500, 11000, 15000, 16000, 13500]
axes[0].barh(categorias, salarios, color="#306998")
axes[0].set_title("Salário Médio por Linguagem")
axes[0].set_xlabel("R$/mês")

# Gráfico de linha
meses = np.arange(1, 13)
vagas = [120, 135, 150, 180, 210, 250, 230, 260, 290, 310, 340, 380]
axes[1].plot(meses, vagas, marker="o", color="#FFD43B")
axes[1].set_title("Vagas Python por Mês (2026)")
axes[1].set_xlabel("Mês")
axes[1].set_ylabel("Vagas")

plt.tight_layout()
plt.savefig("analise.png", dpi=150)
plt.show()

Veja nosso guia de Matplotlib para exemplos detalhados.

Seaborn

O Seaborn é construído sobre Matplotlib e oferece gráficos estatísticos mais bonitos com menos código:

import seaborn as sns

# Gráfico estatístico em uma linha
sns.boxplot(data=df, x="senioridade", y="salario", palette="Blues")
plt.title("Distribuição Salarial por Senioridade")

Plotly

O Plotly cria gráficos interativos que podem ser explorados no browser — zoom, hover, filtros:

import plotly.express as px

fig = px.scatter(
    df, x="anos_experiencia", y="salario",
    color="linguagem", size="projetos",
    title="Salário vs Experiência"
)
fig.show()

Comparativo de Visualização

Machine Learning

scikit-learn

O scikit-learn é o framework de machine learning mais usado do mundo. Interface consistente, documentação excelente e algoritmos para praticamente tudo:

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Preparar dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Treinar modelo
modelo = RandomForestClassifier(n_estimators=100, random_state=42)
modelo.fit(X_train, y_train)

# Avaliar
previsoes = modelo.predict(X_test)
print(classification_report(y_test, previsoes))

Confira nosso guia de machine learning com Python para começar.

Ecossistema de ML Avançado

Para projetos mais complexos:

• XGBoost / LightGBM — gradient boosting otimizado, top em competições Kaggle
• PyTorch — deep learning com autograd dinâmico, preferido por pesquisadores
• TensorFlow / Keras — deep learning com deploy em produção (TFServing, TFLite)
• Hugging Face Transformers — modelos de NLP pré-treinados (BERT, GPT, etc.)
• LangChain — integração com LLMs e APIs de IA

Dashboards e Apps de Dados

Streamlit

O Streamlit permite criar dashboards e apps de dados com puro Python — sem HTML, CSS ou JavaScript:

import streamlit as st
import pandas as pd

st.title("Dashboard de Vendas")

df = pd.read_csv("vendas.csv")
regiao = st.selectbox("Região:", df["região"].unique())
df_filtrado = df[df["região"] == regiao]

st.metric("Total de Vendas", f"R$ {df_filtrado['valor'].sum():,.2f}")
st.bar_chart(df_filtrado.groupby("produto")["valor"].sum())

Alternativas

• Gradio — interfaces para modelos de ML (demos rápidos)
• Panel — dashboards analíticos avançados
• Dash — dashboards com Plotly (mais customizável, mais complexo)

O Stack Recomendado para Data Science em 2026

Conclusão

O ecossistema Python para data science é imbatível em 2026. A tendência é a adoção crescente de ferramentas de alta performance como Polars e DuckDB (ambas escritas em Rust), enquanto Pandas, NumPy e scikit-learn continuam como a fundação sólida do dia a dia.

Se você está começando em data science, foque primeiro em Pandas, Matplotlib e scikit-learn. Depois, explore Polars para performance e Streamlit para compartilhar seus resultados.

Dica para o mercado de trabalho: empresas brasileiras buscam profissionais que dominem esse stack. Confira as vagas disponíveis e os salários na área. E se você está explorando linguagens complementares para data engineering, veja Go e Kotlin — ambas muito usadas em pipelines de dados.

Para referência rápida da linguagem, acesse nosso cheatsheet Python, e para entender conceitos fundamentais, explore o glossário.