Python para Ciência de Dados em 2026

Python se consolidou como a linguagem padrão para ciência de dados, e em 2026 essa posição está mais forte do que nunca. Neste guia, você vai aprender a usar as quatro bibliotecas fundamentais do ecossistema de dados: NumPy, Pandas, Matplotlib e scikit-learn.

Configurando o Ambiente

Antes de começar, vamos preparar o ambiente de desenvolvimento:

# Instale as bibliotecas necessárias:
# pip install numpy pandas matplotlib scikit-learn jupyter

# Ou usando conda:
# conda install numpy pandas matplotlib scikit-learn jupyter

NumPy: A Base de Tudo

NumPy é a biblioteca fundamental para computação numérica em Python. Todas as outras bibliotecas de dados são construídas sobre ela.

Arrays NumPy

import numpy as np

# Criando arrays
array_1d = np.array([1, 2, 3, 4, 5])
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print(f"Formato: {array_2d.shape}")  # (3, 3)
print(f"Tipo: {array_2d.dtype}")     # int64
print(f"Dimensões: {array_2d.ndim}") # 2

# Arrays especiais
zeros = np.zeros((3, 4))           # Matriz 3x4 de zeros
uns = np.ones((2, 3))              # Matriz 2x3 de uns
sequencia = np.arange(0, 10, 0.5)  # [0, 0.5, 1.0, ..., 9.5]
linear = np.linspace(0, 1, 5)      # [0, 0.25, 0.5, 0.75, 1.0]
aleatorio = np.random.randn(3, 3)  # Matriz 3x3 aleatória (normal)

Operações vetorizadas

import numpy as np

# Operações são aplicadas elemento por elemento
a = np.array([1, 2, 3, 4, 5])
b = np.array([10, 20, 30, 40, 50])

print(a + b)    # [11, 22, 33, 44, 55]
print(a * b)    # [10, 40, 90, 160, 250]
print(a ** 2)   # [1, 4, 9, 16, 25]
print(np.sqrt(a))  # [1.0, 1.41, 1.73, 2.0, 2.24]

# Estatísticas básicas
dados = np.array([23, 45, 12, 67, 34, 89, 11, 56, 78, 42])

print(f"Média: {dados.mean():.2f}")
print(f"Mediana: {np.median(dados):.2f}")
print(f"Desvio padrão: {dados.std():.2f}")
print(f"Mínimo: {dados.min()}, Máximo: {dados.max()}")
print(f"Soma: {dados.sum()}")

# Indexação booleana
maiores_que_40 = dados[dados > 40]
print(f"Valores maiores que 40: {maiores_que_40}")

Álgebra linear

import numpy as np

# Multiplicação de matrizes
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

produto = A @ B  # ou np.dot(A, B)
print("Produto matricial:")
print(produto)

# Transposta e inversa
print(f"Transposta:\n{A.T}")
print(f"Determinante: {np.linalg.det(A):.2f}")
print(f"Inversa:\n{np.linalg.inv(A)}")

Pandas: Manipulação de Dados

Pandas é a biblioteca mais importante para análise de dados em Python. O DataFrame é sua estrutura central — pense nele como uma planilha superpoderosa.

Criando DataFrames

import pandas as pd

# A partir de um dicionário
vendas = pd.DataFrame({
    "produto": ["Notebook", "Mouse", "Teclado", "Monitor", "Webcam"],
    "preco": [3500, 89.90, 199.90, 1200, 250],
    "quantidade": [150, 500, 300, 200, 180],
    "categoria": ["Computador", "Acessório", "Acessório", "Computador", "Acessório"]
})

print(vendas)
print(vendas.info())
print(vendas.describe())

Leitura de dados

import pandas as pd

# Ler CSV
# df = pd.read_csv("dados.csv")
# df = pd.read_csv("dados.csv", sep=";", encoding="utf-8")

# Ler Excel
# df = pd.read_excel("dados.xlsx", sheet_name="Planilha1")

# Ler JSON
# df = pd.read_json("dados.json")

# Exemplo com dados criados
dados = pd.DataFrame({
    "data": pd.date_range("2025-01-01", periods=12, freq="M"),
    "receita": [45000, 52000, 48000, 61000, 55000, 70000,
                63000, 72000, 68000, 80000, 75000, 95000],
    "despesa": [38000, 42000, 39000, 45000, 41000, 48000,
                47000, 50000, 49000, 55000, 52000, 60000],
})

dados["lucro"] = dados["receita"] - dados["despesa"]
dados["margem"] = (dados["lucro"] / dados["receita"] * 100).round(2)

print(dados.head())
print(f"\nReceita total: R${dados['receita'].sum():,.2f}")
print(f"Lucro médio mensal: R${dados['lucro'].mean():,.2f}")

Filtragem e seleção

import pandas as pd

funcionarios = pd.DataFrame({
    "nome": ["Ana", "Carlos", "Maria", "João", "Pedro", "Lucia"],
    "departamento": ["TI", "RH", "TI", "Vendas", "TI", "RH"],
    "salario": [8500, 6200, 9800, 5500, 7200, 6800],
    "experiencia": [5, 3, 8, 2, 4, 6],
})

# Filtrar por condição
ti = funcionarios[funcionarios["departamento"] == "TI"]
print("Funcionários de TI:")
print(ti)

# Múltiplas condições
seniors = funcionarios[
    (funcionarios["experiencia"] >= 5) & (funcionarios["salario"] > 7000)
]
print("\nSeniores com bom salário:")
print(seniors)

# Agrupamento
por_depto = funcionarios.groupby("departamento").agg({
    "salario": ["mean", "min", "max"],
    "nome": "count"
}).round(2)
print("\nEstatísticas por departamento:")
print(por_depto)

Tratamento de dados

import pandas as pd
import numpy as np

# Dados com problemas (realidade do dia a dia!)
dados_sujos = pd.DataFrame({
    "nome": ["Ana", "Carlos", None, "Maria", "João", "Ana"],
    "idade": [28, 35, 22, None, 45, 28],
    "salario": [5000, None, 3500, 7200, 8000, 5000],
    "cidade": ["São Paulo", "rio de janeiro", "São Paulo",
               "BELO HORIZONTE", "são paulo", "São Paulo"],
})

print("Dados originais:")
print(dados_sujos)

# Verificar valores nulos
print(f"\nValores nulos:\n{dados_sujos.isnull().sum()}")

# Preencher valores nulos
dados_limpos = dados_sujos.copy()
dados_limpos["salario"].fillna(dados_limpos["salario"].median(), inplace=True)
dados_limpos.dropna(subset=["nome"], inplace=True)

# Padronizar texto
dados_limpos["cidade"] = dados_limpos["cidade"].str.title()

# Remover duplicatas
dados_limpos.drop_duplicates(subset=["nome"], keep="first", inplace=True)

print("\nDados limpos:")
print(dados_limpos)

Matplotlib: Visualização de Dados

Matplotlib é a biblioteca padrão para criar gráficos em Python.

import matplotlib.pyplot as plt
import numpy as np

# Gráfico de linha
meses = ["Jan", "Fev", "Mar", "Abr", "Mai", "Jun"]
receita = [45, 52, 48, 61, 55, 70]
despesa = [38, 42, 39, 45, 41, 48]

plt.figure(figsize=(10, 6))
plt.plot(meses, receita, marker="o", linewidth=2, label="Receita")
plt.plot(meses, despesa, marker="s", linewidth=2, label="Despesa")
plt.title("Receita vs Despesa - 2025", fontsize=16)
plt.xlabel("Mês")
plt.ylabel("Valor (R$ mil)")
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig("receita_despesa.png", dpi=150)
plt.show()

Múltiplos gráficos

import matplotlib.pyplot as plt
import numpy as np

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

# 1. Gráfico de barras
categorias = ["Python", "JavaScript", "Java", "C++", "Go"]
popularidade = [30, 25, 20, 15, 10]
axes[0, 0].bar(categorias, popularidade, color=["#3776AB", "#F7DF1E",
               "#ED8B00", "#00599C", "#00ADD8"])
axes[0, 0].set_title("Popularidade de Linguagens")
axes[0, 0].set_ylabel("Porcentagem (%)")

# 2. Gráfico de pizza
axes[0, 1].pie(popularidade, labels=categorias, autopct="%1.1f%%",
               startangle=90)
axes[0, 1].set_title("Distribuição de Linguagens")

# 3. Histograma
np.random.seed(42)
salarios = np.random.normal(8000, 2000, 1000)
axes[1, 0].hist(salarios, bins=30, edgecolor="black", alpha=0.7)
axes[1, 0].set_title("Distribuição de Salários")
axes[1, 0].set_xlabel("Salário (R$)")
axes[1, 0].set_ylabel("Frequência")

# 4. Scatter plot
experiencia = np.random.uniform(1, 15, 100)
salario = 3000 + experiencia * 800 + np.random.normal(0, 1500, 100)
axes[1, 1].scatter(experiencia, salario, alpha=0.6)
axes[1, 1].set_title("Experiência vs Salário")
axes[1, 1].set_xlabel("Anos de Experiência")
axes[1, 1].set_ylabel("Salário (R$)")

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

scikit-learn: Machine Learning

scikit-learn é a biblioteca padrão para machine learning em Python, com uma API consistente e fácil de usar.

Exemplo completo: prevendo preços de imóveis

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score

# Gerando dados de exemplo (simulação)
np.random.seed(42)
n = 500

dados = pd.DataFrame({
    "area_m2": np.random.uniform(30, 200, n),
    "quartos": np.random.randint(1, 5, n),
    "banheiros": np.random.randint(1, 4, n),
    "vagas": np.random.randint(0, 3, n),
    "andar": np.random.randint(1, 20, n),
})

# Preço baseado nas features (com ruído)
dados["preco"] = (
    dados["area_m2"] * 5000
    + dados["quartos"] * 50000
    + dados["banheiros"] * 30000
    + dados["vagas"] * 40000
    + dados["andar"] * 2000
    + np.random.normal(0, 50000, n)
)

print("Primeiras linhas dos dados:")
print(dados.head())
print(f"\nFormato: {dados.shape}")
print(f"\nEstatísticas do preço:")
print(dados["preco"].describe())

Treinamento e avaliação do modelo

# Separando features e target
X = dados[["area_m2", "quartos", "banheiros", "vagas", "andar"]]
y = dados["preco"]

# Dividindo em treino e teste
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f"Dados de treino: {X_train.shape[0]} amostras")
print(f"Dados de teste: {X_test.shape[0]} amostras")

# Normalizando os dados
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Modelo 1: Regressão Linear
modelo_lr = LinearRegression()
modelo_lr.fit(X_train_scaled, y_train)
pred_lr = modelo_lr.predict(X_test_scaled)

print("\n--- Regressão Linear ---")
print(f"R²: {r2_score(y_test, pred_lr):.4f}")
print(f"RMSE: R${np.sqrt(mean_squared_error(y_test, pred_lr)):,.2f}")

# Modelo 2: Random Forest
modelo_rf = RandomForestRegressor(n_estimators=100, random_state=42)
modelo_rf.fit(X_train, y_train)
pred_rf = modelo_rf.predict(X_test)

print("\n--- Random Forest ---")
print(f"R²: {r2_score(y_test, pred_rf):.4f}")
print(f"RMSE: R${np.sqrt(mean_squared_error(y_test, pred_rf)):,.2f}")

# Importância das features
importancia = pd.DataFrame({
    "feature": X.columns,
    "importancia": modelo_rf.feature_importances_
}).sort_values("importancia", ascending=False)

print("\nImportância das features:")
print(importancia)

Fazendo previsões

# Prevendo o preço de um novo imóvel
novo_imovel = pd.DataFrame({
    "area_m2": [85],
    "quartos": [3],
    "banheiros": [2],
    "vagas": [1],
    "andar": [7],
})

preco_previsto = modelo_rf.predict(novo_imovel)
print(f"\nPreço previsto para o imóvel:")
print(f"  Área: 85m², 3 quartos, 2 banheiros, 1 vaga, 7º andar")
print(f"  Valor estimado: R${preco_previsto[0]:,.2f}")

Pipeline Completo de Data Science

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import cross_val_score

# Definindo o pipeline
preprocessor = ColumnTransformer(
    transformers=[
        ("num", StandardScaler(), ["area_m2", "quartos",
                                    "banheiros", "vagas", "andar"]),
    ]
)

pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("regressor", GradientBoostingRegressor(
        n_estimators=200,
        max_depth=5,
        random_state=42
    )),
])

# Validação cruzada
scores = cross_val_score(pipeline, X, y, cv=5, scoring="r2")
print(f"R² médio (5-fold CV): {scores.mean():.4f} (+/- {scores.std():.4f})")

# Treinar o modelo final
pipeline.fit(X_train, y_train)
pred_final = pipeline.predict(X_test)
print(f"R² no teste: {r2_score(y_test, pred_final):.4f}")

Próximos Passos

Agora que você conhece as bases, aqui vão sugestões para aprofundar seus estudos:

Seaborn: Visualizações estatísticas mais elegantes
Plotly: Gráficos interativos
Deep Learning: TensorFlow ou PyTorch
NLP: spaCy ou Hugging Face Transformers
Big Data: PySpark para grandes volumes de dados
MLOps: MLflow para gerenciar experimentos

O ecossistema de ciência de dados em Python é imenso e continua crescendo. O mais importante é começar com projetos práticos usando dados reais — e o Kaggle é um excelente lugar para encontrar datasets e desafios.

Bons estudos e boas análises!