Carregamento e Exploração de Dados com Pandas 📊

Bem-vindos à aula prática de "Carregamento e Exploração de Dados com Pandas"! Nesta sessão, vamos mergulhar no coração da manipulação de dados em Python, utilizando a biblioteca Pandas. Ela é a ferramenta essencial para cientistas de dados e engenheiros de Machine Learning, permitindo que você lide com dados tabulares de forma eficiente e intuitiva.

Nosso foco será em como trazer seus dados para o ambiente Python a partir de diferentes fontes e, em seguida, como realizar uma exploração inicial para entender sua estrutura e conteúdo. 🚀

1. Introdução: Por que Pandas? 🤔

Pandas é uma biblioteca de código aberto que fornece estruturas de dados de alto desempenho e ferramentas de análise de dados fáceis de usar. As duas estruturas de dados primárias do Pandas são:

• Series: Um array unidimensional rotulado capaz de conter qualquer tipo de dado.
• DataFrame: Uma estrutura de dados bidimensional, como uma tabela SQL ou uma planilha Excel, com rótulos de linha e coluna.

No contexto de Machine Learning, a maioria dos datasets com os quais trabalhamos são tabulares, tornando o DataFrame a estrutura ideal para representá-los. Antes de aplicar qualquer algoritmo de ML, precisamos carregar, limpar e entender nossos dados – e é aí que o Pandas brilha!

2. Carregamento de Dados com Pandas 📥

Pandas oferece funções robustas para carregar dados de diversas fontes. Vamos explorar as mais comuns.

Primeiro, vamos importar a biblioteca:

import pandas as pd
import numpy as np # Também útil para alguns exemplos
print(f"Pandas version: {pd.__version__}")

2.1. Carregando Dados de Arquivos CSV (.csv)

Arquivos CSV (Comma Separated Values) são um dos formatos mais comuns para exportar e importar dados tabulares. A função pd.read_csv() é a sua melhor amiga aqui.

Parâmetros importantes:

• filepath_or_buffer: Caminho para o arquivo CSV.
• sep: Separador de colunas (padrão é vírgula ,).
• header: Linha a ser usada como nomes das colunas (padrão é 0, a primeira linha). Use None se o arquivo não tiver cabeçalho.
• index_col: Coluna a ser usada como índice do DataFrame.
• names: Lista de nomes de colunas, se header=None.
• dtype: Dicionário para especificar tipos de dados para colunas.
• parse_dates: Lista de colunas para tentar parsear como datas.

Exemplo Prático (Criando um CSV virtualmente):

Vamos criar um arquivo CSV de exemplo para demonstrar.

# Criando um arquivo CSV de exemplo
csv_content = """id,nome,idade,cidade,salario
1,Alice,30,São Paulo,50000
2,Bob,24,Rio de Janeiro,45000
3,Carlos,35,Belo Horizonte,60000
4,Diana,29,São Paulo,52000
5,Eduardo,40,Curitiba,70000
"""
 
with open("dados_clientes.csv", "w") as f:
    f.write(csv_content)
 
# Carregando o arquivo CSV
df_clientes = pd.read_csv("dados_clientes.csv")
print("DataFrame carregado de CSV:")
print(df_clientes)
print("\n")
 
# Exemplo com separador diferente (se fosse ';')
# csv_content_semicolon = """id;nome;idade;cidade;salario
# 1;Alice;30;São Paulo;50000
# 2;Bob;24;Rio de Janeiro;45000
# """
# with open("dados_clientes_semicolon.csv", "w") as f:
#     f.write(csv_content_semicolon)
# df_clientes_semicolon = pd.read_csv("dados_clientes_semicolon.csv", sep=';')
# print("DataFrame carregado de CSV com separador ';':")
# print(df_clientes_semicolon)
# print("\n")

2.2. Carregando Dados de Arquivos Excel (.xlsx, .xls)

Para arquivos Excel, usamos pd.read_excel(). Você precisará ter as bibliotecas openpyxl (para .xlsx) ou xlrd (para .xls) instaladas.

pip install openpyxl xlrd

Parâmetros importantes:

• io: Caminho para o arquivo Excel.
• sheet_name: Nome da aba ou índice da aba (padrão é 0, a primeira aba). Pode ser uma lista para carregar múltiplas abas.
• header: Linha a ser usada como nomes das colunas.
• index_col: Coluna a ser usada como índice.
• names: Lista de nomes de colunas.
• dtype: Dicionário para especificar tipos de dados.
• parse_dates: Lista de colunas para tentar parsear como datas.

Exemplo Prático (Criando um Excel virtualmente):

# Criando um DataFrame de exemplo para salvar como Excel
df_produtos = pd.DataFrame({
    'id_produto': [101, 102, 103, 104],
    'nome_produto': ['Notebook', 'Mouse', 'Teclado', 'Monitor'],
    'preco': [3500.00, 75.50, 120.00, 1200.00],
    'estoque': [50, 200, 150, 30]
})
 
# Salvando em um arquivo Excel
df_produtos.to_excel("dados_produtos.xlsx", index=False) # index=False para não escrever o índice do DataFrame no Excel
 
# Carregando o arquivo Excel
df_produtos_excel = pd.read_excel("dados_produtos.xlsx")
print("DataFrame carregado de Excel:")
print(df_produtos_excel)
print("\n")
 
# Exemplo carregando uma aba específica (se houvesse múltiplas)
# Suponha que 'dados_produtos.xlsx' tem uma aba chamada 'Inventário'
# df_inventario = pd.read_excel("dados_produtos.xlsx", sheet_name="Inventário")

2.3. Carregando Dados de Bancos de Dados SQL 🗄️

Pandas pode interagir com bancos de dados SQL usando pd.read_sql_table(), pd.read_sql_query() ou o mais genérico pd.read_sql(). Você precisará de um conector de banco de dados (ex: sqlite3 para SQLite, psycopg2 para PostgreSQL, pymysql para MySQL) e, frequentemente, a biblioteca SQLAlchemy para criar engines de conexão.

Integração com sqlite3 (Python nativo):

Vamos usar sqlite3 para um exemplo simples com um banco de dados em memória.

import sqlite3
 
# 1. Criar uma conexão com o banco de dados (em memória para o exemplo)
conn = sqlite3.connect(':memory:')
 
# 2. Criar uma tabela e inserir alguns dados
conn.execute('''
    CREATE TABLE usuarios (
        id INTEGER PRIMARY KEY,
        nome TEXT NOT NULL,
        email TEXT UNIQUE NOT NULL
    )
''')
conn.execute("INSERT INTO usuarios (nome, email) VALUES ('João', 'joao@example.com')")
conn.execute("INSERT INTO usuarios (nome, email) VALUES ('Maria', 'maria@example.com')")
conn.commit() # Salva as alterações
 
# 3. Carregar dados usando pd.read_sql_query()
# Esta função recebe uma query SQL e um objeto de conexão
df_usuarios_sql = pd.read_sql_query("SELECT * FROM usuarios", conn)
print("DataFrame carregado de SQL (usuários):")
print(df_usuarios_sql)
print("\n")
 
# 4. Fechar a conexão
conn.close()

2.4. Carregando Dados de Arquivos JSON (.json)

JSON (JavaScript Object Notation) é um formato leve de intercâmbio de dados, muito comum em APIs web. pd.read_json() é a função para isso.

Parâmetros importantes:

• path_or_buffer: Caminho para o arquivo JSON.
• orient: Formato esperado do JSON (ex: 'records', 'columns', 'index'). 'records' é comum para uma lista de objetos JSON.
• typ: Tipo de objeto a ser construído (padrão é 'frame' para DataFrame, 'series' para Series).
• lines: Se o arquivo contém um objeto JSON por linha.

Exemplo Prático (Criando um JSON virtualmente):

# Criando um arquivo JSON de exemplo
json_content = """
[
    {"sensor_id": "A1", "temperatura": 25.5, "umidade": 60, "timestamp": "2023-10-26 10:00:00"},
    {"sensor_id": "A2", "temperatura": 24.8, "umidade": 62, "timestamp": "2023-10-26 10:01:00"},
    {"sensor_id": "A1", "temperatura": 25.7, "umidade": 61, "timestamp": "2023-10-26 10:02:00"}
]
"""
 
with open("dados_sensores.json", "w") as f:
    f.write(json_content)
 
# Carregando o arquivo JSON
df_sensores = pd.read_json("dados_sensores.json")
print("DataFrame carregado de JSON:")
print(df_sensores)
print("\n")
 
# Exemplo com JSON onde cada linha é um objeto JSON (orient='records' e lines=True)
json_lines_content = """
{"id": 1, "item": "Maçã", "quantidade": 10}
{"id": 2, "item": "Banana", "quantidade": 15}
{"id": 3, "item": "Laranja", "quantidade": 8}
"""
with open("dados_estoque_jsonl.json", "w") as f:
    f.write(json_lines_content)
 
df_estoque_jsonl = pd.read_json("dados_estoque_jsonl.json", lines=True)
print("DataFrame carregado de JSON (linhas):")
print(df_estoque_jsonl)
print("\n")

3. Exploração Inicial de Dados com Pandas 🕵️‍♀️

Depois de carregar seus dados, o próximo passo crucial é explorá-los para entender sua estrutura, identificar problemas e obter insights iniciais.

Vamos usar o df_clientes que carregamos do CSV para os exemplos.

# Re-carregando df_clientes para garantir que está disponível
csv_content = """id,nome,idade,cidade,salario
1,Alice,30,São Paulo,50000
2,Bob,24,Rio de Janeiro,45000
3,Carlos,35,Belo Horizonte,60000
4,Diana,29,São Paulo,52000
5,Eduardo,40,Curitiba,70000
"""
with open("dados_clientes.csv", "w") as f:
    f.write(csv_content)
df_clientes = pd.read_csv("dados_clientes.csv")

3.1. Visualizando as Primeiras/Últimas Linhas (.head(), .tail())

Para ter uma ideia rápida dos dados, .head() mostra as primeiras 5 linhas (ou n se especificado) e .tail() as últimas 5.

print("Primeiras 3 linhas do df_clientes:")
print(df_clientes.head(3))
print("\n")
 
print("Últimas 2 linhas do df_clientes:")
print(df_clientes.tail(2))
print("\n")

3.2. Informações Gerais do DataFrame (.info())

O método .info() fornece um resumo conciso do DataFrame, incluindo o número de entradas, o número de colunas, contagem de valores não nulos por coluna, o tipo de dado de cada coluna (dtype) e o uso de memória.

print("Informações gerais do df_clientes:")
df_clientes.info()
print("\n")

3.3. Estatísticas Descritivas (.describe())

.describe() gera estatísticas descritivas das colunas numéricas do DataFrame, como contagem, média, desvio padrão, mínimo, máximo e quartis.

print("Estatísticas descritivas do df_clientes:")
print(df_clientes.describe())
print("\n")
 
# Para incluir colunas não numéricas (objetos/strings)
print("Estatísticas descritivas de todas as colunas (incluindo objetos):")
print(df_clientes.describe(include='all'))
print("\n")

3.4. Dimensões do DataFrame (.shape)

O atributo .shape retorna uma tupla (número de linhas, número de colunas).

print(f"Dimensões do df_clientes: {df_clientes.shape}")
print(f"Número de linhas: {df_clientes.shape[0]}")
print(f"Número de colunas: {df_clientes.shape[1]}")
print("\n")

3.5. Nomes das Colunas (.columns)

O atributo .columns retorna um objeto Index contendo os nomes das colunas.

print("Nomes das colunas do df_clientes:")
print(df_clientes.columns)
print("\n")

3.6. Tipos de Dados das Colunas (.dtypes)

O atributo .dtypes retorna uma Series com o tipo de dado de cada coluna.

print("Tipos de dados das colunas do df_clientes:")
print(df_clientes.dtypes)
print("\n")

3.7. Contagem de Valores Únicos (.value_counts())

Para colunas categóricas, .value_counts() é extremamente útil para ver a distribuição de categorias.

print("Contagem de cidades no df_clientes:")
print(df_clientes['cidade'].value_counts())
print("\n")
 
print("Contagem de idade no df_clientes:")
print(df_clientes['idade'].value_counts())
print("\n")

3.8. Verificando Valores Ausentes (.isnull().sum())

Identificar valores ausentes é um passo crítico na exploração de dados. .isnull() retorna um DataFrame booleano, e .sum() conta os True (que representam valores nulos) por coluna.

# Vamos adicionar um valor nulo para demonstração
df_clientes_com_nulos = df_clientes.copy()
df_clientes_com_nulos.loc[0, 'salario'] = np.nan
df_clientes_com_nulos.loc[2, 'cidade'] = np.nan
 
print("DataFrame com valores nulos:")
print(df_clientes_com_nulos)
print("\n")
 
print("Contagem de valores nulos por coluna:")
print(df_clientes_com_nulos.isnull().sum())
print("\n")
 
# Para ver a porcentagem de nulos
print("Porcentagem de valores nulos por coluna:")
print(df_clientes_com_nulos.isnull().sum() / len(df_clientes_com_nulos) * 100)
print("\n")

4. Exercícios e Desafios Práticos 🏋️‍♂️

Agora é a sua vez de praticar! Vamos usar um dataset real (mas pequeno) para simular um cenário comum.

Dataset: titanic.csv (Um dataset clássico de sobreviventes do Titanic)

Você pode baixá-lo facilmente de várias fontes ou usar o link direto: https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv

Tarefas:

• 1. Carregue o Dataset:

  • Carregue o arquivo titanic.csv em um DataFrame do Pandas.
  • Certifique-se de que o DataFrame foi carregado corretamente.

• 2. Exploração Inicial:

  • Mostre as primeiras 7 linhas do DataFrame.
  • Mostre as últimas 3 linhas do DataFrame.
  • Exiba um resumo conciso do DataFrame (tipos de dados, contagem de nulos, etc.).
  • Obtenha estatísticas descritivas para as colunas numéricas.
  • Descubra as dimensões do DataFrame (linhas e colunas).
  • Liste os nomes de todas as colunas.
  • Liste os tipos de dados de cada coluna.

• 3. Análise de Valores Ausentes:

  • Identifique quantas células nulas existem em cada coluna.
  • Calcule a porcentagem de valores nulos para cada coluna.
  • Quais colunas possuem a maior quantidade de valores ausentes?

• 4. Análise de Colunas Categóricas:

  • Qual a distribuição de passageiros por classe (Pclass)? (Quantos na 1ª, 2ª, 3ª classe?)
  • Qual a distribuição de sobreviventes (Survived)? (Quantos sobreviveram, quantos não?)
  • Qual a distribuição de passageiros por sexo (Sex)?

• 5. Desafio Extra (Opcional):

  • Tente carregar o mesmo dataset, mas desta vez, defina a coluna PassengerId como o índice do DataFrame durante o carregamento.
  • Verifique se o índice foi definido corretamente.

# Seu código para os exercícios aqui:
 
# 1. Carregue o Dataset:
# URL do dataset
titanic_url = "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv"
 
# Carregue o arquivo CSV
df_titanic = pd.read_csv(titanic_url)
print("Dataset Titanic carregado com sucesso!\n")
 
# 2. Exploração Inicial:
print("Primeiras 7 linhas do DataFrame:")
# Seu código aqui
print(df_titanic.head(7))
print("\n")
 
print("Últimas 3 linhas do DataFrame:")
# Seu código aqui
print(df_titanic.tail(3))
print("\n")
 
print("Informações gerais do DataFrame:")
# Seu código aqui
df_titanic.info()
print("\n")
 
print("Estatísticas descritivas das colunas numéricas:")
# Seu código aqui
print(df_titanic.describe())
print("\n")
 
print("Dimensões do DataFrame:")
# Seu código aqui
print(df_titanic.shape)
print("\n")
 
print("Nomes das colunas:")
# Seu código aqui
print(df_titanic.columns)
print("\n")
 
print("Tipos de dados das colunas:")
# Seu código aqui
print(df_titanic.dtypes)
print("\n")
 
# 3. Análise de Valores Ausentes:
print("Contagem de valores nulos por coluna:")
# Seu código aqui
print(df_titanic.isnull().sum())
print("\n")
 
print("Porcentagem de valores nulos por coluna:")
# Seu código aqui
print(df_titanic.isnull().sum() / len(df_titanic) * 100)
print("\n")
 
# 4. Análise de Colunas Categóricas:
print("Distribuição de passageiros por Pclass:")
# Seu código aqui
print(df_titanic['Pclass'].value_counts())
print("\n")
 
print("Distribuição de sobreviventes (Survived):")
# Seu código aqui
print(df_titanic['Survived'].value_counts())
print("\n")
 
print("Distribuição de passageiros por Sexo:")
# Seu código aqui
print(df_titanic['Sex'].value_counts())
print("\n")
 
# 5. Desafio Extra (Opcional):
print("Desafio Extra: Carregando com PassengerId como índice:")
# Seu código aqui
df_titanic_indexed = pd.read_csv(titanic_url, index_col='PassengerId')
print(df_titanic_indexed.head())
print(f"\nO índice do DataFrame é: {df_titanic_indexed.index.name}")
print("\n")

5. Resumo e Próximos Passos ✨

Nesta aula prática, você aprendeu as bases para iniciar qualquer projeto de Machine Learning:

• Carregamento de Dados: Dominamos as funções pd.read_csv(), pd.read_excel(), pd.read_sql() e pd.read_json() para trazer dados de diferentes formatos para o Pandas DataFrame.
• Exploração Inicial de Dados: Você utilizou métodos essenciais como .head(), .info(), .describe(), .shape, .columns, .dtypes, .value_counts() e .isnull().sum() para obter um entendimento rápido e profundo da estrutura e qualidade dos seus dados.

Este é apenas o começo! Os próximos passos no seu aprendizado de Pandas e Machine Learning incluem:

1. Limpeza de Dados: Lidar com valores ausentes (remoção ou preenchimento), remover duplicatas, corrigir tipos de dados.
2. Transformação de Dados: Filtrar, selecionar, agrupar, mesclar e pivotar dados.
3. Engenharia de Features: Criar novas features a partir das existentes.
4. Visualização de Dados: Utilizar bibliotecas como Matplotlib e Seaborn para visualizar padrões e insights.

Continue explorando a documentação oficial do Pandas para descobrir todo o poder desta incrível biblioteca! Parabéns por concluir esta aula! 🎉