Pandas em Python: O Guia Completo para Análise de Dados
Se você trabalha com análise de dados em Python, certamente já ouviu falar do Pandas. Esta poderosa biblioteca open-source se tornou indispensável para cientistas de dados, analistas e engenheiros que manipulam e analisam conjuntos de dados. Neste guia completo, vamos explorar o que é o Pandas, suas principais funcionalidades e como utilizá-lo para transformar, limpar e analisar seus dados de forma eficiente.
O que é o Pandas?
Pandas é uma biblioteca de Python criada para manipulação e análise de dados estruturados. O nome é derivado de "panel data" (dados em painel), um termo econométrico para conjuntos de dados que incluem observações ao longo do tempo para os mesmos indivíduos. Desenvolvida por Wes McKinney em 2008, a biblioteca foi originalmente criada para facilitar a análise quantitativa de dados financeiros.
Hoje, o Pandas é utilizado em praticamente todas as áreas que envolvem análise de dados, desde ciência de dados e machine learning até análise financeira e pesquisa acadêmica. Sua popularidade se deve à eficiência, flexibilidade e facilidade de uso.
Estruturas de Dados Fundamentais
O Pandas possui duas estruturas de dados principais que formam a base de toda a biblioteca:
1. Series
Uma Series é um array unidimensional rotulado capaz de armazenar qualquer tipo de dado (inteiros, strings, floats, objetos Python, etc.). É essencialmente uma coluna única de dados com um índice associado.
# Criando uma Series
import pandas as pd
s = pd.Series([1, 3, 5, 7, 9], index=['a', 'b', 'c', 'd', 'e'])
print(s)
# Saída:
# a 1
# b 3
# c 5
# d 7
# e 9
# dtype: int642. DataFrame
Um DataFrame é uma estrutura de dados bidimensional, semelhante a uma tabela em um banco de dados relacional ou uma planilha do Excel. Cada coluna de um DataFrame é uma Series, e o DataFrame possui índices tanto para linhas quanto para colunas.
# Criando um DataFrame
import pandas as pd
data = {
'País': ['Brasil', 'EUA', 'Japão', 'Alemanha', 'França'],
'PIB (trilhões)': [1.8, 23.0, 5.0, 4.2, 2.9],
'População (milhões)': [213, 331, 126, 83, 67],
'Continente': ['América do Sul', 'América do Norte', 'Ásia', 'Europa', 'Europa']
}
df = pd.DataFrame(data)
print(df)Importando e Exportando Dados
Uma das maiores vantagens do Pandas é a facilidade com que ele permite importar e exportar dados em diversos formatos. Vejamos os métodos mais comuns:
Importação
Pandas suporta a leitura de vários formatos, incluindo:
# CSV
df = pd.read_csv('arquivo.csv')
# Excel
df = pd.read_excel('arquivo.xlsx', sheet_name='Sheet1')
# JSON
df = pd.read_json('arquivo.json')
# SQL Query (usando SQLAlchemy)
from sqlalchemy import create_engine
engine = create_engine('sqlite:///banco_de_dados.db')
df = pd.read_sql_query("SELECT * FROM tabela", engine)
# HTML (tabelas de uma página web)
df_list = pd.read_html('https://site.com/tabela.html')Exportação
Da mesma forma, você pode exportar seus DataFrames em diversos formatos:
# CSV
df.to_csv('arquivo_exportado.csv', index=False)
# Excel
df.to_excel('arquivo_exportado.xlsx', sheet_name='Resultados')
# JSON
df.to_json('arquivo_exportado.json')
# SQL
df.to_sql('nome_da_tabela', engine, if_exists='replace')Explorando os Dados
Após importar seus dados, é essencial explorá-los para entender sua estrutura e conteúdo. O Pandas oferece vários métodos para isso:
# Visualizando as primeiras linhas
df.head()
# Visualizando as últimas linhas
df.tail()
# Informações sobre o DataFrame
df.info()
# Estatísticas descritivas
df.describe()
# Dimensões do DataFrame (linhas, colunas)
df.shape
# Nomes das colunas
df.columns
# Tipos de dados de cada coluna
df.dtypesSeleção e Filtragem de Dados
O Pandas oferece várias formas de selecionar e filtrar dados:
Seleção de Colunas
# Selecionando uma coluna (retorna uma Series)
populacao = df['População (milhões)']
# Selecionando múltiplas colunas (retorna um DataFrame)
subset = df[['País', 'PIB (trilhões)']]Seleção de Linhas
# Usando loc (seleção baseada em rótulos)
primeira_linha = df.loc[0]
paises_europeus = df.loc[df['Continente'] == 'Europa']
# Usando iloc (seleção baseada em posição)
segunda_linha = df.iloc[1]
duas_primeiras_linhas = df.iloc[0:2]Filtragem Condicional
# Países com PIB maior que 3 trilhões
paises_ricos = df[df['PIB (trilhões)'] > 3]
# Países da Europa com população maior que 70 milhões
df[(df['Continente'] == 'Europa') & (df['População (milhões)'] > 70)]
# Países da América do Sul ou Ásia
df[df['Continente'].isin(['América do Sul', 'Ásia'])]Manipulação de Dados
O Pandas brilha na manipulação e transformação de dados. Aqui estão algumas operações comuns:
Adicionando e Removendo Colunas
# Adicionando uma nova coluna
df['PIB per capita'] = df['PIB (trilhões)'] * 1e12 / (df['População (milhões)'] * 1e6)
# Removendo uma coluna
df = df.drop('PIB per capita', axis=1)Renomeando Colunas
# Renomeando colunas
df = df.rename(columns={
'País': 'Country',
'PIB (trilhões)': 'GDP (trillions)',
'População (milhões)': 'Population (millions)',
'Continente': 'Continent'
})Tratamento de Valores Ausentes
# Verificando valores ausentes
df.isna().sum()
# Preenchendo valores ausentes
df['Coluna'].fillna(valor, inplace=True) # Com um valor específico
df['Coluna'].fillna(df['Coluna'].mean(), inplace=True) # Com a média
df['Coluna'].fillna(method='ffill', inplace=True) # Preenchimento para frente
# Removendo linhas com valores ausentes
df = df.dropna()Agrupamento e Agregação
Uma das funcionalidades mais poderosas do Pandas é a capacidade de agrupar dados e aplicar funções de agregação:
# Agrupando por continente e calculando a média do PIB e população
continent_stats = df.groupby('Continente').agg({
'PIB (trilhões)': 'mean',
'População (milhões)': ['mean', 'sum']
})
# Agrupamento com múltiplas funções de agregação
resultado = df.groupby('Continente').agg({
'PIB (trilhões)': ['min', 'max', 'mean', 'sum'],
'População (milhões)': ['min', 'max', 'mean', 'sum']
})Pivotando Dados
Para reorganizar os dados em formato tabular:
# Criando uma tabela pivot
tabela_pivot = pd.pivot_table(
df,
values='PIB (trilhões)',
index=['Continente'],
columns=['Outra_Coluna'],
aggfunc='mean'
)Junção de Dados
Assim como em SQL, o Pandas permite juntar diferentes DataFrames:
# Exemplo de dois DataFrames
df1 = pd.DataFrame({
'ID': [1, 2, 3, 4],
'Nome': ['Ana', 'Bruno', 'Carlos', 'Diana']
})
df2 = pd.DataFrame({
'ID': [1, 2, 3, 5],
'Salário': [5000, 6000, 4500, 7000]
})
# Inner join (apenas IDs presentes em ambos)
inner_join = pd.merge(df1, df2, on='ID', how='inner')
# Left join (todos os IDs de df1)
left_join = pd.merge(df1, df2, on='ID', how='left')
# Right join (todos os IDs de df2)
right_join = pd.merge(df1, df2, on='ID', how='right')
# Outer join (todos os IDs de ambos)
outer_join = pd.merge(df1, df2, on='ID', how='outer')Manipulação de Datas e Horas
O Pandas possui excelente suporte para dados temporais:
# Criando uma sequência de datas
datas = pd.date_range(start='2023-01-01', end='2023-01-10')
# Convertendo strings para datetime
df['Data'] = pd.to_datetime(df['Data_String'])
# Extraindo componentes da data
df['Ano'] = df['Data'].dt.year
df['Mês'] = df['Data'].dt.month
df['Dia_da_Semana'] = df['Data'].dt.day_name()
# Filtrando por data
df[(df['Data'] >= '2023-01-01') & (df['Data'] <= '2023-01-31')]Visualização com Pandas
O Pandas possui funcionalidades básicas de visualização que utilizam Matplotlib por trás dos panos:
# Gráfico de linhas
df.plot(kind='line', x='Coluna_X', y='Coluna_Y')
# Gráfico de barras
df.plot(kind='bar', x='Coluna_X', y='Coluna_Y')
# Histograma
df['Coluna_Numérica'].plot(kind='hist', bins=20)
# Boxplot
df.boxplot(column=['Coluna1', 'Coluna2'])
# Heatmap de correlação
import seaborn as sns
sns.heatmap(df.corr(), annot=True)Aplicação de Funções
O Pandas permite aplicar funções personalizadas aos seus dados:
# Aplicando função em uma coluna
def celsius_para_fahrenheit(temp):
return temp * 9/5 + 32
df['Temp_F'] = df['Temp_C'].apply(celsius_para_fahrenheit)
# Usando lambda
df['Desconto'] = df['Preço'].apply(lambda x: x * 0.1 if x > 100 else 0)
# Aplicando função em linhas (axis=1)
def calcular_imc(row):
return row['Peso'] / (row['Altura'] ** 2)
df['IMC'] = df.apply(calcular_imc, axis=1)5 Dicas Avançadas para Produtividade com Pandas
Para finalizar, aqui estão cinco dicas avançadas que podem aumentar significativamente sua produtividade ao trabalhar com Pandas:
1. Método Query para Filtragens Complexas
O método query permite escrever condições de filtragem de forma mais legível:
# Em vez de usar a notação com colchetes e condições
resultado = df[(df['Idade'] > 25) & (df['Salário'] >= 5000) & (df['Departamento'] == 'TI')]
# Use query para maior clareza
resultado = df.query('Idade > 25 and Salário >= 5000 and Departamento == "TI"')2. Método Pipe para Encadeamento de Funções
O método pipe permite encadear operações de forma mais limpa:
# Define funções para manipulação de dados
def remover_duplicatas(df):
return df.drop_duplicates()
def filtrar_por_data(df, data_inicial, data_final):
return df[(df['Data'] >= data_inicial) & (df['Data'] <= data_final)]
def calcular_metricas(df):
df['Nova_Métrica'] = df['Valor'] / df['Quantidade']
return df
# Encadeie as funções usando pipe
resultado = (df
.pipe(remover_duplicatas)
.pipe(filtrar_por_data, '2023-01-01', '2023-12-31')
.pipe(calcular_metricas))3. Otimização de Memória
Para grandes conjuntos de dados, otimizar o uso de memória é crucial:
# Verifique o uso de memória atual
df.info(memory_usage='deep')
# Reduza o uso de memória convertendo tipos de dados
def reduzir_memoria(df):
for col in df.columns:
# Colunas numéricas
if df[col].dtype == 'int64':
if df[col].min() >= 0:
if df[col].max() < 255:
df[col] = df[col].astype('uint8')
elif df[col].max() < 65535:
df[col] = df[col].astype('uint16')
else:
if df[col].min() > -128 and df[col].max() < 127:
df[col] = df[col].astype('int8')
elif df[col].min() > -32768 and df[col].max() < 32767:
df[col] = df[col].astype('int16')
# Para floats, use float32 em vez de float64
elif df[col].dtype == 'float64':
df[col] = df[col].astype('float32')
return df
# Aplique a função
df_otimizado = reduzir_memoria(df)4. Processamento Paralelo com swifter
Para aplicações que exigem processamento intensivo em grandes DataFrames:
# Instale o swifter: pip install swifter
import swifter
# Em vez de
df['Resultado'] = df['Coluna'].apply(funcao_complexa)
# Use swifter para paralelização automática
df['Resultado'] = df['Coluna'].swifter.apply(funcao_complexa)5. Acesso Condicional com .loc e .mask/.where
Para atualizações condicionais mais complexas:
# Atualizando valores condicionalmente usando .loc
df.loc[df['Vendas'] > 1000, 'Classificação'] = 'Alto Volume'
# Usando mask para substituir valores baseados em condição
df['Desconto'] = df['Preço'].mask(df['Preço'] > 100, df['Preço'] * 0.9)
# where mantém o valor original se a condição for verdadeira, caso contrário, substitui
df['Status'] = df['Status'].where(df['Status'].notna(), 'Não informado')Conclusão
O Pandas é uma ferramenta indispensável para quem trabalha com dados em Python. Sua flexibilidade e poder permitem que você realize praticamente qualquer tipo de manipulação e análise de dados de forma eficiente.
Este guia cobriu apenas as funcionalidades mais fundamentais e algumas técnicas avançadas. O Pandas oferece muito mais recursos e possibilidades que você pode explorar à medida que se torna mais familiarizado com a biblioteca.
Se você está começando na área de dados ou quer aprimorar suas habilidades, investir tempo no aprendizado do Pandas certamente trará grandes benefícios para sua carreira e produtividade.
Interessado em aprofundar seus conhecimentos em Python para análise de dados? A Data Driven School oferece cursos completos que abordam o Pandas e muito mais. Confira nossa Manipulação de Dados com Linguagem Python e transforme-se em um especialista em análise de dados.