🚀 Filtragem, Seleção e Agrupamento de Dados com Pandas

Bem-vindo(a) à aula sobre Manipulação e Análise de Dados com Pandas! 🐼 Nesta etapa fundamental do seu curso de Fundamentos do Machine Learning com Python, vamos mergulhar nas técnicas essenciais para preparar seus dados: filtragem, seleção e agrupamento.

💡 1. Introdução

No mundo do Machine Learning, os dados raramente vêm prontos para uso. Muitas vezes, precisamos extrair subconjuntos específicos, reorganizar informações ou sumarizar grandes volumes de dados para revelar padrões. O Pandas, com sua estrutura de DataFrame, oferece ferramentas poderosas e flexíveis para realizar essas tarefas de forma eficiente.

Nesta aula, você aprenderá a:

Filtrar dados com base em condições lógicas.
Selecionar colunas e linhas específicas usando diferentes métodos.
Agrupar dados para realizar análises sumarizadas.

Dominar essas técnicas é crucial para qualquer etapa do pipeline de Machine Learning, desde a exploração inicial até o pré-processamento para modelos. Vamos começar!

🔍 2. Explicação Detalhada com Exemplos

Para ilustrar os conceitos, utilizaremos um DataFrame de exemplo que simula dados de estudantes.

import pandas as pd
import numpy as np
 
# DataFrame de exemplo
data = {
    'Nome': ['Alice', 'Bob', 'Carlos', 'Diana', 'Eva', 'Frank', 'Grace', 'Heitor', 'Isabela', 'João'],
    'Idade': [23, 22, 24, 23, 25, 22, 26, 24, 23, 25],
    'Cidade': ['São Paulo', 'Rio de Janeiro', 'Belo Horizonte', 'São Paulo', 'Curitiba', 'Rio de Janeiro', 'São Paulo', 'Belo Horizonte', 'Curitiba', 'São Paulo'],
    'Curso': ['Engenharia', 'Ciência da Computação', 'Engenharia', 'Medicina', 'Ciência da Computação', 'Medicina', 'Engenharia', 'Ciência da Computação', 'Medicina', 'Engenharia'],
    'Nota_Final': [8.5, 7.2, 9.1, 8.8, 7.5, 9.0, 8.2, 7.8, 8.7, 9.3],
    'Status': ['Ativo', 'Ativo', 'Ativo', 'Inativo', 'Ativo', 'Ativo', 'Inativo', 'Ativo', 'Ativo', 'Inativo'],
    'Horas_Estudo_Semana': [15, 12, 18, 10, 14, 16, 11, 13, 17, 19]
}
df_alunos = pd.DataFrame(data)
 
print("Nosso DataFrame de exemplo (df_alunos):")
print(df_alunos)

Saída esperada

Nosso DataFrame de exemplo (df_alunos):
       Nome  Idade          Cidade                  Curso  Nota_Final   Status  Horas_Estudo_Semana
0     Alice     23       São Paulo             Engenharia         8.5    Ativo                   15
1       Bob     22  Rio de Janeiro  Ciência da Computação         7.2    Ativo                   12
2    Carlos     24  Belo Horizonte             Engenharia         9.1    Ativo                   18
3     Diana     23       São Paulo               Medicina         8.8  Inativo                   10
4       Eva     25      Curitiba    Ciência da Computação         7.5    Ativo                   14
5     Frank     22  Rio de Janeiro               Medicina         9.0    Ativo                   16
6     Grace     26       São Paulo             Engenharia         8.2  Inativo                   11
7    Heitor     24  Belo Horizonte  Ciência da Computação         7.8    Ativo                   13
8   Isabela     23      Curitiba                 Medicina         8.7    Ativo                   17
9      João     25       São Paulo             Engenharia         9.3  Inativo                   19

2.1. Filtragem de Dados (Boolean Indexing)

A filtragem de dados no Pandas é realizada usando indexação booleana. Isso significa que você cria uma série de valores True/False com base em uma condição, e o Pandas retorna apenas as linhas onde a condição é True.

Sintaxe Básica

df[condição]

Exemplos Inspirados na Documentação Oficial do Pandas:

1. Filtrar por uma única condição numérica: Queremos ver apenas os alunos com Nota_Final maior que 8.5.

# Alunos com nota final maior que 8.5
alunos_excelentes = df_alunos[df_alunos['Nota_Final'] > 8.5]
print("\nAlunos com Nota_Final > 8.5:")
print(alunos_excelentes)

2. Filtrar por uma única condição de string/categórica: Vamos encontrar todos os alunos da cidade de 'São Paulo'.

# Alunos de São Paulo
alunos_sp = df_alunos[df_alunos['Cidade'] == 'São Paulo']
print("\nAlunos de São Paulo:")
print(alunos_sp)

3. Filtrar por múltiplas condições: Podemos combinar condições usando operadores lógicos:

& para "E" (AND)
| para "OU" (OR)
~ para "NÃO" (NOT)

⚠️ Importante: Cada condição deve ser envolvida por parênteses ().

# Alunos de Engenharia OU Medicina
engenharia_ou_medicina = df_alunos[(df_alunos['Curso'] == 'Engenharia') | (df_alunos['Curso'] == 'Medicina')]
print("\nAlunos de Engenharia OU Medicina:")
print(engenharia_ou_medicina)
 
# Alunos de São Paulo E com Nota_Final maior que 8.0
sp_e_nota_alta = df_alunos[(df_alunos['Cidade'] == 'São Paulo') & (df_alunos['Nota_Final'] > 8.0)]
print("\nAlunos de São Paulo E Nota_Final > 8.0:")
print(sp_e_nota_alta)

4. Usando isin() para múltiplas condições categóricas: Para verificar se um valor está em uma lista de opções, isin() é muito útil.

# Alunos de São Paulo OU Rio de Janeiro
cidades_desejadas = ['São Paulo', 'Rio de Janeiro']
alunos_cidades_especificas = df_alunos[df_alunos['Cidade'].isin(cidades_desejadas)]
print(f"\nAlunos das cidades {cidades_desejadas}:")
print(alunos_cidades_especificas)

5. Filtrando strings com str.contains(): Útil para buscar substrings em colunas de texto.

# Alunos cujo nome contém a letra 'a' (ignorando maiúsculas/minúsculas)
nomes_com_a = df_alunos[df_alunos['Nome'].str.contains('a', case=False)]
print("\nAlunos cujo nome contém 'a' (case-insensitive):")
print(nomes_com_a)

2.2. Seleção de Dados

A seleção refere-se à forma como acessamos partes específicas do nosso DataFrame – seja uma coluna, um conjunto de colunas, uma linha ou um subconjunto de linhas e colunas.

2.2.1. Seleção de Colunas

Uma única coluna: Retorna uma Series.

# Selecionar a coluna 'Nome'
nomes = df_alunos['Nome']
print("\nColuna 'Nome' (Series):")
print(nomes)
print(type(nomes))

Múltiplas colunas: Retorna um DataFrame.

# Selecionar as colunas 'Nome' e 'Nota_Final'
nomes_notas = df_alunos[['Nome', 'Nota_Final']]
print("\nColunas 'Nome' e 'Nota_Final' (DataFrame):")
print(nomes_notas)
print(type(nomes_notas))

2.2.2. Seleção de Linhas e Colunas com `loc` e `iloc`

Estas são as ferramentas mais poderosas e recomendadas para seleção de dados, pois oferecem clareza e evitam ambiguidades.

df.loc[]: Seleção por rótulo (label). Permite usar nomes de índices e colunas.
df.iloc[]: Seleção por posição inteira (integer position). Permite usar índices numéricos baseados em zero.

Ambos aceitam [linhas, colunas].

Exemplos com `loc` (Seleção por Rótulo):

# Selecionar a linha com índice 0
linha_0_loc = df_alunos.loc[0]
print("\nLinha com índice 0 (usando .loc):")
print(linha_0_loc)
 
# Selecionar linhas de 0 a 2 (inclusive) e colunas 'Nome' e 'Curso'
sub_df_loc = df_alunos.loc[0:2, ['Nome', 'Curso']]
print("\nLinhas 0 a 2, colunas 'Nome' e 'Curso' (usando .loc):")
print(sub_df_loc)
 
# Selecionar 'Nome' e 'Nota_Final' para alunos com Idade > 23
alunos_mais_velhos_notas = df_alunos.loc[df_alunos['Idade'] > 23, ['Nome', 'Nota_Final']]
print("\nNome e Nota_Final para alunos com Idade > 23 (usando .loc):")
print(alunos_mais_velhos_notas)

Exemplos com `iloc` (Seleção por Posição):

# Selecionar a linha na posição 0
linha_0_iloc = df_alunos.iloc[0]
print("\nLinha na posição 0 (usando .iloc):")
print(linha_0_iloc)
 
# Selecionar as 3 primeiras linhas (posições 0, 1, 2) e as 2 primeiras colunas (posições 0, 1)
sub_df_iloc = df_alunos.iloc[0:3, 0:2] # Note que o fatiamento (slice) é exclusivo no final para posições
print("\n3 primeiras linhas, 2 primeiras colunas (usando .iloc):")
print(sub_df_iloc)
 
# Selecionar todas as linhas e a coluna na posição 4 (Nota_Final)
nota_final_iloc = df_alunos.iloc[:, 4]
print("\nColuna Nota_Final (usando .iloc):")
print(nota_final_iloc)

⚠️ Diferença Crucial entre `loc` e `iloc`

loc: Usa os rótulos do índice e os nomes das colunas. O fatiamento (slice) [start:end] inclui o end.
iloc: Usa as posições inteiras (0-based) do índice e das colunas. O fatiamento [start:end] exclui o end.

# Exemplo para ilustrar a diferença no fatiamento:
print("\nDataFrame original:")
print(df_alunos.loc[0:2, ['Nome', 'Idade']]) # Inclui o índice 2
print("\nDataFrame com .loc[0:2, ['Nome', 'Idade']]:")
print(df_alunos.iloc[0:2, [0, 1]]) # Exclui a posição 2
print("\nDataFrame com .iloc[0:2, [0, 1]]:")

2.3. Agrupamento de Dados com `groupby()`

A operação groupby() é uma das mais poderosas no Pandas e segue o paradigma "Split-Apply-Combine" (Dividir-Aplicar-Combinar):

Split (Dividir): O DataFrame é dividido em grupos com base em uma ou mais chaves (colunas).
Apply (Aplicar): Uma função é aplicada a cada grupo (ex: soma, média, contagem, etc.).
Combine (Combinar): Os resultados de cada grupo são combinados em uma única estrutura de dados (geralmente um novo DataFrame ou Series).

Sintaxe Básica

df.groupby('coluna_para_agrupar').funcao_agregacao()

Funções de Agregação Comuns:

sum(), mean(), median(), min(), max(), count(), size(), std(), var(), first(), last().

Exemplos Inspirados na Documentação Oficial do Pandas:

1. Agrupar por uma coluna e calcular a média: Vamos calcular a Nota_Final média por Curso.

# Média da Nota_Final por Curso
media_notas_por_curso = df_alunos.groupby('Curso')['Nota_Final'].mean()
print("\nMédia da Nota_Final por Curso:")
print(media_notas_por_curso)

2. Agrupar por múltiplas colunas: Podemos agrupar por Cidade e Curso para ver a média de Horas_Estudo_Semana.

# Média de Horas_Estudo_Semana por Cidade e Curso
media_horas_por_cidade_curso = df_alunos.groupby(['Cidade', 'Curso'])['Horas_Estudo_Semana'].mean()
print("\nMédia de Horas_Estudo_Semana por Cidade e Curso:")
print(media_horas_por_cidade_curso)

3. Aplicar múltiplas funções de agregação com agg(): Para obter várias estatísticas por grupo, usamos agg().

# Média, Mínimo e Máximo da Nota_Final por Curso
estatisticas_notas_por_curso = df_alunos.groupby('Curso')['Nota_Final'].agg(['mean', 'min', 'max', 'count'])
print("\nEstatísticas da Nota_Final por Curso:")
print(estatisticas_notas_por_curso)
 
# Agregação personalizada com dicionário para diferentes colunas
estatisticas_personalizadas = df_alunos.groupby('Curso').agg(
    Media_Nota=('Nota_Final', 'mean'),
    Total_Alunos=('Nome', 'count'),
    Max_Horas=('Horas_Estudo_Semana', 'max')
)
print("\nEstatísticas personalizadas por Curso:")
print(estatisticas_personalizadas)

4. Filtragem de grupos com filter(): Às vezes, queremos apenas grupos que satisfaçam uma certa condição. filter() retorna um DataFrame contendo apenas os grupos que passam pelo filtro.

# Filtrar cursos que tenham mais de 2 alunos
cursos_com_mais_de_2_alunos = df_alunos.groupby('Curso').filter(lambda x: len(x) > 2)
print("\nCursos com mais de 2 alunos:")
print(cursos_com_mais_de_2_alunos)

5. Transformações dentro de grupos com transform(): transform() retorna uma Series do mesmo tamanho que o DataFrame original, aplicando uma função de agregação a cada grupo e "transmitindo" o resultado de volta para as linhas originais. Isso é útil para normalização de dados dentro de grupos.

# Calcular a nota média do curso para cada aluno
df_alunos['Nota_Media_Curso'] = df_alunos.groupby('Curso')['Nota_Final'].transform('mean')
print("\nDataFrame com Nota_Media_Curso adicionada:")
print(df_alunos[['Nome', 'Curso', 'Nota_Final', 'Nota_Media_Curso']])
 
# Calcular o desvio da nota do aluno em relação à média do curso
df_alunos['Desvio_Nota_Media_Curso'] = df_alunos['Nota_Final'] - df_alunos['Nota_Media_Curso']
print("\nDataFrame com Desvio_Nota_Media_Curso adicionado:")
print(df_alunos[['Nome', 'Curso', 'Nota_Final', 'Nota_Media_Curso', 'Desvio_Nota_Media_Curso']])

📝 3. Resumo e Próximos Passos

Nesta aula, você aprendeu as operações fundamentais de manipulação de dados com Pandas:

Filtragem: Usando indexação booleana e funções como isin() e str.contains() para selecionar subconjuntos de dados com base em condições.
Seleção: Acessando colunas específicas diretamente ou usando os poderosos indexadores loc (por rótulo) e iloc (por posição) para fatiar seu DataFrame com precisão.
Agrupamento: Utilizando groupby() para dividir, aplicar e combinar dados, permitindo análises sumarizadas e transformações complexas.

Dominar essas ferramentas é um passo gigantesco para se tornar proficiente em análise de dados e Machine Learning. Elas são a base para o pré-processamento de dados, engenharia de features e exploração de dados, etapas cruciais em qualquer projeto de ML.

➡️ Próximos Passos:

Na próxima aula, exploraremos a Combinação e Reestruturação de Dados com Pandas, onde aprenderemos a unir DataFrames (merge, concat), pivotar e derreter dados, e lidar com valores ausentes. Prepare-se para integrar ainda mais seus conhecimentos! 🚀

Fundamentos do Machine Learning com Python

Filtragem, Seleção e Agrupamento de Dados com Pandas (Documentação Pandas)

🚀 Filtragem, Seleção e Agrupamento de Dados com Pandas

💡 1. Introdução

🔍 2. Explicação Detalhada com Exemplos

2.1. Filtragem de Dados (Boolean Indexing)

Sintaxe Básica

Exemplos Inspirados na Documentação Oficial do Pandas:

2.2. Seleção de Dados

2.2.1. Seleção de Colunas

2.2.2. Seleção de Linhas e Colunas com loc e iloc

Exemplos com loc (Seleção por Rótulo):

Exemplos com iloc (Seleção por Posição):

⚠️ Diferença Crucial entre loc e iloc

2.3. Agrupamento de Dados com groupby()

Sintaxe Básica

Funções de Agregação Comuns:

Exemplos Inspirados na Documentação Oficial do Pandas:

📝 3. Resumo e Próximos Passos

➡️ Próximos Passos:

2.2.2. Seleção de Linhas e Colunas com `loc` e `iloc`

Exemplos com `loc` (Seleção por Rótulo):

Exemplos com `iloc` (Seleção por Posição):

⚠️ Diferença Crucial entre `loc` e `iloc`

2.3. Agrupamento de Dados com `groupby()`