Python
Pandas Crosstab: Um Guia Iniciante para Análise Sem Esforço

Pandas Crosstab: Um Guia Iniciante para Análise Sem Esforço

MoeNagy Dev

O que é o pandas crosstab?

A função crosstab() na biblioteca pandas é uma ferramenta poderosa para criar tabelas de contingência, também conhecidas como tabulações cruzadas. Ela permite que você analise a relação entre duas ou mais variáveis ​​categóricas, fornecendo uma representação tabular da distribuição de frequência delas.

A função crosstab() aceita uma ou mais séries ou variáveis ​​categóricas como entrada e gera uma tabela bidimensional, onde as linhas representam uma variável e as colunas representam outra variável. A tabela resultante mostra a contagem ou frequência das combinações das variáveis ​​de entrada.

Os principais recursos e casos de uso do crosstab() incluem:

  • Análise de Frequência: Identificar a frequência ou contagem de diferentes combinações de variáveis ​​categóricas.
  • Tabela de Contingência: Criar uma tabela de contingência para analisar a relação entre duas ou mais variáveis ​​categóricas.
  • Tabela Dinâmica: Gerar uma saída semelhante a uma tabela dinâmica, que pode ser ainda mais personalizada e analisada.
  • Probabilidades Condicionais: Calcular as probabilidades condicionais entre as variáveis.
  • Exploração de Dados: Explorar a distribuição e os relacionamentos dentro do seu conjunto de dados.

Criando um crosstab Simples

Vamos começar gerando um DataFrame de amostra para trabalhar:

import pandas as pd
 
# Gerar um DataFrame de amostra
data = {
    'Gênero': ['Masculino', 'Feminino', 'Masculino', 'Feminino', 'Masculino', 'Feminino'],
    'Idade': ['Jovem', 'Jovem', 'Idoso', 'Idoso', 'Jovem', 'Idoso'],
    'Contagem': [10, 8, 6, 12, 5, 9]
}
 
df = pd.DataFrame(data)

Agora. , podemos usar a função crosstab() para criar uma tabela cruzada simples:

pd.crosstab(df['Gênero'], df['Idade'])

Isso irá gerar uma tabela que mostra a contagem de cada combinação de 'Gênero' e 'Idade' no DataFrame.

Idade  Idoso  Jovem
Gênero
Feminino   12     8
Masculino   6    15

As linhas representam a variável 'Gênero', e as colunas representam a variável 'Idade'. Os valores na tabela mostram a contagem de cada combinação.

Personalizando a tabela cruzada

Você pode personalizar ainda mais a função crosstab() para atender às suas necessidades. Vamos explorar algumas das opções disponíveis.

Especificando rótulos de linha e coluna

Você pode fornecer rótulos personalizados para as linhas e colunas usando os parâmetros index e columns:

pd.crosstab(df['Gênero'], df['Idade'], rownames=['Gênero'], colnames=['Idade'])

Isso irá gerar a mesma saída de antes, mas com os rótulos de linha e coluna personalizados.

Aplicando funções de agregação

Por padrão, crosstab() conta o número de ocorrências para cada combinação de variáveis. Você pode alterar esse comportamento aplicando uma função de agregação usando o parâmetro aggfunc:

pd.crosstab(df['Gênero'], df['Idade'], values=df['Contagem'], aggfunc=sum)

Isso irá criar uma tabela cruzada que soma os valores de 'Contagem' para cada combinação de 'Gênero' e 'Idade'.

Lidando com valores ausentes

Se seus dados contiverem valores ausentes, você pode controlar como eles são tratados usando os parâmetros margins e margins_name:

pd.crosstab(df['Gênero'], df['Idade'], margins=True, margins_name='Total')

Isso irá adicionar uma linha e coluna 'Total' à tabela cruzada, fornecendo as contagens totais para cada linha e coluna, incluindo o total geral.

Técnicas avançadas de tabela cruzada

Trabalhando com índices multinível

A função crosstab() também pode lidar com índices multinível em seus dados. Vamos criar um DataFrame de amostra com um índice multinível:

data = {
    ('Gênero', ''): ['Masculino', 'Feminino', 'Masculino', 'Feminino', 'Masculino', '.
```python
dados = {
    ('Gênero', ''): ['Masculino', 'Masculino', 'Feminino', 'Feminino', 'Feminino', 'Feminino'],
    ('Idade', ''): ['Jovem', 'Jovem', 'Idoso', 'Idoso', 'Jovem', 'Idoso'],
    ('Contagem', ''): [10, 8, 6, 12, 5, 9]
}
 
df = pd.DataFrame(dados)
df.columns = pd.MultiIndex.from_tuples(df.columns)

Agora, podemos criar uma tabela cruzada usando o índice multinível:

pd.crosstab(df[('Gênero', '')], df[('Idade', '')])

A saída terá um índice multinível tanto para as linhas quanto para as colunas, refletindo a estrutura dos dados de entrada.

Normalizando a saída da tabela cruzada

Você pode normalizar a saída da tabela cruzada para mostrar as frequências relativas em vez das contagens brutas. Isso pode ser feito usando o parâmetro normalize:

pd.crosstab(df['Gênero'], df['Idade'], normalize='index')

Isso irá normalizar a tabela cruzada dividindo cada valor pela soma da linha, resultando nos percentuais de linha.

Visualizando os dados da tabela cruzada

Para visualizar os dados da tabela cruzada, você pode usar várias funções de plotagem fornecidas pelo pandas ou outras bibliotecas de visualização, como Matplotlib ou Seaborn. Por exemplo:

import matplotlib.pyplot as plt
 
tabela_cruzada = pd.crosstab(df['Gênero'], df['Idade'])
tabela_cruzada.plot(kind='bar', figsize=(8, 6))
plt.title('Tabela Cruzada de Gênero e Idade')
plt.xlabel('Gênero')
plt.ylabel('Contagem')
plt.show()

Isso criará um gráfico de barras da tabela cruzada, o que pode ser útil para entender as relações entre as variáveis.

Filtrando e Ordenando a tabela cruzada

Filtrando a tabela cruzada com base em critérios

Você pode filtrar a tabela cruzada com base em critérios específicos usando as técnicas padrão de indexação e máscara booleana do pandas:

tabela_cruzada = pd.crosstab(df['Gênero'], df['Idade'])
tabela_cruzada_filtrada = tabela_cruzada.loc[tabela_cruzada['Jovem'] > 5]

Isso criará uma nova tabela cruzada que inclui apenas as linhas em que o valor da coluna 'Jovem' é maior que 5.

Ordenando as linhas e colunas da tabela cruzada

Para ordenar as linhas e colunas da tabela cruzada, você pode usar o método sort_index():

tabela_cruzada = pd.crosstab(df['Gênero'], df['Idade'])
tabela_cruzada_ordenada = tabela_cruzada.sort_index()

ab = crosstab.sort_index(axis=0, ascending=False)


Isso irá classificar as linhas do crosstab em ordem decrescente.

### Combinando filtragem e classificação

Você pode combinar filtragem e classificação para personalizar ainda mais a saída do crosstab:

```python
crosstab = pd.crosstab(df['Gender'], df['Age'])
filtered_sorted_crosstab = crosstab.loc[crosstab['Young'] > 5].sort_index(axis=0, ascending=False)

Isso primeiro filtrará o crosstab para incluir apenas as linhas onde o valor da coluna 'Young' é maior que 5, e depois classificará as linhas em ordem decrescente.

Crosstabs com Dados Categóricos

Trabalhando com variáveis categóricas

Ao trabalhar com variáveis categóricas, é importante garantir que elas estejam devidamente codificadas como tipos de dados categóricos. Você pode usar o método astype() para converter uma coluna em um tipo de dados categórico:

df['Gender'] = df['Gender'].astype('category')
df['Age'] = df['Age'].astype('category')

Exibindo crosstab para recursos categóricos

Depois de ter suas variáveis categóricas configuradas, você pode criar um crosstab para analisar os relacionamentos entre elas:

pd.crosstab(df['Gender'], df['Age'])

Isso exibirá o crosstab para as variáveis categóricas 'Gender' e 'Age'.

Lidando com valores NaN em dados categóricos

Se seus dados contiverem valores NaN (ausentes) nas variáveis categóricas, você pode tratá-los usando o parâmetro dropna:

pd.crosstab(df['Gender'], df['Age'], dropna=False)

Isso incluirá os valores NaN na saída do crosstab, permitindo que você analise os dados ausentes também.

Crosstabs com Séries Temporais

Gerando crosstabs para dados baseados em tempo

Se seus dados contiverem informações relacionadas ao tempo, você pode usar a função crosstab() para analisar os relacionamentos ao longo do tempo. Vamos criar um DataFrame de amostra com uma coluna de data:

data = {
    'Date': ['2022-01-01', '2022-01-02', '2022-01-03', '2022-01-04', '2022-01-05', '2022-01-06'],
    'Gender': ['Male', 'Female', 'Male.
', 'Feminino', 'Masculino', 'Feminino'],
    'Idade': ['Jovem', 'Jovem', 'Velho', 'Velho', 'Jovem', 'Velho'],
    'Contagem': [10, 8, 6, 12, 5, 9]
}
 
df = pd.DataFrame(data)
df['Data'] = pd.to_datetime(df['Data'])
 
Agora, você pode criar uma tabela cruzada usando a coluna 'Data' como uma das variáveis:
 
```python
pd.crosstab(df['Data'].dt.date, df['Gênero'])

Isso irá gerar uma tabela cruzada que mostra a contagem de cada gênero para cada data no DataFrame.

Analisando tendências e padrões ao longo do tempo

Você pode analisar ainda mais as tendências e padrões na tabela cruzada baseada no tempo usando funções adicionais do pandas ou visualizações:

tabela_cruzada = pd.crosstab(df['Data'].dt.date, df['Gênero'])
tabela_cruzada.plot(kind='line', figsize=(10, 6))
plt.title('Contagens de Gênero ao Longo do Tempo')
plt.xlabel('Data')
plt.ylabel('Contagem')
plt.show()

Isso criará um gráfico de linha das contagens de gênero ao longo do tempo, permitindo que você identifique quaisquer tendências ou padrões nos dados.

Lidando com operações relacionadas a data/hora

Ao trabalhar com dados baseados no tempo, você pode precisar realizar várias operações relacionadas a data/hora, como agrupar por ano, mês ou dia. Você pode usar o acessador dt na coluna 'Data' para acessar essas operações:

pd.crosstab(df['Data'].dt.month, df['Gênero'])

Isso criará uma tabela cruzada que mostra a contagem de cada gênero para cada mês nos dados.

Combinando tabela cruzada com outras funções do pandas

Integrando tabela cruzada com groupby()

Você pode combinar a função crosstab() com a função groupby() para realizar análises mais complexas. Por exemplo, você pode primeiro agrupar os dados por uma variável e, em seguida, criar uma tabela cruzada nos dados agrupados:

df_agrupado = df.groupby(['Gênero', 'Idade'])
pd.crosstab(df_agrupado.groups.keys(), df['Data'].dt.date)

Isso criará uma tabela cruzada que mostra a contagem de cada combinação de 'Gênero' e 'Idade' para cada data nos dados.

Combinando tabela cruzada com pivot_table()

A função crosstab() também pode ser usada em conjunto com. com a função pivot_table() para realizar análise de dados mais avançada:

pivot_table = pd.pivot_table(df, index=['Gênero', 'Idade'], columns='Data', values='Contagem', aggfunc='soma')

Isso criará uma tabela dinâmica que mostra a soma de 'Contagem' para cada combinação de 'Gênero' e 'Idade' através das diferentes datas.

Explorando outras funções do pandas para tabela cruzada

Embora crosstab() seja uma ferramenta poderosa, existem outras funções do pandas que podem ser usadas em combinação ou como alternativas a crosstab(). Alguns exemplos incluem:

  • value_counts(): Obter as contagens de frequência de valores únicos em uma Série.
  • pivot(): Criar uma tabela dinâmica no estilo de planilha como um DataFrame.
  • melt(): Despivotear um DataFrame de formato largo para formato longo.
  • cut() e qcut(): Agrupar dados contínuos em intervalos.

Explorar essas funções pode ajudá-lo a expandir sua caixa de ferramentas de análise de dados e encontrar a abordagem mais adequada para seu caso de uso específico.

Funções

Funções são um conceito fundamental em Python que permitem que você encapsule um conjunto de instruções e as reutilize em todo o seu código. As funções podem receber parâmetros de entrada, executar algumas operações e retornar um resultado.

Aqui está um exemplo de uma função simples que calcula a área de um retângulo:

def calcular_area(comprimento, largura):
    area = comprimento * largura
    return area
 
# Chame a função e imprima o resultado
resultado = calcular_area(5, 10)
print(f"A área do retângulo é {resultado} unidades quadradas.")

Neste exemplo, a função calcular_area() recebe dois parâmetros, comprimento e largura, e retorna a área calculada. Você pode então chamar a função e armazenar o resultado na variável resultado, que é então impresso no console.

As funções também podem ter valores de parâmetro padrão, o que permite que você chame a função sem fornecer todos os argumentos:

def cumprimentar(nome, mensagem="Olá"):
    print(f"{mensagem}, {nome}!")
 
cumprimentar("Alice")  # Saída: Olá, Alice!
cumprimentar("Bob", "Oi")  # Saída: Oi, Bob!

) # Saída: Olá, Bob!


Neste exemplo, a função `greet()` tem um valor padrão de `"Olá"` para o parâmetro `message`, então você pode chamar a função apenas com o argumento `name` e ela usará a mensagem padrão.

## Módulos e Pacotes
O design modular do Python permite que você organize seu código em componentes reutilizáveis chamados módulos. Módulos são arquivos Python que contêm funções, classes e variáveis que podem ser importados e usados em outras partes do seu código.

Aqui está um exemplo de criação de um módulo simples chamado `math_utils.py`:

```python
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    return a / b

Você pode então importar e usar as funções deste módulo em outro arquivo Python:

import math_utils
 
result = math_utils.add(5, 3)
print(result)  # Saída: 8
 
result = math_utils.subtract(10, 4)
print(result)  # Saída: 6

Os módulos também podem ser organizados em pacotes, que são diretórios contendo vários módulos. Isso permite que você crie uma estrutura hierárquica para o seu código e facilite o gerenciamento.

Aqui está um exemplo de uma estrutura de pacote:

my_package/
    __init__.py
    math/
        __init__.py
        operations.py
        geometry.py
    data/
        __init__.py
        file_utils.py
        database_utils.py

Neste exemplo, o pacote my_package contém dois subpacotes: math e data. Cada subpacote tem seu próprio conjunto de módulos, e os arquivos __init__.py permitem que o Python reconheça esses diretórios como pacotes.

Você pode então importar e usar as funções dos módulos dentro do pacote:

from my_package.math.operations import add, subtract
from my_package.data.file_utils import read_file
 
result = add(5, 3)
print(result)  # Saída: 8
 
data = read_file("data.txt")
print(data)

Programação Orientada a Objetos (POO)

A Programação Orientada a Objetos (POO) é um paradigma de programação que se concentra em criar objetos. Objetos são instâncias de classes. As classes definem a estrutura e o comportamento dos objetos, e os objetos podem interagir uns com os outros para resolver problemas complexos.

Aqui está um exemplo de uma classe simples representando uma pessoa:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
 
    def cumprimentar(self):
        print(f"Olá, meu nome é {self.nome} e eu tenho {self.idade} anos.")
 
# Crie um objeto Pessoa e chame o método cumprimentar
pessoa = Pessoa("Alice", 30)
pessoa.cumprimentar()  # Saída: Olá, meu nome é Alice e eu tenho 30 anos.

Neste exemplo, a classe Pessoa tem dois atributos (nome e idade) e um método (cumprimentar()). Quando você cria um novo objeto Pessoa, você pode definir os valores iniciais dos atributos usando o método __init__(), que é um método especial chamado de construtor.

Você também pode criar subclasses que herdam de uma classe base, permitindo que você estenda a funcionalidade da classe base:

class Estudante(Pessoa):
    def __init__(self, nome, idade, serie):
        super().__init__(nome, idade)
        self.serie = serie
 
    def estudar(self):
        print(f"{self.nome} está estudando para a {self.serie} série.")
 
# Crie um objeto Estudante e chame seus métodos
estudante = Estudante("Bob", 15, "10ª")
estudante.cumprimentar()  # Saída: Olá, meu nome é Bob e eu tenho 15 anos.
estudante.estudar()  # Saída: Bob está estudando para a 10ª série.

Neste exemplo, a classe Estudante herda da classe Pessoa e adiciona um atributo serie e um método estudar(). O método __init__() da classe Estudante chama o método __init__() da classe Pessoa usando a função super() para inicializar os atributos nome e idade.

Exceções e Tratamento de Erros

O mecanismo de tratamento de exceções do Python permite que você lide com situações inesperadas em seu código e forneça uma maneira elegante de lidar com erros. As exceções são levantadas quando ocorre um erro durante a execução de um programa, e você pode. Escreva o código para capturar e lidar com essas exceções.

Aqui está um exemplo de como lidar com uma exceção ZeroDivisionError:

def divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Erro: Divisão por zero não é permitida.")
        return None
 
print(divide(10, 2))  # Saída: 5.0
print(divide(10, 0))  # Saída: Erro: Divisão por zero não é permitida.

Neste exemplo, a função divide() usa um bloco try-except para capturar a exceção ZeroDivisionError. Se a operação de divisão gerar a exceção, o código no bloco except é executado e uma mensagem é impressa no console. Se a divisão for bem-sucedida, o resultado é retornado.

Você também pode definir suas próprias exceções personalizadas, criando uma nova classe que herda da classe Exception integrada:

class NegativeNumberError(Exception):
    pass
 
def square_root(number):
    if number < 0:
        raise NegativeNumberError("Erro: Não é possível calcular a raiz quadrada de um número negativo.")
    return number ** 0.5
 
try:
    print(square_root(16))  # Saída: 4.0
    print(square_root(-4))
except NegativeNumberError as e:
    print(e)  # Saída: Erro: Não é possível calcular a raiz quadrada de um número negativo.

Neste exemplo, a função square_root() levanta uma exceção personalizada NegativeNumberError se o número de entrada for negativo. O bloco try-except captura a exceção e imprime a mensagem de erro.

Conclusão

Neste tutorial de Python, você aprendeu sobre vários conceitos de nível intermediário em Python, incluindo funções, módulos e pacotes, programação orientada a objetos e tratamento de exceções. Esses tópicos são essenciais para a construção de aplicativos Python mais complexos e robustos.

Lembre-se, a melhor maneira de melhorar suas habilidades em Python é praticar a escrita de código e resolver problemas. Experimente os exemplos fornecidos neste tutorial e tente aplicar esses conceitos aos seus próprios projetos. Além disso, continue . Para explorar o vasto ecossistema de bibliotecas e estruturas Python, que podem expandir enormemente as capacidades dos seus programas Python.

Feliz codificação!

MoeNagy Dev.