- Introdução ao Pandas
- Criação de DataFrames
- Visualização e Exploração de Dados
- Seleção e Indexação de Dados
- Filtragem de Dados
- Manipulação de Dados
- Aplicação de Funções
- Trabalhando com Dados Ausentes
- Remoção de Duplicatas
- Agrupamento e Agregação de Dados
- Ordenação de Dados
- Combinação de DataFrames
- Entrada e Saída de Dados
- Operações Avançadas
- Parâmetro
axisem Operações
Pandas é uma biblioteca poderosa para manipulação e análise de dados em Python. Ela fornece estruturas de dados flexíveis e expressivas, tornando o trabalho com dados tabulares e séries temporais mais fácil.
import pandas as pdPandas permite o uso de dois tipos principais de estruturas de dados:
- Series: um array unidimensional.
- DataFrame: uma estrutura bidimensional (tabela).
Existem várias formas de criar um DataFrame no Pandas. Vamos explorar as principais abordagens.
Um dos métodos mais comuns de criar um DataFrame é a partir de dicionários.
Exemplo 1:
data = {
'Nome': ['Ana', 'Bruno', 'Carlos'],
'Idade': [23, 35, 50],
'Salário': [4000, 5000, 6000]
}
df = pd.DataFrame(data)
print(df)Saída:
Nome Idade Salário
0 Ana 23 4000
1 Bruno 35 5000
2 Carlos 50 6000
Exemplo 2:
Incluindo índices personalizados:
data = {
'Produto': ['A', 'B', 'C'],
'Preço': [10.5, 20.3, 15.0]
}
df = pd.DataFrame(data, index=['ID1', 'ID2', 'ID3'])
print(df)Saída:
Produto Preço
ID1 A 10.5
ID2 B 20.3
ID3 C 15.0
DataFrames também podem ser criados a partir de listas.
Exemplo 3:
data = [
['Ana', 23, 4000],
['Bruno', 35, 5000],
['Carlos', 50, 6000]
]
df = pd.DataFrame(data, columns=['Nome', 'Idade', 'Salário'])
print(df)Saída:
Nome Idade Salário
0 Ana 23 4000
1 Bruno 35 5000
2 Carlos 50 6000
Exemplo 4:
Com índices personalizados:
data = [
[10.5, 'Categoria A'],
[20.3, 'Categoria B'],
[15.0, 'Categoria A']
]
df = pd.DataFrame(data, index=['Produto1', 'Produto2', 'Produto3'], columns=['Preço', 'Categoria'])
print(df)Saída:
Preço Categoria
Produto1 10.5 Categoria A
Produto2 20.3 Categoria B
Produto3 15.0 Categoria A
Se você já trabalha com NumPy, pode criar DataFrames diretamente a partir de arrays.
Exemplo 5:
import numpy as np
array = np.array([
['Ana', 23, 4000],
['Bruno', 35, 5000],
['Carlos', 50, 6000]
])
df = pd.DataFrame(array, columns=['Nome', 'Idade', 'Salário'])
print(df)Saída:
Nome Idade Salário
0 Ana 23 4000
1 Bruno 35 5000
2 Carlos 50 6000
Porém, você pode facilmente criar DataFrames lendo dados de arquivos externos.
Exemplo 6: Leitura de CSV
df = pd.read_csv('datasets/sample.csv')
print(df.head())Saída:
nome idade cidade profissao
0 João 34 São Paulo Engenheiro
1 Maria 28 Rio de Janeiro Médica
2 Carlos 45 Belo Horizonte Professor
3 Ana 37 Porto Alegre Advogada
4 Pedro 30 Salvador Arquiteto
Exemplo 7: Leitura de Excel
df = pd.read_excel('datasets/sample.xlsx', sheet_name='SheetLegal')
print(df.head())Saída:
nome idade cidade profissao
0 João 34 São Paulo Engenheiro
1 Maria 28 Rio de Janeiro Médica
2 Carlos 45 Belo Horizonte Professor
3 Ana 37 Porto Alegre Advogada
4 Pedro 30 Salvador Arquiteto
Exemplo 8: Leitura de JSON
df = pd.read_json('datasets/sample.json')
print(df.head())Saída:
nome idade cidade profissao
0 {'primeiro': 'João', 'segundo': 'Paulo'} 34 São Paulo Engenheiro
1 {'primeiro': 'Maria', 'segundo': 'Santos'} 28 Rio de Janeiro Médica
2 {'primeiro': 'Carlos', 'segundo': 'Ferreira'} 45 Belo Horizonte Professor
3 {'primeiro': 'Ana', 'segundo': 'Pereira'} 37 Porto Alegre Advogada
4 {'primeiro': 'Pedro', 'segundo': 'Alves'} 30 Salvador Arquiteto
Uma vez que os dados estejam carregados no DataFrame, a visualização rápida e a exploração são fundamentais para entender a estrutura dos dados.
É possível usar métodos como head() e tail() para visualizar as primeiras ou últimas linhas do DataFrame.
Exemplo 9:
print(df.head()) # Primeiros 5 registros
print(df.tail(3)) # Últimos 3 registrosO método info() fornece um resumo detalhado do DataFrame.
Exemplo 10:
print(df.info()) # Informações geraisSaida com df definido em cima do arquivo sample.json:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8 entries, 0 to 7
Data columns (total 4 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 nome 8 non-null object
1 idade 8 non-null int64
2 cidade 8 non-null object
3 profissao 8 non-null object
dtypes: int64(1), object(3)
memory usage: 388.0+ bytes
O método describe() gera estatísticas descritivas para cada coluna numérica.
Exemplo 11:
print(df.describe()) # Estatísticas básicasSaída com df definido em cima do arquivo sample.json:
idade
count 8.000000
mean 33.750000
std 6.453128
min 25.000000
25% 29.500000
50% 33.000000
75% 37.500000
max 45.000000
Outras operações úteis:
# Média
print(df['idade'].mean())
# Mediana
print(df['idade'].median())
# Desvio Padrão
print(df['idade'].std())Saída:
33.75
33.0
6.453127702351562
Existem várias maneiras de selecionar dados em um DataFrame. Vamos explorar as principais.
A seleção com colchetes é o método mais simples.
Exemplo 12: Selecionar coluna única
nomes = df['nome']
print(nomes)Saída com df definido em cima do arquivo sample.csv:
0 João
1 Maria
2 Carlos
3 Ana
4 Pedro
5 Lucas
6 Lia
7 Tânia
Name: nome, dtype: object
Exemplo 13: Selecionar múltiplas colunas
dados = df[['nome', 'idade']]
print(dados)Saída com df definido em cima do arquivo sample.csv:
nome idade
0 João 34
1 Maria 28
2 Carlos 45
3 Ana 37
4 Pedro 30
5 Lucas 25
6 Lia 32
7 Tânia 39
O Pandas oferece dois métodos para selecionar dados: loc e iloc.
-
loc: seleção baseada em rótulos (nomes). -
iloc: seleção baseada em posição numérica (índices).
Considere df como definido a seguir:
data = {
'Nome': ['Felipe', 'Arthur', 'Luiz', 'Edeilson'],
'Salário': [1_999_999, 16_000, 13_000, 87_321]
}
df = pd.DataFrame(data, index=['ID1', 'ID2', 'ID3', p])
print(df)Saída:
Nome Salário
ID1 Felipe 1999999
ID2 Arthur 16000
ID3 Luiz 13000
ID4 Edeilson 87321
Exemplo 14: loc para seleção baseada em rótulos
# Selecionar linhas de 'ID1' a 'ID2' e colunas 'Nome' e 'Salário'
df_loc = df.loc['ID1':'ID2', ['Nome', 'Salário']]
print(df_loc)Saída:
Nome Salário
ID1 Felipe 1999999
ID2 Arthur 16000
Exemplo 15: iloc para seleção baseada em posição
# Selecionar as linhas de 1 a 3 e primeiras 2 colunas
df_iloc = df.iloc[1:3, 0:2]
print(df_iloc)Saída:
Nome Salário
ID2 Arthur 16000
ID3 Luiz 13000
Esses métodos são mais eficientes para acessar um único elemento, seja por rótulo (at) ou por posição (iat).
Exemplo 16:
# Obter valor específico
valor = df.at[0, 'Nome'] # Equivalente a df.loc[0, 'Nome']
print(valor)Exemplo 17:
# Obter valor específico usando posições inteiras
valor = df.iat[0, 1] # Equivalente a df.iloc[0, 1]
print(valor)A filtragem de dados é uma operação muito comum e útil para análise.
Filtrar linhas com base em condições simples.
Exemplo 18:
# Filtrar linhas onde 'Idade' > 30
df_filtrado = df[df['Idade'] > 30]
print(df_filtrado)Exemplo 19:
# Filtrar linhas onde 'Categoria' é 'Categoria A'
df_filtrado = df[df['Categoria'] == 'Categoria A']
print(df_filtrado)A filtragem com múltiplas condições em Pandas é feita combinando expressões lógicas. Você pode usar operadores como & (E lógico), | (OU lógico) e ~ (NÃO lógico) para filtrar os dados de forma mais específica. Esses operadores funcionam em nível elementar, o que significa que eles avaliam as condições para cada linha do DataFrame.
&(E lógico): Retorna verdadeiro se ambas as condições forem verdadeiras.|(OU lógico): Retorna verdadeiro se uma ou ambas as condições forem verdadeiras.~(NÃO lógico): Inverte o valor lógico (True para False, e vice-versa).
- Quando você utiliza múltiplas condições, cada uma delas deve estar entre parênteses
()para evitar problemas de precedência. - Estes operadores não são os mesmos que os operadores lógicos do Python (
and,or,not). O Pandas requer esses operadores elementares para vetores de dados.
# Filtrar onde 'Idade' > 30 e 'Salário' > 5000
df_filtrado = df[(df['Idade'] > 30) & (df['Salário'] > 5000)]
print(df_filtrado)Explicação: Aqui estamos selecionando as linhas onde a idade é maior que 30 e o salário é maior que 5000. Ambas as condições precisam ser verdadeiras para que a linha seja incluída no DataFrame filtrado.
Exemplo 1: Filtrando com | (OU lógico)
# Filtrar onde 'Categoria' é 'Categoria A' ou 'Preço' > 15
df_filtrado = df[(df['Categoria'] == 'Categoria A') | (df['Preço'] > 15)]
print(df_filtrado)Explicação: Neste caso, estamos selecionando as linhas onde uma ou ambas as condições são verdadeiras: a categoria é 'Categoria A' ou o preço é maior que 15.
Exemplo 2: Filtrando com ~ (NÃO lógico)
# Filtrar todas as linhas onde a categoria NÃO é 'Categoria B'
df_filtrado = df[~(df['Categoria'] == 'Categoria B')]
print(df_filtrado)Explicação:
Aqui estamos usando o operador ~ para inverter a condição. Ou seja, todas as linhas onde a categoria não é 'Categoria B' serão incluídas.
Exemplo 3: Múltiplas condições com três critérios
# Filtrar onde 'Idade' > 25, 'Salário' > 4000 e 'Categoria' é 'Categoria A'
df_filtrado = df[(df['Idade'] > 25) & (df['Salário'] > 4000) & (df['Categoria'] == 'Categoria A')]
print(df_filtrado)Explicação: Aqui estamos combinando três condições: a idade deve ser maior que 25, o salário maior que 4000 e a categoria deve ser 'Categoria A'. Todas as três condições devem ser verdadeiras para que a linha seja incluída.
Exemplo 4: Condições complexas com &, |, e ~
# Filtrar onde 'Idade' > 30 e ('Salário' > 5000 ou 'Categoria' é 'Categoria A'), exceto 'Nome' não ser 'Ana'
df_filtrado = df[(df['Idade'] > 30) & ((df['Salário'] > 5000) | (df['Categoria'] == 'Categoria A')) & ~(df['Nome'] == 'Ana')]
print(df_filtrado)Explicação: Neste exemplo mais complexo, filtramos as linhas onde a idade é maior que 30 e ou o salário é maior que 5000 ou a categoria é 'Categoria A'. Além disso, também estamos excluindo as linhas onde o nome é 'Ana'.
- Uso de parênteses: Sempre use parênteses em torno de cada condição, pois a ausência deles pode resultar em erros de precedência.
- Clareza no código: Em operações complexas, é útil dividir suas condições em variáveis nomeadas para tornar o código mais legível.
Exemplo 5: Usando variáveis para tornar o código mais legível
condicao_idade = df['Idade'] > 30
condicao_salario = df['Salário'] > 5000
condicao_categoria = df['Categoria'] == 'Categoria A'
# Combinação das condições
df_filtrado = df[condicao_idade & (condicao_salario | condicao_categoria)]
print(df_filtrado)Explicação: Aqui, dividimos as condições em variáveis para facilitar a compreensão do filtro complexo. A vantagem de fazer isso é que o código se torna mais fácil de manter e ajustar se necessário.
Você também pode utilizar o método query() para expressar as mesmas condições de forma ainda mais legível, especialmente quando está trabalhando com condições complexas.
# Usando query para fazer a mesma filtragem do Exemplo 5
df_filtrado = df.query('Idade > 30 and (Salário > 5000 or Categoria == "Categoria A")')
print(df_filtrado)Explicação:
Usar query() é útil para manter seu código mais limpo e intuitivo, especialmente para quem está acostumado com SQL ou linguagens similares.
query() é uma forma mais legível de aplicar condições de filtragem complexas.
Exemplo 22:
# Usando query para filtrar dados
df_filtrado = df.query('Idade > 30 and Salário > 5000')
print(df_filtrado)Exemplo 23:
# Usando query com variável
categoria = 'Categoria A'
df_filtrado = df.query('Categoria == @categoria')
print(df_filtrado)Manipular dados é essencial para pré-processamento e limpeza.
Exemplo 24: Adicionar coluna
# Adicionar coluna 'Bonus' com 10% do salário
df['Bonus'] = df['Salário'] * 0.10
print(df)Exemplo 25: Remover coluna
# Remover coluna 'Bonus'
df_sem_bonus = df.drop('Bonus', axis=1)
print(df_sem_bonus)Exemplo 27:
# Renomear coluna 'Nome' para 'Funcionário'
df_renomeado = df.rename(columns={'Nome': 'Funcionário'})
print(df_renomeado)Exemplo 29:
# Converter 'Idade' para float
df['Idade'] = df['Idade'].astype(float)
print(df.dtypes)O método apply() no Pandas permite aplicar funções personalizadas em colunas ou linhas de um DataFrame ou Series. Ele é extremamente flexível e pode ser utilizado para aplicar uma função em uma única coluna (ou linha), ou mesmo em múltiplas colunas se for usado com funções mais complexas.
- Quando você precisa de uma transformação mais complexa do que as funções embutidas do Pandas podem oferecer.
- Para aplicar funções em colunas ou linhas individualmente.
- Para usar funções definidas pelo usuário (UDFs) para transformar dados.
apply()é mais versátil. Ele pode trabalhar tanto em colunas quanto em linhas inteiras e pode aplicar funções que retornam valores escalares ou novos DataFrames/Series.- Pode ser usado com funções definidas pelo usuário ou lambdas.
# Função para classificar idades em grupos
def classificar_idade(idade):
if idade < 30:
return 'Jovem'
elif idade < 50:
return 'Adulto'
else:
return 'Sênior'
df['Faixa Etária'] = df['Idade'].apply(classificar_idade)
print(df)Explicação:
Neste exemplo, a função classificar_idade() é aplicada a cada valor da coluna Idade. Dependendo da idade, ela retorna uma categoria (Jovem, Adulto, Sênior), e essa categoria é inserida em uma nova coluna chamada Faixa Etária.
# Aplicar uma função para somar 'Idade' e 'Salário'
df['Total'] = df.apply(lambda row: row['Idade'] + row['Salário'], axis=1)
print(df)Explicação:
Aqui, a função lambda soma os valores das colunas Idade e Salário para cada linha do DataFrame. O parâmetro axis=1 indica que estamos aplicando a função ao longo das linhas (e não das colunas).
O método map() é usado principalmente para substituir ou mapear valores em uma Series com base em um dicionário ou função. Ele é mais limitado que o apply() porque só funciona com Series e não pode ser aplicado em múltiplas colunas ou linhas. No entanto, ele é muito útil quando você deseja fazer substituições diretas de valores.
- Quando você quer substituir valores em uma única coluna com base em um dicionário ou uma função.
- Para mapear valores de uma Series para outros valores.
map()só funciona em Series, enquantoapply()pode ser usado em DataFrames ou Series.map()é mais eficiente para substituições simples, como mapear valores de uma Series para outros.
# Dicionário de mapeamento
mapeamento = {'Ana': 'A', 'Bruno': 'B', 'Carlos': 'C'}
# Aplicar o mapeamento
df['Iniciais'] = df['Nome'].map(mapeamento)
print(df)Explicação:
Aqui, o método map() substitui os valores da coluna Nome com base no dicionário mapeamento. O nome "Ana" se torna "A", "Bruno" se torna "B", e assim por diante. Esse tipo de operação é extremamente eficiente para substituições diretas.
# Mapear com uma função lambda para deixar os nomes em maiúsculas
df['Nome Maiúsculo'] = df['Nome'].map(lambda x: x.upper())
print(df)Explicação:
Neste exemplo, usamos map() com uma função lambda para converter os nomes da coluna Nome para letras maiúsculas. O map() percorre cada elemento da Series e aplica a função.
O applymap() é um método que funciona em todo o DataFrame, aplicando uma função a cada elemento individual. Ele é útil quando você deseja aplicar a mesma função em todos os valores de um DataFrame, coluna por coluna e linha por linha.
- Quando você quer aplicar uma função em cada valor individual de um DataFrame.
- Quando você precisa transformar ou manipular todos os elementos de um DataFrame ao mesmo tempo.
applymap()é específico para DataFrames, e trabalha elemento por elemento.apply()pode ser usado tanto em DataFrames quanto em Series, mas trabalha por linha ou coluna, não em elementos individuais.
# Aplicar função lambda para dobrar todos os valores no DataFrame numérico
df_numerico = df[['Idade', 'Salário']]
df_dobro = df_numerico.applymap(lambda x: x * 2)
print(df_dobro)Explicação:
Aqui usamos applymap() para aplicar uma função lambda que multiplica por 2 cada valor do DataFrame df_numerico. Cada valor da coluna Idade e Salário é processado individualmente e multiplicado por 2.
# Converter todos os valores do DataFrame para string
df_str = df.applymap(str)
print(df_str)Explicação:
Neste exemplo, usamos applymap() para converter cada valor do DataFrame em uma string. Cada elemento, independentemente de seu tipo original, será transformado em uma string.
| Método | Escopo | Uso Comum | Funcionamento |
|---|---|---|---|
apply() |
DataFrame ou Series | Aplicar funções em colunas ou linhas inteiras | Pode trabalhar em colunas ou linhas inteiras, ideal para operações complexas. |
map() |
Series | Substituir ou mapear valores individuais | Trabalha apenas com Series e é ideal para substituições diretas. |
applymap() |
DataFrame | Aplicar uma função em todos os elementos | Aplica uma função em cada elemento de um DataFrame, ideal para manipulações elementares. |
- Use
apply()quando precisar aplicar uma função em uma coluna ou linha inteira. - Use
map()quando quiser substituir valores em uma Series com base em um dicionário ou função. - Use
applymap()quando precisar aplicar a mesma função em cada elemento de um DataFrame.
Esses métodos são poderosos para manipular e transformar dados no Pandas e, dependendo da tarefa, um deles será mais eficiente e apropriado que os outros.
Trabalhar com dados ausentes é uma parte fundamental do pré-processamento de dados. Valores nulos ou ausentes podem ocorrer por diversos motivos, como falhas na coleta de dados ou erros de processamento. Pandas oferece uma ampla gama de métodos para identificar, remover e substituir esses valores, garantindo que sua análise seja confiável.
Pandas fornece funções como isnull() e notnull() para identificar valores nulos. Elas retornam um DataFrame ou Series de valores booleanos, onde True indica que o valor é nulo (NaN), e False indica que o valor não é nulo.
Exemplo 1: Verificar se existem valores nulos no DataFrame
# Verificar se há valores nulos no DataFrame
print(df.isnull())Exemplo 2: Contar o número de valores nulos por coluna
# Contar o número de valores nulos em cada coluna
print(df.isnull().sum())Exemplo 3: Verificar colunas específicas quanto a valores nulos
# Verificar valores nulos em uma coluna específica
print(df['Salário'].isnull())
# Verificar valores nulos em múltiplas colunas
print(df[['Nome', 'Idade']].isnull())Exemplo 4: Verificar valores não nulos
# Verificar onde os valores NÃO são nulos
print(df.notnull())Exemplo 5: Filtrar linhas que têm valores nulos em uma coluna específica
# Selecionar linhas onde 'Salário' está ausente (nulo)
df_nulos = df[df['Salário'].isnull()]
print(df_nulos)Pandas permite remover valores nulos de várias formas. O método mais comum é o dropna(), que remove linhas ou colunas onde os valores são nulos.
Exemplo 1: Remover todas as linhas que contenham valores nulos
# Remover todas as linhas que contenham algum valor nulo
df_sem_nulos = df.dropna()
print(df_sem_nulos)Exemplo 2: Remover colunas que contenham valores nulos
# Remover todas as colunas que contenham algum valor nulo
df_sem_nulos_colunas = df.dropna(axis=1)
print(df_sem_nulos_colunas)Exemplo 3: Remover linhas apenas se todas as colunas tiverem valores nulos
# Remover linhas onde TODAS as colunas são nulas
df_sem_nulos_total = df.dropna(how='all')
print(df_sem_nulos_total)Exemplo 4: Remover linhas apenas se uma quantidade mínima de valores não nulos estiver presente
# Manter linhas que tenham pelo menos 2 valores não nulos
df_minimos_valores = df.dropna(thresh=2)
print(df_minimos_valores)Exemplo 5: Remover valores nulos apenas em colunas específicas
# Remover linhas onde há valores nulos apenas na coluna 'Salário'
df_sem_nulos_salario = df.dropna(subset=['Salário'])
print(df_sem_nulos_salario)axis=0(padrão): Remove valores nulos em linhas.axis=1: Remove valores nulos em colunas.how='any'(padrão): Remove a linha/coluna se qualquer valor for nulo.how='all': Remove a linha/coluna apenas se todos os valores forem nulos.thresh: Mantém a linha/coluna se contiver ao menos um número mínimo de valores não nulos.
Em vez de remover dados, muitas vezes é útil preencher (ou imputar) valores nulos com algum valor de substituição. Pandas permite fazer isso com o método fillna().
Exemplo 1: Substituir valores nulos por zero
# Substituir todos os valores nulos por 0
df_preenchido = df.fillna(0)
print(df_preenchido)Exemplo 2: Substituir valores nulos com a média de uma coluna
# Preencher os valores nulos na coluna 'Salário' com a média dos salários
df['Salário'] = df['Salário'].fillna(df['Salário'].mean())
print(df)Exemplo 3: Substituir valores nulos com o valor anterior (preenchimento forward)
# Preencher valores nulos com o valor da linha anterior
df_preenchido = df.fillna(method='ffill')
print(df_preenchido)Exemplo 4: Substituir valores nulos com o próximo valor válido (preenchimento backward)
# Preencher valores nulos com o próximo valor válido
df_preenchido = df.fillna(method='bfill')
print(df_preenchido)Exemplo 5: Substituir valores nulos em colunas específicas
# Preencher valores nulos na coluna 'Salário' com 5000 e na coluna 'Idade' com a média da coluna
df_preenchido = df.fillna({'Salário': 5000, 'Idade': df['Idade'].mean()})
print(df_preenchido)value: Define o valor para preencher os valores nulos.method: Permite preenchimento com o valor anterior (ffill) ou próximo valor (bfill).inplace=False: SeTrue, modifica o DataFrame original em vez de retornar uma nova cópia.limit: Limita o número de valores nulos a preencher.
Pandas oferece formas eficientes de contar valores nulos em todo o DataFrame ou em colunas específicas.
Exemplo 1: Contar o número total de valores nulos no DataFrame
# Contar o número total de valores nulos no DataFrame
total_nulos = df.isnull().sum().sum()
print(f'Total de valores nulos: {total_nulos}')Exemplo 2: Contar valores nulos por coluna
# Contar valores nulos em cada coluna
nulos_por_coluna = df.isnull().sum()
print(nulos_por_coluna)Exemplo 3: Contar valores nulos em colunas específicas
# Contar valores nulos apenas nas colunas 'Salário' e 'Idade'
nulos_selecionados = df[['Salário', 'Idade']].isnull().sum()
print(nulos_selecionados)Remover duplicatas é uma etapa importante na limpeza de dados para evitar ruído ou distorções na análise. Linhas duplicadas podem ocorrer devido a falhas no processo de entrada de dados ou durante a combinação de diferentes conjuntos de dados. O Pandas oferece métodos fáceis e eficientes para identificar e remover essas duplicatas.
O método duplicated() é utilizado para identificar duplicatas em um DataFrame. Ele retorna uma Series booleana indicando True para as linhas duplicadas e False para as linhas únicas. Por padrão, ele considera todas as colunas ao verificar duplicatas, mas é possível ajustar o comportamento com diferentes parâmetros.
Exemplo 1: Verificar todas as duplicatas no DataFrame
# Verificar linhas duplicadas no DataFrame inteiro
duplicatas = df.duplicated()
print(duplicatas)Exemplo 2: Verificar duplicatas com base em colunas específicas
# Verificar duplicatas apenas com base na coluna 'Nome'
duplicatas = df.duplicated(subset=['Nome'])
print(duplicatas)Exemplo 3: Considerar apenas a primeira ocorrência como única
# Verificar duplicatas, mantendo a primeira ocorrência
duplicatas = df.duplicated(keep='first')
print(duplicatas)Exemplo 4: Considerar apenas a última ocorrência como única
# Verificar duplicatas, mantendo a última ocorrência
duplicatas = df.duplicated(keep='last')
print(duplicatas)Exemplo 5: Marcar todas as ocorrências duplicadas como True
# Verificar duplicatas, marcando todas as ocorrências duplicadas como True
duplicatas = df.duplicated(keep=False)
print(duplicatas)subset: Define as colunas a serem consideradas na verificação de duplicatas.keep='first'(padrão): Marca todas as duplicatas comoTrue, exceto a primeira ocorrência.keep='last': Marca todas as duplicatas comoTrue, exceto a última ocorrência.keep=False: Marca todas as ocorrências duplicadas comoTrue.
O método drop_duplicates() remove as linhas duplicadas de um DataFrame. Assim como no duplicated(), você pode especificar se deseja manter a primeira ou última ocorrência de cada valor duplicado.
Exemplo 1: Remover todas as duplicatas, mantendo a primeira ocorrência
# Remover linhas duplicadas, mantendo a primeira ocorrência
df_unico = df.drop_duplicates()
print(df_unico)Exemplo 2: Remover duplicatas, mantendo apenas a última ocorrência
# Remover duplicatas, mantendo a última ocorrência
df_unico = df.drop_duplicates(keep='last')
print(df_unico)Exemplo 3: Remover todas as duplicatas sem manter nenhuma ocorrência
# Remover todas as duplicatas, mantendo apenas linhas 100% únicas
df_unico = df.drop_duplicates(keep=False)
print(df_unico)Exemplo 4: Remover duplicatas com base em colunas específicas
# Remover duplicatas com base apenas na coluna 'Nome'
df_unico_nome = df.drop_duplicates(subset=['Nome'])
print(df_unico_nome)subset: Especifica as colunas nas quais verificar duplicatas.keep='first'(padrão): Mantém a primeira ocorrência e remove as duplicatas subsequentes.keep='last': Mantém a última ocorrência e remove as anteriores.keep=False: Remove todas as duplicatas, sem manter nenhuma ocorrência.inplace=False: SeTrue, modifica o DataFrame original, sem retornar uma nova cópia.
Antes de remover duplicatas, pode ser útil contar quantas linhas duplicadas existem no DataFrame. Isso pode ser feito utilizando o método duplicated() em combinação com sum().
Exemplo 5: Contar o número de linhas duplicadas
# Contar o número de linhas duplicadas no DataFrame
num_duplicatas = df.duplicated().sum()
print(f'Número de duplicatas: {num_duplicatas}')Exemplo 6: Contar duplicatas com base em colunas específicas
# Contar duplicatas com base na coluna 'Nome'
num_duplicatas_nome = df.duplicated(subset=['Nome']).sum()
print(f'Número de duplicatas na coluna "Nome": {num_duplicatas_nome}')Agrupamento e agregação são técnicas poderosas e fundamentais para análise de grandes conjuntos de dados. O Pandas facilita essas operações através de métodos como groupby() e agg(), que permitem resumir, contar e transformar dados com base em critérios específicos. Essas operações são essenciais para entender padrões, tendências e insights em seus dados.
O método groupby() permite agrupar dados com base em uma ou mais colunas. Depois de agrupar, você pode aplicar várias funções de agregação, como contagem, soma, média, entre outras, para resumir os dados em cada grupo.
df.groupby('coluna_de_agrupamento').agg(função_de_agregação)Exemplo 1: Contar registros por grupo
# Agrupar por 'Faixa Etária' e contar quantos registros existem em cada grupo
grupo = df.groupby('Faixa Etária').size()
print(grupo)Explicação: Neste exemplo, os dados são agrupados pela coluna Faixa Etária, e o método size() conta quantas linhas pertencem a cada grupo.
Exemplo 2: Agrupar por múltiplas colunas e contar
# Agrupar por 'Faixa Etária' e 'Categoria', contando quantos registros existem em cada combinação
grupo = df.groupby(['Faixa Etária', 'Categoria']).size()
print(grupo)Explicação:
Aqui estamos agrupando os dados por mais de uma coluna (Faixa Etária e Categoria). O resultado mostra quantos registros existem para cada combinação de valores dessas colunas.
Exemplo 3: Agrupar e aplicar funções de agregação simples
# Agrupar por 'Categoria' e calcular a média dos preços
grupo = df.groupby('Categoria')['Preço'].mean()
print(grupo)Explicação:
Os dados são agrupados por Categoria, e a função mean() é aplicada à coluna Preço, retornando a média do preço para cada grupo.
Exemplo 4: Agrupar e contar valores não nulos
# Agrupar por 'Categoria' e contar quantos valores não nulos existem em 'Preço'
grupo = df.groupby('Categoria')['Preço'].count()
print(grupo)Explicação:
Neste exemplo, a função count() conta o número de valores não nulos na coluna Preço para cada grupo de Categoria.
Após agrupar os dados com groupby(), você pode aplicar funções de agregação para resumir os dados de várias maneiras. Pandas oferece funções de agregação padrão, como mean(), sum(), count(), além da capacidade de usar funções customizadas ou aplicar várias funções de agregação de uma só vez.
Exemplo 1: Usar uma função de agregação
# Agrupar por 'Categoria' e calcular a soma dos preços
grupo = df.groupby('Categoria')['Preço'].sum()
print(grupo)Explicação:
Aqui, estamos agrupando os dados pela coluna Categoria e somando os valores da coluna Preço para cada grupo.
Exemplo 2: Aplicar múltiplas funções de agregação em uma única coluna
# Agrupar por 'Categoria' e aplicar as funções de média, mínimo e máximo no 'Preço'
grupo = df.groupby('Categoria')['Preço'].agg(['mean', 'min', 'max'])
print(grupo)Explicação:
Neste exemplo, estamos aplicando três funções de agregação (mean, min, max) na coluna Preço para cada grupo de Categoria. Isso retorna um DataFrame com o valor médio, mínimo e máximo dos preços para cada categoria.
Exemplo 3: Usar diferentes funções de agregação em colunas diferentes
# Agrupar por 'Categoria' e aplicar diferentes funções de agregação para 'Preço' e 'Quantidade'
grupo = df.groupby('Categoria').agg({
'Preço': ['mean', 'sum'],
'Quantidade': ['count', 'max']
})
print(grupo)Explicação:
Aqui aplicamos a função mean e sum na coluna Preço e count e max na coluna Quantidade, após agrupar os dados pela coluna Categoria.
# Definir uma função personalizada que calcula a diferença entre o máximo e o mínimo
def faixa_max_min(series):
return series.max() - series.min()
# Agrupar por 'Categoria' e aplicar a função customizada em 'Preço'
grupo = df.groupby('Categoria')['Preço'].agg(faixa_max_min)
print(grupo)Explicação:
Neste exemplo, usamos uma função personalizada faixa_max_min que calcula a diferença entre o valor máximo e o valor mínimo em cada grupo da coluna Preço.
# Aplicar funções e renomeá-las
grupo = df.groupby('Categoria').agg(
média_preço=('Preço', 'mean'),
total_preço=('Preço', 'sum'),
total_produtos=('Quantidade', 'sum')
)
print(grupo)as_index=False: Mantém a coluna de agrupamento como uma coluna normal no resultado, em vez de transformá-la em índice.dropna=True: Remove grupos onde todas as chaves sãoNaN(padrão: True).agg(): Permite aplicar múltiplas funções de agregação simultaneamente, seja com funções embutidas (mean,sum, etc.) ou funções personalizadas.
A ordenação de dados é uma operação comum para organizar os dados em uma sequência lógica, seja por valores de colunas ou pelo índice do DataFrame. O Pandas oferece métodos eficientes como sort_values() e sort_index() para realizar essa tarefa de forma flexível.
O método sort_values() permite ordenar os dados com base em uma ou mais colunas. Você pode especificar se a ordenação deve ser ascendente ou descendente, e também definir como lidar com valores nulos.
Exemplo 1: Ordenar por uma única coluna (ascendente)
# Ordenar por 'Salário' em ordem crescente (padrão)
df_ordenado = df.sort_values(by='Salário')
print(df_ordenado)Exemplo 2: Ordenar por uma única coluna (descendente)
# Ordenar por 'Salário' em ordem decrescente
df_ordenado = df.sort_values(by='Salário', ascending=False)
print(df_ordenado)Exemplo 3: Ordenar por múltiplas colunas
# Ordenar por 'Categoria' e depois por 'Salário'
df_ordenado = df.sort_values(by=['Categoria', 'Salário'])
print(df_ordenado)Exemplo 4: Ordenar por múltiplas colunas com diferentes ordens
# Ordenar por 'Categoria' (ascendente) e 'Salário' (descendente)
df_ordenado = df.sort_values(by=['Categoria', 'Salário'], ascending=[True, False])
print(df_ordenado)Exemplo 5: Ordenar tratando valores nulos (colocando-os no início)
# Ordenar por 'Salário' com valores nulos no início
df_ordenado = df.sort_values(by='Salário', na_position='first')
print(df_ordenado)Exemplo 6: Ordenar por mais de uma coluna, com valores nulos no final
# Ordenar por 'Categoria' e 'Salário', com valores nulos no final
df_ordenado = df.sort_values(by=['Categoria', 'Salário'], na_position='last')
print(df_ordenado)by: Coluna(s) para realizar a ordenação.ascending: Definir se a ordem é ascendente (True) ou descendente (False).na_position: Define se valores nulos serão colocados no início (first) ou no final (last).inplace=False: Modificar o DataFrame original ou retornar uma cópia ordenada.
O método sort_index() é utilizado para ordenar o DataFrame ou Series com base no índice. Ele pode ser útil quando os dados têm um índice significativo, como datas ou rótulos.
Exemplo 1: Ordenar pelo índice em ordem crescente (padrão)
# Ordenar o DataFrame pelo índice em ordem crescente
df_ordenado = df.sort_index()
print(df_ordenado)Exemplo 2: Ordenar pelo índice em ordem decrescente
# Ordenar o DataFrame pelo índice em ordem decrescente
df_ordenado = df.sort_index(ascending=False)
print(df_ordenado)Exemplo 3: Ordenar por índice de colunas (no caso de transpor o DataFrame)
# Ordenar as colunas (índice de colunas) em ordem crescente
df_ordenado_colunas = df.T.sort_index()
print(df_ordenado_colunas)Exemplo 4: Ordenar por MultiIndex
Se o DataFrame possuir um índice hierárquico (MultiIndex), você pode ordenar os níveis de forma específica.
# Ordenar o DataFrame com MultiIndex pelo primeiro nível
df_ordenado = df.sort_index(level=0)
print(df_ordenado)ascending=True: Definir se a ordenação é ascendente (True) ou descendente (False).axis=0: Ordenar o índice das linhas (padrão) ou o índice das colunas (axis=1).level: Especifica o nível para ordenar em um índice hierárquico (MultiIndex).inplace=False: Modificar o DataFrame original ou retornar uma cópia ordenada.
Com esses exemplos, você pode organizar seus dados de maneira eficiente com base em colunas ou índices, utilizando tanto sort_values() quanto sort_index() para diferentes necessidades.
Mesclar e juntar DataFrames são operações fundamentais para combinar informações de diferentes fontes. Pandas oferece várias formas de fazer isso, sendo merge() e join() as mais usadas.
O método merge() permite mesclar dois DataFrames com base em colunas comuns ou índices. Ele funciona de forma semelhante a um "join" em SQL, e você pode especificar o tipo de junção (inner, left, right, outer).
on: Coluna ou lista de colunas em que a mesclagem será baseada.how: Define o tipo de junção. Pode ser'left','right','outer', ou'inner'(padrão:'inner').left_oneright_on: Especifica as colunas a serem usadas para a mesclagem no DataFrame esquerdo e direito, respectivamente.suffixes: Define os sufixos para resolver conflitos de nomes de colunas.
Exemplo 1: Mesclar DataFrames com chave comum (inner join)
df_esquerda = pd.DataFrame({'Chave': ['K0', 'K1', 'K2'], 'A': [1, 2, 3]})
df_direita = pd.DataFrame({'Chave': ['K0', 'K1', 'K3'], 'B': [4, 5, 6]})
# Mesclar com base na coluna 'Chave'
df_merge = pd.merge(df_esquerda, df_direita, on='Chave', how='inner')
print(df_merge)Exemplo 2: Mesclar com left join
# Mesclar com base na coluna 'Chave', mantendo todas as linhas do DataFrame esquerdo
df_merge = pd.merge(df_esquerda, df_direita, on='Chave', how='left')
print(df_merge)Exemplo 3: Mesclar com right join
# Mesclar mantendo todas as linhas do DataFrame direito
df_merge = pd.merge(df_esquerda, df_direita, on='Chave', how='right')
print(df_merge)Exemplo 4: Mesclar com outer join
# Mesclar mantendo todas as linhas de ambos os DataFrames
df_merge = pd.merge(df_esquerda, df_direita, on='Chave', how='outer')
print(df_merge)Exemplo 5: Mesclar com diferentes nomes de colunas (left_on e right_on)
df_esquerda = pd.DataFrame({'ID': ['K0', 'K1', 'K2'], 'A': [1, 2, 3]})
df_direita = pd.DataFrame({'Chave': ['K0', 'K1', 'K3'], 'B': [4, 5, 6]})
# Mesclar usando colunas diferentes
df_merge = pd.merge(df_esquerda, df_direita, left_on='ID', right_on='Chave', how='inner')
print(df_merge)O método join() é utilizado para combinar DataFrames baseando-se nos índices, ao invés de colunas. É especialmente útil quando os DataFrames já compartilham um índice comum.
how: Define o tipo de junção ('left','right','inner','outer').on: Coluna ou índice em que a junção será baseada.lsuffixersuffix: Sufixos para resolver conflitos de nomes de colunas.
Exemplo 1: Junção baseada no índice (inner join)
df_esquerda = pd.DataFrame({'A': [1, 2, 3]}, index=['K0', 'K1', 'K2'])
df_direita = pd.DataFrame({'B': [4, 5, 6]}, index=['K0', 'K1', 'K3'])
# Junção com base no índice comum
df_join = df_esquerda.join(df_direita, how='inner')
print(df_join)Exemplo 2: Junção com left join
# Junção com base no índice, mantendo todos os valores do DataFrame esquerdo
df_join = df_esquerda.join(df_direita, how='left')
print(df_join)Exemplo 3: Junção com right join
# Junção mantendo todos os valores do DataFrame direito
df_join = df_esquerda.join(df_direita, how='right')
print(df_join)Exemplo 4: Junção com outer join
# Junção mantendo todos os valores de ambos os DataFrames
df_join = df_esquerda.join(df_direita, how='outer')
print(df_join)Pandas facilita a leitura e escrita de dados em diversos formatos de arquivo, como CSV, Excel, JSON, entre outros. Isso torna a biblioteca poderosa para importar e exportar dados para diferentes sistemas.
Exemplo 1: Leitura de CSV com separador personalizado
# Ler um arquivo CSV com '|' como separador
df = pd.read_csv('dados.txt', sep='|')
print(df.head())Exemplo 2: Leitura de Excel
# Ler um arquivo Excel da primeira planilha
df = pd.read_excel('dados.xlsx', sheet_name='Planilha1')
print(df.head())Exemplo 3: Leitura de JSON
# Ler um arquivo JSON
df = pd.read_json('dados.json')
print(df.head())Exemplo 1: Escrever DataFrame em CSV sem incluir o índice
# Escrever DataFrame em um arquivo CSV, excluindo o índice
df.to_csv('saida.csv', index=False)Exemplo 2: Escrever DataFrame em Excel com múltiplas planilhas
# Escrever DataFrame em um arquivo Excel com múltiplas planilhas
with pd.ExcelWriter('saida.xlsx') as writer:
df.to_excel(writer, sheet_name='Planilha1')
df.to_excel(writer, sheet_name='Planilha2')Exemplo 3: Escrever DataFrame em formato JSON
# Escrever DataFrame em JSON com indentação
df.to_json('saida.json', indent=4)Pandas oferece funcionalidades mais avançadas, como a criação de tabelas dinâmicas e a manipulação de índices hierárquicos (MultiIndex), que são úteis em situações que envolvem agregação e segmentação de dados complexos.
O método pivot_table() é utilizado para criar tabelas dinâmicas, que resumem e agregam dados. Ele permite agrupar os dados com base em várias colunas e aplicar funções de agregação em valores numéricos.
Exemplo 1: Criar uma tabela dinâmica simples
# Criar tabela dinâmica para calcular a média do 'Salário' por 'Faixa Etária' e 'Categoria'
tabela_pivot = pd.pivot_table(df, values='Salário', index='Faixa Etária', columns='Categoria', aggfunc='mean')
print(tabela_pivot)Exemplo 2: Usar múltiplas funções de agregação
# Tabela dinâmica com múltiplas funções de agregação
tabela_pivot = pd.pivot_table(df, values='Salário', index='Faixa Etária', aggfunc=['mean', 'sum'])
print(tabela_pivot)Pandas permite criar e manipular índices hierárquicos (MultiIndex), o que é útil quando se trabalha com dados de várias camadas, como agrupamentos ou categorias aninhadas.
Exemplo 1: Criar um DataFrame com MultiIndex
arrays = [
['Grupo1', 'Grupo1', 'Grupo2', 'Grupo2'],
['Subgrupo1', 'Subgrupo2', 'Subgrupo1', 'Subgrupo2']
]
index = pd.MultiIndex.from_arrays(arrays, names=('Grupo', 'Subgrupo'))
df_multi = pd.DataFrame({'Dados': [1, 2, 3, 4]}, index=index)
print(df_multi)Exemplo 2: Acessar dados em MultiIndex
# Selecionar dados no nível 'Grupo1'
print(df_multi.loc['Grupo1'])
# Selecionar dados no nível específico ('Grupo1', 'Subgrupo1')
print(df_multi.loc[('Grupo1', 'Subgrupo1')])O parâmetro axis define a direção das operações em um DataFrame ou Series. Dependendo da operação, você pode aplicar a função por colunas (linhas individualmente) ou por linhas (colunas individualmente).
axis=0: A operação é realizada ao longo das linhas (por coluna). Este é o comportamento padrão.axis=1: A operação é realizada ao longo das colunas (por linha).
Exemplo 1: Soma de valores por coluna (axis=0)
# Somar os valores por coluna
soma_colunas = df[['Idade', 'Salário']].sum(axis=0)
print(soma_colunas)Exemplo 2: Soma de valores por linha (axis=1)
# Somar os valores por linha
soma_linhas = df[['Idade', 'Salário']].sum(axis=1)
print(soma_linhas)