Python
Reordenando Colunas do Pandas: Um Guia para Iniciantes

Reordenando Colunas do Pandas: Um Guia para Iniciantes

MoeNagy Dev

Importância da Reordenação de Colunas no Pandas

Reordenar colunas em DataFrames do Pandas é uma habilidade essencial para analistas de dados e pesquisadores. Pode melhorar a análise de dados e a visualização, melhorar a legibilidade e a organização dos conjuntos de dados e alinhar os dados para casos de uso específicos.

Ao reorganizar a ordem das colunas, você pode:

  • Melhorar a análise de dados e a visualização, agrupando colunas relacionadas juntas, facilitando o entendimento e a interpretação dos dados.
  • Melhorar a legibilidade e a organização dos seus conjuntos de dados, tornando mais simples navegar e entender a estrutura dos dados.
  • Alinhar os dados para casos de uso específicos, como preparar dados para modelos de aprendizado de máquina ou criar relatórios personalizados.

Entendendo a Ordem das Colunas em DataFrames do Pandas

No Pandas, a ordem das colunas em um DataFrame é determinada pela ordem em que as colunas são criadas ou adicionadas ao DataFrame. Quando você cria um novo DataFrame, as colunas são tipicamente ordenadas na mesma ordem em que foram fornecidas durante o processo de criação.

Você pode acessar a ordem das colunas de um DataFrame usando o atributo columns:

import pandas as pd
 
# Criar um DataFrame de exemplo
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Exibir a ordem das colunas
print(df.columns)
# Saída: Index(['A', 'B', 'C'], dtype='object')

Reordenando Colunas Usando Métodos Embutidos

O Pandas fornece vários métodos embutidos para reordenar colunas em um DataFrame.

df.reindex(columns=new_order)

O método reindex() permite que você reordene as colunas especificando uma nova ordem no parâmetro columns. Esse método preserva os tipos de dados originais das colunas.

new_order = ['C', 'A', 'B']
df_reordered = df.reindex(columns=new_order)
print(df_reordered)
#    C  A  B
# 0  7  1  4
# 1  8  2  5
# 2  9  3  6

Se você especificar uma coluna que não existe no DataFrame original, `reindex()` adicionará uma nova coluna com valores `NaN`.

### `df[new_order]`

Você também pode reordenar as colunas selecionando-as na ordem desejada usando os nomes das colunas entre colchetes.

```python
# Reordenar as colunas
new_order = ['C', 'A', 'B']
df_reordered = df[new_order]
print(df_reordered)
#    C  A  B
# 0  7  1  4
# 1  8  2  5
# 2  9  3  6

Este método é mais conciso do que usar reindex(), mas não lida com colunas ausentes na nova ordem.

Técnicas Avançadas de Reordenação

Reordenação com base nos nomes das colunas

Você pode reordenar as colunas com base em seus nomes, seja em ordem alfabética ou em uma ordem específica definida por uma lista.

# Reordenar as colunas alfabeticamente
df_alphabetical = df[sorted(df.columns)]
print(df_alphabetical)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9
 
# Reordenar as colunas em uma ordem específica
specific_order = ['B', 'C', 'A']
df_specific_order = df[specific_order]
print(df_specific_order)
#    B  C  A
# 0  4  7  1
# 1  5  8  2
# 2  6  9  3

Reordenação com base nos tipos de dados das colunas

Você pode agrupar as colunas por seus tipos de dados e reorganizar a ordem dos tipos de dados.

# Reordenar as colunas por tipo de dados
df_by_dtype = df.reindex(sorted(df.columns, key=lambda x: (df[x].dtype, x)), axis=1)
print(df_by_dtype)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9

Neste exemplo, as colunas são primeiro classificadas por seus tipos de dados e, em seguida, por seus nomes (como um critério de classificação secundário).

Reordenação com base em estatísticas de coluna

Você pode reordenar as colunas com base em estatísticas específicas, como os valores mínimos, máximos ou médios das colunas.

# Reordenar as colunas pelo valor mínimo
df_by_min = df.reindex(df.min().sort_values().index, axis=1)
print(df_by_min)
#    A  B.

0 1 4 7

1 2 5 8

2 3 6 9


Neste exemplo, as colunas são reordenadas com base no valor mínimo de cada coluna, conforme determinado por `df.min().sort_values().index`.

## Reordenação Condicional de Colunas

Você pode reordenar as colunas com base em condições específicas, como selecionar colunas que correspondam a um padrão ou excluir colunas que atendam a determinados critérios.

```python
# Reordenar colunas que contêm a letra 'A'
df_with_A = df[df.columns[df.columns.str.contains('A')]]
print(df_with_A)
#    A
# 0  1
# 1  2
# 2  3

# Reordenar colunas excluindo aquelas que contêm a letra 'A'
df_without_A = df[df.columns[~df.columns.str.contains('A')]]
print(df_without_A)
#    B  C
# 0  4  7
# 1  5  8
# 2  6  9

Você pode combinar a reordenação condicional com os métodos de reordenação internos, como reindex() ou seleção de colunas com colchetes.

Preservando a Ordem Original das Colunas

Se você precisar redefinir a ordem das colunas para o estado inicial, pode usar o método reindex() com a ordem original das colunas.

# Redefinir a ordem das colunas para o estado original
df_original_order = df.reindex(df.columns, axis=1)
print(df_original_order)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9

Isso garante que a ordem das colunas seja restaurada para o estado inicial, mesmo que a ordem tenha sido modificada durante o fluxo de trabalho de processamento de dados.

Reordenando Colunas em Colunas de Vários Níveis

O Pandas também suporta estruturas de colunas de vários níveis, onde cada coluna tem um cabeçalho hierárquico. Você pode aplicar as técnicas de reordenação discutidas anteriormente a níveis individuais da estrutura de colunas de vários níveis.

# Criar um DataFrame com colunas de vários níveis
df_multilevel = pd.DataFrame({
    ('nível1', 'A'): [1, 2, 3],
    ('nível1', 'B'): [4, 5, 6],
    ('nível2', 'C'): [7, 8, 9]
})
 
# Reordenar as colunas pelo primeiro nível
df_reordered_multilevel = df_multilevel[sorted(df_multilevel.columns.get_level_values(0))]
print(df_reordered_multilevel)
#    (nível1, A)  (nível1, B)  (nível2, C)
# 0           1           4            7
# 1           2           5            8
# 2           3           6            9
```# 0           1           4            7
# 1           2           5            8
# 2           3           6            9
 

Neste exemplo, as colunas são reordenadas com base no primeiro nível da estrutura de colunas de vários níveis.

Instruções Condicionais

As instruções condicionais em Python permitem que você execute diferentes blocos de código com base em certas condições. As instruções condicionais mais comuns são if, elif e else.

idade = 25
if idade >= 18:
    print("Você é um adulto.")
else:
    print("Você é menor de idade.")

Neste exemplo, se a variável idade for maior ou igual a 18, o bloco de código sob a instrução if será executado. Caso contrário, o bloco de código sob a instrução else será executado.

Você também pode usar a instrução elif para verificar várias condições:

pontuacao = 85
if pontuacao >= 90:
    print("Você tirou um A.")
elif pontuacao >= 80:
    print("Você tirou um B.")
elif pontuacao >= 70:
    print("Você tirou um C.")
else:
    print("Você foi reprovado.")

Loops

Os loops em Python permitem que você execute repetidamente um bloco de código. Os dois tipos de loop mais comuns são for e while.

Loops For

Os loops for são usados para iterar sobre uma sequência (como uma lista, tupla ou string).

frutas = ["maçã", "banana", "cereja"]
for fruta in frutas:
    print(fruta)

Isso irá gerar a saída:

maçã
banana
cereja

Você também pode usar a função range() para criar uma sequência de números para iterar:

for i in range(5):
    print(i)

Isso irá gerar a saída:

0
1
2
3
4

Loops While

Os loops while são usados para executar um bloco de código enquanto uma determinada condição for verdadeira.

contador = 0
while contador < 5:
    print(contador)
    contador += 1

Isso irá gerar a saída:

0
1
2
3
4

Funções

As funções em Python são blocos de código reutilizáveis que executam uma tarefa específica. Elas podem receber argumentos e retornar valores.

def cumprimentar(nome):
    print(f"Olá, {nome}!")
 
cumprimentar("Alice")
cumprimentar("Bob")

Este irá imprimir:

Olá, Alice!
Olá, Bob!

Você também pode definir funções com argumentos padrão e argumentos de comprimento variável:

def calcular_area(comprimento, largura, altura=None):
    # Se a altura for fornecida
    if altura:
        return comprimento * largura * altura
    # Caso contrário, calcula a área da superfície
    else:
        return comprimento * largura
 
print(calcular_area(5, 3))       # Saída: 15
print(calcular_area(4, 2, 6))    # Saída: 48

Módulos e Pacotes

A biblioteca padrão do Python fornece uma ampla gama de módulos internos, e você também pode criar seus próprios módulos e pacotes.

import math
print(math.pi)    # Saída: 3.141592653589793

Você também pode importar funções ou atributos específicos de um módulo:

from math import sqrt
print(sqrt(16))   # Saída: 4.0

Pacotes são coleções de módulos e ajudam a organizar seu código em uma estrutura hierárquica.

meu_pacote/
    __init__.py
    modulo1.py
    modulo2.py
    subpacote/
        __init__.py
        modulo3.py

Tratamento de Exceções

Os mecanismos de tratamento de exceções do Python permitem que você lide com erros e situações inesperadas em seu código.

try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("Erro: Divisão por zero.")

Você também pode usar blocos except para lidar com vários tipos de exceções e incluir um bloco else e finally opcional.

try:
    num = int(input("Digite um número: "))
    print(10 / num)
except ValueError:
    print("Erro: Entrada inválida. Por favor, digite um número.")
except ZeroDivisionError:
    print("Erro: Divisão por zero.")
else:
    print("A operação foi bem-sucedida.")
finally:
    print("Este bloco será sempre executado.")

Entrada e Saída de Arquivos

O Python fornece funções integradas para ler e escrever em arquivos.

# Escrevendo em um arquivo
with open("exemplo.txt", "w") as arquivo:
    arquivo.write("Olá, mundo!")
 
# Lendo de um arquivo
with open("exemplo.txt", "r") as arquivo:
    conteudo = arquivo.read()
    print(conteudo)  # Saída: Olá, mundo!

O uso da declaração with.

Programação Orientada a Objetos (POO)

Python suporta programação orientada a objetos, o que permite que você crie classes e objetos personalizados.

class Carro:
    def __init__(self, marca, modelo, ano):
        self.marca = marca
        self.modelo = modelo
        self.ano = ano
 
    def ligar(self):
        print(f"O {self.ano} {self.marca} {self.modelo} está ligando.")
 
meu_carro = Carro("Toyota", "Camry", 2020)
meu_carro.ligar()  # Saída: O 2020 Toyota Camry está ligando.

Neste exemplo, definimos uma classe Carro com um método __init__ para inicializar os atributos do objeto e um método ligar para realizar uma ação.

Conclusão

Neste tutorial, abordamos uma ampla gama de conceitos do Python, incluindo instruções condicionais, loops, funções, módulos e pacotes, tratamento de exceções, entrada/saída de arquivos e programação orientada a objetos. Esses tópicos são essenciais para a construção de aplicativos Python robustos e eficientes. Lembre-se de praticar e experimentar com os exemplos de código fornecidos para solidificar seu entendimento desses conceitos. Bom código!

MoeNagy Dev.