Bibliotecas Python para manipulação e análise de dados: Pandas e NumPy na prática

As bibliotecas Python funcionam como caixas de ferramentas para programadores. Em vez de escrever tudo do zero, você pode importar funções e objetos já prontos dessas caixas, que resolvem tarefas específicas de forma rápida e confiável. Por isso, você pode encontrar diferentes “caixas” por aí, aplicadas com diferentes objetivos.

Mas quando o assunto são bibliotecas Python para manipulação e análise de dados, duas merecem atenção: Pandas e NumPy. Neste artigo, você vai entender como elas funcionam, suas diferenças e quando usá-las juntas.

O que é Pandas?

Pandas é uma biblioteca Python criada por Wes McKinney em 2008, hoje considerada o padrão para manipulação e análise de dados estruturados. Com ela, você pode trabalhar com informações organizadas em tabelas de forma muito mais rápida do que em ferramentas tradicionais.

No dia a dia, o Pandas ajuda em tarefas como organizar, limpar e explorar dados. Você pode usar essa biblioteca sempre que precisar trabalhar com dados tabulares, como aqueles que você encontraria em:

• Planilhas do Excel ou CSV;
• Tabelas de bancos de dados;
• Dados de APIs web;
• Arquivos JSON ou XML.

Faça o curso:

Analisando Dados com Pandas & SQL

Principais estruturas do Pandas

O Pandas trabalha com duas estruturas básicas:

• Series: lista unidimensional com rótulos em cada elemento (1D);
• DataFrame: tabela bidimensional com linhas e colunas, semelhante a uma planilha do Excel.

Entre as duas, o DataFrame é a mais utilizada, já que facilita a manipulação de grandes volumes de dados de forma simples e eficiente.

Principais aplicações do Pandas

O Pandas é versátil e pode ser usado em diferentes etapas de um projeto de dados, incluindo:

• Leitura e escrita de dados em vários formatos, como CSV, Excel, JSON, SQL, Parquet;
• Limpeza e pré-processamento, como tratamento de valores ausentes, duplicados e inconsistências;
• Transformação de dados, com operações de filtragem, agregação e combinação de diferentes conjuntos;
• Análise exploratória, permitindo gerar estatísticas descritivas, agrupamentos e tabelas dinâmicas;
• Preparação dos dados para visualizações ou modelos de machine learning.

Faça o curso:

Análise Exploratória de Dados

Exemplo prático com Pandas

Vamos supor que você tem uma planilha de clientes e precisa agrupar informações por região, calcular o total de compras ou filtrar colunas específicas. O Pandas torna esse processo simples e direto:

import pandas as pd

# "Planilha" de clientes
df = pd.DataFrame({
    "cliente": ["Ana", "Bruno", "Carlos", "Ana", "Bruno", "Dani"],
    "regiao":  ["Sul", "Sudeste", "Sul",  "Sul", "Sudeste", "Nordeste"],
    "compras": [3, 2, 1, 2, 4, 1],
    "receita": [450, 300, 150, 320, 720, 120]
})

# 1) Limpeza rápida
df = df.drop_duplicates()                 # remove duplicatas
df["receita"] = df["receita"].fillna(0)   # trata valores ausentes

# 2) Filtros e seleção
sudeste = df[df["regiao"] == "Sudeste"]   # apenas registros do Sudeste
colunas  = df[["cliente", "receita"]]     # colunas específicas

# 3) Métricas por grupo (relatório por região)
por_regiao = df.groupby("regiao", as_index=False).agg(
    total_receita=("receita", "sum"),
    media_receita=("receita", "mean"),
    total_compras=("compras", "sum")
).sort_values("total_receita", ascending=False)

# 4) Nova coluna derivada (ticket médio)
df["ticket_medio"] = df["receita"] / df["compras"]

print(por_regiao)
print(df.head())

import pandas as pd

# "Planilha" de clientes
df = pd.DataFrame({
    "cliente": ["Ana", "Bruno", "Carlos", "Ana", "Bruno", "Dani"],
    "regiao":  ["Sul", "Sudeste", "Sul",  "Sul", "Sudeste", "Nordeste"],
    "compras": [3, 2, 1, 2, 4, 1],
    "receita": [450, 300, 150, 320, 720, 120]
})

# 1) Limpeza rápida
df = df.drop_duplicates()                 # remove duplicatas
df["receita"] = df["receita"].fillna(0)   # trata valores ausentes

# 2) Filtros e seleção
sudeste = df[df["regiao"] == "Sudeste"]   # apenas registros do Sudeste
colunas  = df[["cliente", "receita"]]     # colunas específicas

# 3) Métricas por grupo (relatório por região)
por_regiao = df.groupby("regiao", as_index=False).agg(
    total_receita=("receita", "sum"),
    media_receita=("receita", "mean"),
    total_compras=("compras", "sum")
).sort_values("total_receita", ascending=False)

# 4) Nova coluna derivada (ticket médio)
df["ticket_medio"] = df["receita"] / df["compras"]

print(por_regiao)
print(df.head())

Esse código mostra como o Pandas facilita o trabalho com dados em formato de tabela. O processo inclui:

• Limpeza dos dados: remoção de duplicatas e tratamento de valores ausentes;
• Filtros e seleção: escolha de registros por região ou colunas específicas;
• Agrupamento: cálculo de soma, média e totais de compras por região;
• Criação de colunas derivadas: como o ticket médio por cliente.

Ou seja, com poucos comandos, o Pandas transforma uma planilha bruta em relatórios organizados e insights úteis.

O que é NumPy?

NumPy (abreviação de Numerical Python) é a biblioteca do Python voltada para operações numéricas e computação científica. Criado em 2005 por Travis Oliphant, ele unificou ferramentas antigas e hoje é a base de grande parte do ecossistema de análise de dados em Python.

Faça o curso:

Introdução à Biblioteca Numpy

Estrutura principal do NumPy

O NumPy é construído em torno dos arrays multidimensionais, também chamados de ndarray. Essa estrutura armazena dados de um mesmo tipo de forma muito mais eficiente que as listas comuns do Python.

Com os arrays do NumPy, você tem:

• Mais velocidade nas operações;
• Menor uso de memória;
• Operações matemáticas em blocos, sem precisar de loops.

Essa otimização é chamada de vetorização e é o que torna o NumPy tão rápido.

Leia também:

Matemática para programação: como usar na prática

Principais aplicações do NumPy

Você vai usar NumPy sempre que precisar de cálculos rápidos e precisos com grandes volumes de dados. Ele é ideal para:

• Operações matemáticas e estatísticas;
• Álgebra linear e transformadas de Fourier;
• Geração de números aleatórios, como simulações e modelos estatísticos;
• Manipulação de arrays multidimensionais.
• Suporte a outras bibliotecas que dependem de arrays, como Pandas, Matplotlib e Scikit-Learn.

Exemplo prático com NumPy

Imagine que você tenha um vetor com valores de vendas e queira calcular métricas como média, soma, desvio padrão ou aplicar transformações matemáticas sem precisar escrever loops. O NumPy resolve isso em poucas linhas:

import numpy as np

# Vetor de vendas (em R$)
vendas = np.array([1200, 1350, 1100, 1600, 1800, 1700, 1500])

# 1) Estatísticas em 1 linha
media = vendas.mean()
desvio = vendas.std()
total  = vendas.sum()

# 2) Transformações vetorizadas (ex.: aplicar desconto de 10%)
com_desconto = vendas * 0.90

# 3) Normalização (z-score) para comparar meses
zscore = (vendas - media) / desvio

# 4) Máscaras booleanas (ex.: meses acima da média)
acima_media = vendas[vendas > media]

print(media, desvio, total)
print(com_desconto)
print(zscore.round(2))
print(acima_media)

import numpy as np

# Vetor de vendas (em R$)
vendas = np.array([1200, 1350, 1100, 1600, 1800, 1700, 1500])

# 1) Estatísticas em 1 linha
media = vendas.mean()
desvio = vendas.std()
total  = vendas.sum()

# 2) Transformações vetorizadas (ex.: aplicar desconto de 10%)
com_desconto = vendas * 0.90

# 3) Normalização (z-score) para comparar meses
zscore = (vendas - media) / desvio

# 4) Máscaras booleanas (ex.: meses acima da média)
acima_media = vendas[vendas > media]

print(media, desvio, total)
print(com_desconto)
print(zscore.round(2))
print(acima_media)

Esse exemplo mostra como o NumPy facilita cálculos numéricos em blocos de dados:

• Estatísticas básicas: média, soma e desvio padrão em uma linha;
• Transformações vetorizadas: aplicar descontos ou multiplicações a todos os valores;
• Normalização com z-score: identificar desvios em relação à média;
• Filtros booleanos: selecionar apenas os meses acima da média.

Ou seja, o NumPy permite analisar e manipular grandes volumes de números de forma rápida, simples e eficiente.

Pandas vs NumPy: quando usar cada um

Ambas são bibliotecas Python para manipulação e análise de dados. Embora pareçam concorrentes, na verdade elas se complementam.

• O Pandas foi criado para trabalhar com dados em tabelas (linhas e colunas). Ele é ideal para organizar, limpar, filtrar e analisar informações estruturadas;
• O NumPy é voltado para cálculos numéricos de alta performance em arrays multidimensionais. Ele é mais rápido, ocupa menos memória e funciona muito bem em operações matemáticas intensivas.

Em termos de desempenho:

• O NumPy costuma ser mais eficiente em conjuntos pequenos e médios (até ~50 mil linhas), pois foi otimizado para operações vetorizadas;
• O Pandas escala melhor em grandes volumes (a partir de ~500 mil linhas), especialmente em tarefas de agrupamento e agregação.

Na prática, a melhor estratégia é combinar as duas bibliotecas: usar o NumPy para cálculos pesados e o Pandas para organização e análise exploratória. Essa união é o que faz do Python uma das principais ferramentas para ciência de dados.

Tabela comparativa: Pandas vs NumPy

Curso Gratuito

Saia do zero e analise dados com Python e Pandas neste curso gratuito com certificado!

Realize análises poderosas que vão muito além do que ferramentas como Excel podem oferecer.

Comece agora

Como integrar Pandas e NumPy em projetos de análise de dados?

Conforme explicado, Pandas e NumPy são bibliotecas Python para manipulação e análise de dados que não competem entre si, mas que são complementares. Por isso, elas podem ser usadas juntas em diversos projetos.

Veja três exemplos simples de como aplicar essa integração:

1. Relatório de vendas mensais

Você tem um arquivo CSV chamado vendas_mensais.csv com as colunas mes (YYYY-MM) e vendas.

Arquivo de entrada:

mes,vendas
2024-01,25500
2024-02,21200
2024-03,27400
2024-04,19800
2024-05,30500
2024-06,23100

mes,vendas
2024-01,25500
2024-02,21200
2024-03,27400
2024-04,19800
2024-05,30500
2024-06,23100

Código em Python:

import pandas as pd
import numpy as np

# 1) Ler e organizar os dados (Pandas)
df = pd.read_csv("vendas_mensais.csv")  # colunas: mes, vendas
df["mes"] = pd.to_datetime(df["mes"]).dt.to_period("M").astype(str)
df["vendas"] = pd.to_numeric(df["vendas"], errors="coerce")
df = df.dropna(subset=["vendas"]).sort_values("mes")

# 2) Estatísticas globais (NumPy)
v = df["vendas"].to_numpy(dtype=float)
media  = v.mean()
desvio = v.std()

# 3) Marcar meses acima/abaixo da média
df["zscore"]      = (v - media) / desvio if desvio != 0 else 0
df["status"]      = np.where(df["vendas"] >= media, "acima", "abaixo")
df["desvio_rel%"] = ((df["vendas"] - media) / media * 100).round(1)

# 4) Relatórios rápidos (Pandas)
resumo_global = pd.DataFrame({
    "métrica": ["total", "média", "desvio_padrão", "n_meses", "meses_acima", "meses_abaixo"],
    "valor": [
        df["vendas"].sum(),
        round(media, 2),
        round(desvio, 2),
        len(df),
        int((df["status"] == "acima").sum()),
        int((df["status"] == "abaixo").sum()),
    ],
})

relatorio_mensal = df[["mes", "vendas", "status", "desvio_rel%", "zscore"]]

# 5) Exibir resultados
print("\n=== RESUMO GLOBAL ===")
print(resumo_global.to_string(index=False))

print("\n=== RELATÓRIO MENSAL ===")
print(relatorio_mensal.to_string(index=False))

import pandas as pd
import numpy as np

# 1) Ler e organizar os dados (Pandas)
df = pd.read_csv("vendas_mensais.csv")  # colunas: mes, vendas
df["mes"] = pd.to_datetime(df["mes"]).dt.to_period("M").astype(str)
df["vendas"] = pd.to_numeric(df["vendas"], errors="coerce")
df = df.dropna(subset=["vendas"]).sort_values("mes")

# 2) Estatísticas globais (NumPy)
v = df["vendas"].to_numpy(dtype=float)
media  = v.mean()
desvio = v.std()

# 3) Marcar meses acima/abaixo da média
df["zscore"]      = (v - media) / desvio if desvio != 0 else 0
df["status"]      = np.where(df["vendas"] >= media, "acima", "abaixo")
df["desvio_rel%"] = ((df["vendas"] - media) / media * 100).round(1)

# 4) Relatórios rápidos (Pandas)
resumo_global = pd.DataFrame({
    "métrica": ["total", "média", "desvio_padrão", "n_meses", "meses_acima", "meses_abaixo"],
    "valor": [
        df["vendas"].sum(),
        round(media, 2),
        round(desvio, 2),
        len(df),
        int((df["status"] == "acima").sum()),
        int((df["status"] == "abaixo").sum()),
    ],
})

relatorio_mensal = df[["mes", "vendas", "status", "desvio_rel%", "zscore"]]

# 5) Exibir resultados
print("\n=== RESUMO GLOBAL ===")
print(resumo_global.to_string(index=False))

print("\n=== RELATÓRIO MENSAL ===")
print(relatorio_mensal.to_string(index=False))

O que esse código faz?

• Lê e organiza o CSV (Pandas)
• Calcula média e desvio padrão das vendas (NumPy);
• Classifica os meses como “acima” ou “abaixo” da média;
• Gera relatórios prontos: um resumo global e outro mensal.

Esse exemplo mostra como Pandas e NumPy trabalham juntos: o primeiro organiza os dados, enquanto o segundo executa os cálculos estatísticos.

2. Detectando outliers nos dados de faturamento

Você tem dados de faturamento e desconfia de valores muito fora do padrão. Para identificar esses casos, pode usar o NumPy para calcular o z-score (distância em relação à média) e o Pandas para marcar e filtrar os outliers na tabela antes de gerar relatórios.

import pandas as pd
import numpy as np

# 1) Criar DataFrame de exemplo (poderia vir de um CSV)
df = pd.DataFrame({
    "mes": ["2024-01","2024-02","2024-03","2024-04","2024-05","2024-06"],
    "faturamento": [12000, 13500, 11000, 38000, 18000, 17000]  # note o valor alto (38000)
})

# 2) Converter a coluna em array NumPy
valores = df["faturamento"].to_numpy()

# 3) Calcular média e desvio padrão (NumPy)
media = valores.mean()
desvio = valores.std()

# 4) Calcular z-score para cada valor
zscore = (valores - media) / desvio

# 5) Marcar outliers no DataFrame (Pandas + NumPy)
df["zscore"] = zscore
df["outlier"] = np.abs(zscore) > 2   # regra simples: |z| > 2

# 6) Criar versão limpa (sem outliers)
df_limpo = df[~df["outlier"]]

print("=== Dados originais ===")
print(df)

print("\n=== Dados sem outliers ===")
print(df_limpo)

import pandas as pd
import numpy as np

# 1) Criar DataFrame de exemplo (poderia vir de um CSV)
df = pd.DataFrame({
    "mes": ["2024-01","2024-02","2024-03","2024-04","2024-05","2024-06"],
    "faturamento": [12000, 13500, 11000, 38000, 18000, 17000]  # note o valor alto (38000)
})

# 2) Converter a coluna em array NumPy
valores = df["faturamento"].to_numpy()

# 3) Calcular média e desvio padrão (NumPy)
media = valores.mean()
desvio = valores.std()

# 4) Calcular z-score para cada valor
zscore = (valores - media) / desvio

# 5) Marcar outliers no DataFrame (Pandas + NumPy)
df["zscore"] = zscore
df["outlier"] = np.abs(zscore) > 2   # regra simples: |z| > 2

# 6) Criar versão limpa (sem outliers)
df_limpo = df[~df["outlier"]]

print("=== Dados originais ===")
print(df)

print("\n=== Dados sem outliers ===")
print(df_limpo)

O que esse código faz?

• Organiza os dados em uma tabela com Pandas;
• Calcula a média e o desvio padrão do faturamento usando NumPy;
• Aplica o z-score para medir o quanto cada valor se afasta da média;
• Marca os outliers (valores muito distantes do padrão);
• Gera uma versão limpa dos dados, pronta para relatórios ou dashboards.

3. Preparação de dados para machine learning

Antes de treinar um modelo preditivo, os dados precisam estar no formato certo. Nesse processo, o Pandas organiza as colunas e cria novas variáveis, enquanto o NumPy converte o DataFrame em arrays para alimentar bibliotecas de machine learning.

import pandas as pd
import numpy as np

# 1) Criar DataFrame com dados de exemplo (poderia vir de um CSV)
df = pd.DataFrame({
    "itens": [2, 3, 1, 4, 5],
    "preco": [50, 40, 80, 35, 60],
    "desconto": [0.1, 0.0, 0.05, 0.2, 0.15]
})

# 2) Engenharia de atributos (Pandas)
df["receita_bruta"] = df["itens"] * df["preco"]
df["receita_liquida"] = df["receita_bruta"] * (1 - df["desconto"])

# 3) Separar features (X) e target (y)
X = df[["itens", "preco", "desconto"]].to_numpy(dtype=float)   # entrada do modelo
y = df["receita_liquida"].to_numpy(dtype=float)                # saída (valor a prever)

# 4) Exibir resultado
print("=== DataFrame original (Pandas) ===")
print(df)

print("\n=== Features (X) como array NumPy ===")
print(X)

print("\n=== Target (y) como array NumPy ===")
print(y)

import pandas as pd
import numpy as np

# 1) Criar DataFrame com dados de exemplo (poderia vir de um CSV)
df = pd.DataFrame({
    "itens": [2, 3, 1, 4, 5],
    "preco": [50, 40, 80, 35, 60],
    "desconto": [0.1, 0.0, 0.05, 0.2, 0.15]
})

# 2) Engenharia de atributos (Pandas)
df["receita_bruta"] = df["itens"] * df["preco"]
df["receita_liquida"] = df["receita_bruta"] * (1 - df["desconto"])

# 3) Separar features (X) e target (y)
X = df[["itens", "preco", "desconto"]].to_numpy(dtype=float)   # entrada do modelo
y = df["receita_liquida"].to_numpy(dtype=float)                # saída (valor a prever)

# 4) Exibir resultado
print("=== DataFrame original (Pandas) ===")
print(df)

print("\n=== Features (X) como array NumPy ===")
print(X)

print("\n=== Target (y) como array NumPy ===")
print(y)

O que esse código mostra?

• Pandas cria e organiza a tabela de dados;
• Novas colunas são geradas: receita_bruta e receita_liquida;
• As colunas de entrada (itens, preco, desconto) são convertidas em array NumPy (X);
• A coluna alvo (receita_liquida) também é convertida em array (y).

Assim, os dados ficam no formato que qualquer biblioteca de machine learning, como Scikit-Learn, TensorFlow ou PyTorch, espera:

• X: matriz (amostras x variáveis);
• Y: vetor (valores a prever).

Acelere seu aprendizado sobre análise de dados

Pandas e NumPy são bibliotecas fundamentais para quem deseja trabalhar com análise e manipulação de dados em Python. Mas, para realmente dominar essas ferramentas e usá-las de forma estratégica em projetos reais, você precisa ir além da teoria.

Na Trilha Análise e Visualização de Dados, da Asimov Academy, você aprende na prática:

• A usar Python do zero para analisar dados com profundidade;
• A manipular planilhas, bancos de dados e arquivos complexos;
• A criar gráficos interativos com Pandas, Matplotlib, Seaborn e Plotly.

Tudo isso em projetos aplicados, para que você desenvolva habilidades que realmente fazem diferença no mercado.

Inscreva-se agora e acelere seu aprendizado!

Trilha Análise e Visualização de Dados

Manipule dados e construa visualizações interativas com as ferramentas mais utilizadas por analistas de dados do mundo.

Comece agora