Python
Pandas Rename: Um Guia Iniciante para Renomear com Facilidade

Pandas Rename: Um Guia Iniciante para Renomear com Facilidade

MoeNagy Dev

Pandas Rename: Entendendo os Fundamentos

Apresentando o método pandas.DataFrame.rename()

O método pandas.DataFrame.rename() é uma ferramenta poderosa para renomear as colunas e índices (linhas e colunas) de um DataFrame do pandas. Esse método permite modificar os nomes dos seus dados de uma maneira flexível e eficiente, facilitando o trabalho e o entendimento dos seus dados.

Renomeando colunas

Para renomear colunas em um DataFrame, você pode usar o parâmetro columns do método rename(). Você pode passar um dicionário ou uma função para especificar os novos nomes das colunas.

import pandas as pd
 
# Criar um DataFrame de exemplo
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Renomear colunas pelo nome
df = df.rename(columns={'A': 'alpha', 'B': 'beta', 'C': 'gamma'})
print(df)

Saída:

   alpha  beta  gamma
0      1     4      7
1      2     5      8
2      3     6      9

Renomeando índices (linhas e colunas)

O método rename() também pode ser usado para renomear os índices de linha (index) e coluna de um DataFrame. Você pode usar o parâmetro index para renomear as linhas e o parâmetro columns para renomear as colunas.

# Renomeando linhas e colunas
df = df.rename(index={0: 'one', 1: 'two', 2: 'three'}, columns={'alpha': 'A', 'beta': 'B', 'gamma': 'C'})
print(df)

Saída:

        A  B  C
one     1  4  7
two     2  5  8
three   3  6  9

Lidando com múltiplas renomeações simultaneamente

Você também pode realizar várias renomeações de uma vez, passando um dicionário ou uma função para o método rename().

df = df.rename(index={'one': 'primeiro', 'two': 'segundo', 'three': 'terceiro'},
               columns={'A': 'X', 'B': 'Y', 'C': 'Z'})
print(df)

Saída:

X Y Z primeiro 1 4 7 segundo 2 5 8 terceiro 3 6 9


## Pandas Rename: Renomeando Colunas

### Renomeando colunas por nome

Você pode renomear colunas especificando diretamente os nomes antigos e novos das colunas no parâmetro `columns` do método `rename()`.

```python
# Renomeando colunas por nome
df = pd.DataFrame({'original_a': [1, 2, 3], 'original_b': [4, 5, 6], 'original_c': [7, 8, 9]})
df = df.rename(columns={'original_a': 'new_a', 'original_b': 'new_b', 'original_c': 'new_c'})
print(df)

Saída:

   new_a  new_b  new_c
0      1      4      7
1      2      5      8
2      3      6      9

Renomeando colunas usando um dicionário

Você também pode usar um dicionário para mapear os nomes de colunas antigos para os novos.

# Renomeando colunas usando um dicionário
rename_dict = {'original_a': 'new_a', 'original_b': 'new_b', 'original_c': 'new_c'}
df = df.rename(columns=rename_dict)
print(df)

Saída:

   new_a  new_b  new_c
0      1      4      7
1      2      5      8
2      3      6      9

Renomeando colunas usando uma função

Você também pode usar uma função para transformar os nomes das colunas. A função deve receber o nome da coluna original como entrada e retornar o novo nome da coluna.

# Renomeando colunas usando uma função
def rename_func(column_name):
    if column_name.startswith('original_'):
        return column_name.replace('original_', 'new_')
    else:
        return column_name
 
df = df.rename(columns=rename_func)
print(df)

Saída:

   new_a  new_b  new_c
0      1      4      7
1      2      5      8
2      3      6      9

Lidando com a diferença de maiúsculas e minúsculas nos nomes das colunas

Por padrão, o método rename() é sensível a maiúsculas e minúsculas. Se você quiser realizar a renomeação de forma insensível a maiúsculas e minúsculas, você pode converter os nomes das colunas para um formato específico.

Renomeando colunas no Pandas

Tratando a diferença de maiúsculas e minúsculas nos nomes das colunas

# Tratando a diferença de maiúsculas e minúsculas nos nomes das colunas
df = pd.DataFrame({'OriginalA': [1, 2, 3], 'OriginalB': [4, 5, 6], 'OriginalC': [7, 8, 9]})
df = df.rename(columns={c.lower(): f'new_{c.lower()}' for c in df.columns})
print(df)

Saída:

   new_originala  new_originalb  new_originalc
0             1              4              7
1             2              5              8
2             3              6              9

Tratando colunas com nomes duplicados

Se seu DataFrame tiver colunas com nomes duplicados, você pode usar o método rename() para resolver os duplicados.

# Tratando colunas com nomes duplicados
df = pd.DataFrame({'A': [1, 2, 3], 'A': [4, 5, 6], 'B': [7, 8, 9]})
df = df.rename(columns={'A': 'A_1', 'A.1': 'A_2'})
print(df)

Saída:

   A_1  A_2  B
0    1    4  7
1    2    5  8
2    3    6  9

Renomeando índices no Pandas

Renomeando linhas (índice)

Você pode usar o parâmetro index do método rename() para renomear os índices das linhas (índice) de um DataFrame.

# Renomeando linhas (índice)
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, index=['old_index_1', 'old_index_2', 'old_index_3'])
df = df.rename(index={'old_index_1': 'new_index_1', 'old_index_2': 'new_index_2', 'old_index_3': 'new_index_3'})
print(df)

Saída:

            A  B
new_index_1  1  4
new_index_2  2  5
new_index_3  3  6

Renomeando colunas (colunas)

Da mesma forma, você pode usar o parâmetro columns do método rename() para renomear os índices das colunas de um DataFrame.

# Renomeando colunas (colunas)
df = pd.DataFrame({'old_col_a': [1, 2, 3], 'old_col_b': [4, 5, 6]}, index=['row_1', 'row_2', 'row_3'])
df = df.rename(columns={'old_col_a': 'new_col_a', 'old_col_b': 'new_col_b'})
print(df)

Saída:

        new_col_a  new_col_b
row_1          1          4
row_2          2          5
row_3          3          6

Renomeando linhas e colunas simultaneamente

Você pode.

# Renomeando linhas e colunas simultaneamente
df = pd.DataFrame({'old_col_a': [1, 2, 3], 'old_col_b': [4, 5, 6]}, index=['old_row_1', 'old_row_2', 'old_row_3'])
df = df.rename(index={'old_row_1': 'new_row_1', 'old_row_2': 'new_row_2', 'old_row_3': 'new_row_3'},
               columns={'old_col_a': 'new_col_a', 'old_col_b': 'new_col_b'})
print(df)

Saída:

            new_col_a  new_col_b
new_row_1          1          4
new_row_2          2          5
new_row_3          3          6

Lidando com índices hierárquicos (índices multinível)

O método rename() também pode ser usado para renomear índices hierárquicos (índices multinível) em um DataFrame.

# Lidando com índices hierárquicos (índices multinível)
df = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                  index=pd.MultiIndex.from_tuples([('old_level1', 'old_level2'), ('new_level1', 'new_level2'), ('third_level1', 'third_level2')],
                                                 names=['level1', 'level2']),
                  columns=['old_col_a', 'old_col_b', 'old_col_c'])
df = df.rename(index={'old_level1': 'renamed_level1', 'new_level1': 'renamed_level1_2', 'third_level1': 'renamed_level1_3'},
               columns={'old_col_a': 'new_col_a', 'old_col_b': 'new_col_b', 'old_col_c': 'new_col_c'})
print(df)

Saída:

                             new_col_a  new_col_b  new_col_c
level1          level2
renamed_level1  old_level2           1          2          3
renamed_level1_2 new_level2          4          5          6
renamed_level1_3 third_level2        7          8          9

Pandas Rename: Técnicas Avançadas

Renomeação condicional com base em critérios específicos

Você pode usar uma função para realizar a renomeação condicional com base em critérios específicos.

# Renomeação condicional com base em critérios específicos
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7.
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
df = df.rename(columns=lambda x: 'new_' + x if x in ['A', 'B'] else x)
print(df)

Saída:

   new_A  new_B  C
0      1      4  7
1      2      5  8
2      3      6  9

Renomeando usando expressões regulares

Você pode usar expressões regulares para realizar operações de renomeação mais complexas.

# Renomeando usando expressões regulares
import re
 
df = pd.DataFrame({'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'target': [7, 8, 9]})
df = df.rename(columns=lambda x: re.sub(r'feature_(\d+)', r'new_feature_\1', x))
print(df)

Saída:

   new_feature_1  new_feature_2  target
0             1              4       7
1             2              5       8
2             3              6       9

Renomeando com modificação in-place

Por padrão, o método rename() retorna um novo DataFrame com as colunas ou índices renomeados. Se você quiser modificar o DataFrame original in-place, você pode definir o parâmetro inplace como True.

# Renomeando com modificação in-place
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df.rename(columns={'A': 'new_A', 'B': 'new_B'}, inplace=True)
print(df)

Saída:

   new_A  new_B
0      1      4
1      2      5
2      3      6

Listas e Tuplas

Listas e tuplas são duas das estruturas de dados mais comumente usadas em Python. Elas permitem armazenar e manipular coleções de dados.

Listas

Listas são mutáveis, o que significa que você pode adicionar, remover ou modificar elementos na lista depois que ela foi criada. Você pode criar uma lista usando colchetes [] e separar os elementos com vírgulas.

frutas = ['maçã', 'banana', 'cereja']
print(frutas)  # Saída: ['maçã', 'banana', 'cereja']

Você pode acessar elementos individuais em uma lista usando seus índices, que começam em 0.

print(frutas[0])  # Saída: 'maçã'
print(frutas[1])  # Saída: 'banana'
print(frutas[-1])  # Saída: 'cereja' (índice negativo começa do final)

Você também pode modificar elementos em uma lista:

frutas[1] = 'laranja'
print(frutas)  # Saída: ['maçã', 'laranja', 'cereja']

As listas suportam uma variedade de métodos embutidos, como `ap.

fruits.append('uva')
print(fruits)  # Saída: ['maçã', 'laranja', 'cereja', 'uva']
 
fruits.insert(1, 'pêra')
print(fruits)  # Saída: ['maçã', 'pêra', 'laranja', 'cereja', 'uva']
 
fruits.remove('laranja')
print(fruits)  # Saída: ['maçã', 'pêra', 'cereja', 'uva']
 
fruits.sort()
print(fruits)  # Saída: ['maçã', 'cereja', 'pêra', 'uva']

Tuplas

Tuplas são semelhantes a listas, mas são imutáveis, o que significa que você não pode modificar seus elementos após a criação. Você pode criar uma tupla usando parênteses () e separar os elementos com vírgulas.

point = (3, 4)
print(point)  # Saída: (3, 4)

Você pode acessar elementos individuais em uma tupla usando seus índices, assim como com listas.

print(point[0])  # Saída: 3
print(point[1])  # Saída: 4

No entanto, você não pode modificar os elementos em uma tupla:

point[0] = 5  # TypeError: 'tuple' object does not support item assignment

Tuplas são úteis quando você deseja garantir que a estrutura de dados permaneça inalterada, como ao trabalhar com coordenadas ou outros tipos de dados que não devem ser modificados.

Instruções Condicionais

Instruções condicionais permitem que você execute diferentes blocos de código com base em certas condições. A instrução condicional mais comum em Python é a instrução if-elif-else.

age = 25
if age < 18:
    print("Você é menor de idade.")
elif age < 65:
    print("Você é adulto.")
else:
    print("Você é idoso.")

Neste exemplo, o programa verifica o valor da variável age e executa o bloco de código correspondente com base na condição.

Você também pode usar operadores lógicos, como and, or e not, para combinar várias condições.

temperature = 35
humidity = 80
if temperature > 30 and humidity > 70:
    print("Está quente e úmido lá fora.")
else:
    print("O clima está confortável.")

O Python também suporta o operador ternário, que permite .

is_student = True
discount = 50 if is_student else 0
print(f"Seu desconto é de {discount}%.")  # Saída: Seu desconto é de 50%.

Neste exemplo, o valor de discount é definido como 50 se is_student for True, e 0 caso contrário.

Loops

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

Loops For

Um loop for é usado 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 seguinte saída:

maçã
banana
cereja

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

for i in range(5):
    print(i)  # Saída: 0 1 2 3 4

Loops While

Um loop while é usado para executar um bloco de código enquanto uma determinada condição for verdadeira.

count = 0
while count < 3:
    print(f"Iteração {count + 1}")
    count += 1

Isso irá gerar a seguinte saída:

Iteração 1
Iteração 2
Iteração 3

Você também pode usar as instruções break e continue para controlar o fluxo de um loop.

numeros = [1, 2, 3, 4, 5]
for num in numeros:
    if num == 3:
        break
    print(num)  # Saída: 1 2

Neste exemplo, o loop para quando chega ao número 3 devido à instrução break.

numeros = [1, 2, 3, 4, 5]
for num in numeros:
    if num % 2 == 0:
        continue
    print(num)  # Saída: 1 3 5

Neste exemplo, o loop pula os números pares devido à instrução continue.

Funções

Funções em Python são blocos de código reutilizáveis que executam uma tarefa específica. Você pode definir uma função usando a palavra-chave def.

def saudar(nome):
    print(f"Olá, {nome}!")
 
saudar("Alice")  # Saída: Olá, Alice!

As funções também podem receber parâmetros e retornar valores.

def somar_numeros(a, b):
    return a + b
 
resultado = somar_numeros(2, 3)  # resultado = 5

rs(3, 4) print(result) # Saída: 7


Você também pode definir valores padrão para os parâmetros de função.

```python
def saudar(nome, mensagem="Olá"):
    print(f"{mensagem}, {nome}!")

saudar("Alice")  # Saída: Olá, Alice!
saudar("Bob", "Oi")  # Saída: Oi, Bob!

As funções também podem ser aninhadas, e você pode definir funções que recebem outras funções como argumentos (funções de ordem superior).

def aplicar_duas_vezes(func, arg):
    return func(func(arg))
 
def quadrado(x):
    return x * x
 
resultado = aplicar_duas_vezes(quadrado, 3)
print(resultado)  # Saída: 81

Neste exemplo, a função aplicar_duas_vezes() recebe uma função func e um argumento arg, e aplica a função duas vezes ao argumento.

Módulos e Pacotes

No Python, você pode organizar seu código em módulos e pacotes para torná-lo mais modular e reutilizável.

Módulos

Um módulo é um arquivo contendo definições e instruções Python. Você pode importar um módulo usando a instrução import.

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

Você também pode importar funções ou variáveis específicas de um módulo.

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

Pacotes

Um pacote é uma coleção de módulos organizados em uma estrutura de diretórios. Você pode criar seus próprios pacotes para agrupar módulos relacionados.

Suponha que você tenha a seguinte estrutura de diretórios:

meu_pacote/
    __init__.py
    math_utils.py
    string_utils.py

No arquivo math_utils.py, você pode definir uma função:

def quadrado(x):
    return x * x

Para usar essa função, você pode importá-la do pacote:

from meu_pacote.math_utils import quadrado
print(quadrado(5))  # Saída: 25

O arquivo __init__.py é usado para especificar o conteúdo do pacote e também pode conter código de inicialização.

Conclusão

Neste tutorial, você aprendeu sobre vários conceitos do Python, incluindo listas, tuplas, instruções condicionais, loops, funções e módulos/pacotes. Esses são fundamen. Esses são os blocos de construção fundamentais da linguagem Python e ajudarão você a escrever um código mais eficiente e organizado.

Lembre-se, a melhor maneira de melhorar suas habilidades em Python é praticar, experimentar e explorar o vasto ecossistema de bibliotecas e ferramentas Python. Continue aprendendo e feliz codificação!

MoeNagy Dev.