Python
Pandas Rename

Pandas Rename: Una guía para principiantes sobre el cambio de nombre sin esfuerzo

MoeNagy Dev

Pandas Rename: Comprendiendo los conceptos básicos

Introducción al método pandas.DataFrame.rename()

El método pandas.DataFrame.rename() es una herramienta poderosa para cambiar el nombre de las columnas e índices (filas y columnas) de un DataFrame de Pandas. Este método te permite modificar los nombres de tus datos de manera flexible y eficiente, lo que facilita el trabajo y la comprensión de tus datos.

Cambiar el nombre de las columnas

Para cambiar el nombre de las columnas en un DataFrame, puedes utilizar el parámetro columns del método rename(). Puedes pasar un diccionario o una función para especificar los nuevos nombres de las columnas.

import pandas as pd
 
# Crear un DataFrame de ejemplo
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Cambiar el nombre de las columnas por nombre
df = df.rename(columns={'A': 'alfa', 'B': 'beta', 'C': 'gamma'})
print(df)

Resultado:

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

Cambiar el nombre de los índices (filas y columnas)

El método rename() también se puede utilizar para cambiar el nombre de los índices de las filas (index) y los índices de las columnas de un DataFrame. Puedes utilizar el parámetro index para cambiar el nombre de las filas y el parámetro columns para cambiar el nombre de las columnas.

# Cambiar el nombre de las filas y las columnas
df = df.rename(index={0: 'uno', 1: 'dos', 2: 'tres'}, columns={'alfa': 'A', 'beta': 'B', 'gamma': 'C'})
print(df)

Resultado:

       A  B  C
uno    1  4  7
dos    2  5  8
tres   3  6  9

Manejo de cambios de nombre múltiples simultáneamente

También puedes realizar cambios de nombre múltiples a la vez pasando un diccionario o una función al método rename().

# Cambiar múltiples columnas e índices a la vez
df = df.rename(index={'uno': 'primero', 'dos': 'segundo', 'tres': 'tercero'},
               columns={'A': 'X', 'B': 'Y', 'C': 'Z'})
print(df)

Resultado:

        X  Y  Z
primero  1  4  7
segundo  2  5  8
tercero  3  6  9

Pandas Rename: Cambio de nombre de columnas

Cambiar el nombre de las columnas por nombre

Puedes cambiar el nombre de las columnas especificando directamente los nombres antiguos y nuevos de las columnas en el parámetro columns del método rename().

# Cambiar el nombre de las columnas por nombre
df = pd.DataFrame({'original_a': [1, 2, 3], 'original_b': [4, 5, 6], 'original_c': [7, 8, 9]})
df = df.rename(columns={'original_a': 'nueva_a', 'original_b': 'nueva_b', 'original_c': 'nueva_c'})
print(df)

Resultado:

   nueva_a  nueva_b  nueva_c
0        1        4        7
1        2        5        8
2        3        6        9

Cambiar el nombre de las columnas utilizando un diccionario

También puedes utilizar un diccionario para mapear los nombres antiguos de las columnas a los nuevos nombres de las columnas.

# Cambiar el nombre de las columnas utilizando un diccionario
diccionario_cambio = {'original_a': 'nueva_a', 'original_b': 'nueva_b', 'original_c': 'nueva_c'}
df = df.rename(columns=diccionario_cambio)
print(df)

Resultado:

   nueva_a  nueva_b  nueva_c
0        1        4        7
1        2        5        8
2        3        6        9

Cambiar el nombre de las columnas utilizando una función

También puedes utilizar una función para transformar los nombres de las columnas. La función debe tomar el nombre de columna original como entrada y devolver el nuevo nombre de columna.

# Cambiar el nombre de las columnas utilizando una función
def funcion_cambio(nombre_columna):
    if nombre_columna.startswith('original_'):
        return nombre_columna.replace('original_', 'nuevo_')
    else:
        return nombre_columna
 
df = df.rename(columns=funcion_cambio)
print(df)

Resultado:

   nueva_a  nueva_b  nueva_c
0        1        4        7
1        2        5        8
2        3        6        9

Manejo de la sensibilidad a mayúsculas y minúsculas en los nombres de las columnas

De forma predeterminada, el método rename() distingue entre mayúsculas y minúsculas. Si deseas realizar cambios de nombre insensibles a mayúsculas y minúsculas, puedes convertir los nombres de las columnas a un caso específico antes de utilizar el método rename().

# Manejo de la sensibilidad a mayúsculas y minúsculas en los nombres de las columnas
df = pd.DataFrame({'OriginalA': [1, 2, 3], 'OriginalB': [4, 5, 6], 'OriginalC': [7, 8, 9]})
df = df.rename(columns={c.lower(): f'nuevo_{c.lower()}' for c in df.columns})
print(df)

Resultado:

   nuevo_originala  nuevo_originalb  nuevo_originalc
0                1                4                7
1                2                5                8
2                3                6                9

Manejo de columnas con nombres duplicados

Si tu DataFrame tiene columnas con nombres duplicados, puedes utilizar el método rename() para resolver los duplicados.

# Manejo de columnas con nombres 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)

Resultado:

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

Pandas Rename: Cambio de nombre de índices

Cambiar el nombre de las filas (índice)

Puedes utilizar el parámetro index del método rename() para cambiar el nombre de los índices de las filas (index) de un DataFrame.

# Cambiar el nombre de las filas (índice)
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, index=['antiguo_indice_1', 'antiguo_indice_2', 'antiguo_indice_3'])
df = df.rename(index={'antiguo_indice_1': 'nuevo_indice_1', 'antiguo_indice_2': 'nuevo_indice_2', 'antiguo_indice_3': 'nuevo_indice_3'})
print(df)

Resultado:

                 A  B
nuevo_indice_1  1  4
nuevo_indice_2  2  5
nuevo_indice_3  3  6

Cambiar el nombre de las columnas (columnas)

De manera similar, puedes utilizar el parámetro columns del método rename() para cambiar el nombre de los índices de las columnas de un DataFrame.

# Cambiar el nombre de las columnas (columnas)
df = pd.DataFrame({'antigua_col_a': [1, 2, 3], 'antigua_col_b': [4, 5, 6]}, index=['fila_1', 'fila_2', 'fila_3'])
df = df.rename(columns={'antigua_col_a': 'nueva_col_a', 'antigua_col_b': 'nueva_col_b'})
print(df)

Resultado:

           nueva_col_a  nueva_col_b
fila_1               1            4
fila_2               2            5
fila_3               3            6

Cambiar tanto las filas como las columnas simultáneamente

You can also use the rename() method to rename both the row and column indices at the same time.

# Renombrar filas y columnas simultáneamente
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)

Salida:

            new_col_a  new_col_b
new_row_1          1          4
new_row_2          2          5
new_row_3          3          6

Manejo de índices jerárquicos (índices de varios niveles)

El método rename() también se puede utilizar para renombrar índices jerárquicos (índices de varios niveles) en un DataFrame.

# Manejo de índices jerárquicos (índices de varios niveles)
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)

Salida:

                             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 avanzadas

Renombramiento condicional basado en criterios específicos

Puede utilizar una función para realizar un renombramiento condicional basado en criterios específicos.

# Renombramiento condicional basado en criterios específicos
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)

Salida:

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

Renombramiento utilizando expresiones regulares

Puede utilizar expresiones regulares para realizar operaciones de renombramiento más complejas.

# Renombramiento utilizando expresiones 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)

Salida:

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

Renombramiento con modificación inplace

De forma predeterminada, el método rename() devuelve un nuevo DataFrame con las columnas o índices renombrados. Si desea modificar el DataFrame original inplace, puede establecer el parámetro inplace en True.

# Renombramiento con modificación inplace
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df.rename(columns={'A': 'nuevo_A', 'B': 'nuevo_B'}, inplace=True)
print(df)

Salida:

   nuevo_A  nuevo_B
0        1        4
1        2        5
2        3        6

Listas y Tuplas

Las listas y las tuplas son dos de las estructuras de datos más comúnmente utilizadas en Python. Te permiten almacenar y manipular colecciones de datos.

Listas

Las listas son mutables, lo que significa que puedes agregar, eliminar o modificar elementos en la lista después de haber sido creada. Puedes crear una lista usando corchetes [] y separar los elementos con comas.

frutas = ['manzana', 'plátano', 'cereza']
print(frutas)  # Salida: ['manzana', 'plátano', 'cereza']

Puedes acceder a elementos individuales en una lista utilizando su índice, que comienza desde 0.

print(frutas[0])  # Salida: 'manzana'
print(frutas[1])  # Salida: 'plátano'
print(frutas[-1])  # Salida: 'cereza' (índice negativo comienza desde el final)

También puedes modificar elementos en una lista:

frutas[1] = 'naranja'
print(frutas)  # Salida: ['manzana', 'naranja', 'cereza']

Las listas admiten una variedad de métodos integrados, como append(), insert(), remove() y sort().

frutas.append('uva')
print(frutas)  # Salida: ['manzana', 'naranja', 'cereza', 'uva']
 
frutas.insert(1, 'pera')
print(frutas)  # Salida: ['manzana', 'pera', 'naranja', 'cereza', 'uva']
 
frutas.remove('naranja')
print(frutas)  # Salida: ['manzana', 'pera', 'cereza', 'uva']
 
frutas.sort()
print(frutas)  # Salida: ['cereza', 'manzana', 'pera', 'uva']

Tuplas

Las tuplas son similares a las listas, pero son inmutables, lo que significa que no puedes modificar sus elementos después de haber sido creada. Puedes crear una tupla utilizando paréntesis () y separar los elementos con comas.

punto = (3, 4)
print(punto)  # Salida: (3, 4)

Puedes acceder a elementos individuales en una tupla utilizando su índice, al igual que con las listas.

print(punto[0])  # Salida: 3
print(punto[1])  # Salida: 4

Sin embargo, no puedes modificar los elementos en una tupla:

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

Las tuplas son útiles cuando quieres asegurarte de que la estructura de datos permanezca sin cambios, como al trabajar con coordenadas u otros tipos de datos que no deben modificarse.

Declaraciones Condicionales

Las declaraciones condicionales te permiten ejecutar diferentes bloques de código basados en ciertas condiciones. La declaración condicional más común en Python es la declaración if-elif-else.

edad = 25
if edad < 18:
    print("Eres menor de edad.")
elif edad < 65:
    print("Eres adulto.")
else:
    print("Eres adulto mayor.")

En este ejemplo, el programa verifica el valor de la variable edad y ejecuta el bloque de código correspondiente en función de la condición.

También puedes usar operadores lógicos, como and, or y not, para combinar múltiples condiciones.

temperatura = 35
humedad = 80
if temperatura > 30 and humedad > 70:
    print("Hace calor y hay humedad.")
else:
    print("El clima es cómodo.")

Python también admite el operador ternario, que te permite escribir una declaración if-else simple en una sola línea.

is_student = True
discount = 50 if is_student else 0
print(f"Tu descuento es de {discount}%.")  # Salida: Tu descuento es de 50%.

En este ejemplo, el valor de discount se establece en 50 si is_student es True, y 0 en caso contrario.

Bucles

En Python, los bucles te permiten ejecutar repetidamente un bloque de código. Los dos tipos más comunes de bucles son los bucles for y los bucles while.

Bucles for

Un bucle for se utiliza para iterar sobre una secuencia, como una lista, una tupla o una cadena.

fruits = ['manzana', 'plátano', 'cereza']
for fruit in fruits:
    print(fruit)

Esto producirá la siguiente salida:

manzana
plátano
cereza

También puedes usar la función range() para crear una secuencia de números e iterar sobre ellos.

for i in range(5):
    print(i)  # Salida: 0 1 2 3 4

Bucles while

Un bucle while se utiliza para ejecutar un bloque de código mientras se cumpla una determinada condición.

count = 0
while count < 3:
    print(f"Iteración {count + 1}")
    count += 1

Esto producirá la siguiente salida:

Iteración 1
Iteración 2
Iteración 3

También puedes usar las instrucciones break y continue para controlar el flujo de un bucle.

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        break
    print(num)  # Salida: 1 2

En este ejemplo, el bucle se detiene cuando alcanza el número 3 debido a la instrucción break.

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        continue
    print(num)  # Salida: 1 3 5

En este ejemplo, el bucle omite los números pares debido a la instrucción continue.

Funciones

Las funciones en Python son bloques de código reutilizable que realizan una tarea específica. Puedes definir una función usando la palabra clave def.

def saludar(nombre):
    print(f"Hola, {nombre}!")
 
saludar("Alice")  # Salida: ¡Hola, Alice!

Las funciones también pueden recibir parámetros y devolver valores.

def sumar_numeros(a, b):
    return a + b
 
resultado = sumar_numeros(3, 4)
print(resultado)  # Salida: 7

También puedes definir valores predeterminados para los parámetros de una función.

def saludar(nombre, mensaje="Hola"):
    print(f"{mensaje}, {nombre}!")
 
saludar("Alice")  # Salida: ¡Hola, Alice!
saludar("Bob", "Hola")  # Salida: ¡Hola, Bob!

Las funciones también pueden estar anidadas, y puedes definir funciones que tomen otras funciones como argumentos (funciones de orden superior).

def aplicar_dos_veces(func, arg):
    return func(func(arg))
 
def cuadrado(x):
    return x * x
 
resultado = aplicar_dos_veces(cuadrado, 3)
print(resultado)  # Salida: 81

En este ejemplo, la función aplicar_dos_veces() toma una función func y un argumento arg, y aplica la función dos veces al argumento.

Módulos y paquetes

En Python, puedes organizar tu código en módulos y paquetes para hacerlo más modular y reutilizable.

Módulos

Un módulo es un archivo que contiene definiciones y declaraciones de Python. Puedes importar un módulo utilizando la instrucción import.

import math
print(math.pi)  # Salida: 3.141592653589793

También puedes importar funciones o variables específicas de un módulo.

from math import sqrt
print(sqrt(16))  # Salida: 4.0

Paquetes

Un paquete es una colección de módulos organizados en una estructura de directorios. Puedes crear tus propios paquetes para agrupar módulos relacionados.

Supongamos que tienes la siguiente estructura de directorios:

mi_paquete/
    __init__.py
    utilidades_mate.py
    utilidades_cadena.py

En el archivo utilidades_mate.py, puedes definir una función:

def elevar_al_cuadrado(x):
    return x * x

Para usar esta función, puedes importarla desde el paquete:

from mi_paquete.utilidades_mate import elevar_al_cuadrado
print(elevar_al_cuadrado(5))  # Salida: 25

El archivo __init__.py se utiliza para especificar el contenido del paquete y también puede contener código de inicialización.

Conclusión

En este tutorial, has aprendido sobre varios conceptos de Python, incluyendo listas, tuplas, declaraciones condicionales, bucles, funciones, módulos y paquetes. Estos son bloques de construcción fundamentales del lenguaje Python y te ayudarán a escribir código más eficiente y organizado.

Recuerda, la mejor manera de mejorar tus habilidades en Python es practicar, experimentar y explorar el vasto ecosistema de bibliotecas y herramientas de Python. ¡Sigue aprendiendo y feliz programación!

MoeNagy Dev