Python
Cambiar fácilmente los nombres de las columnas en Pandas: una guía para principiantes

Cambiar fácilmente los nombres de las columnas en Pandas: una guía para principiantes

MoeNagy Dev

Cambiando los nombres de las columnas en Pandas

Descripción general de Pandas DataFrame

Un Pandas DataFrame es una estructura de datos bidimensional y tabular con filas y columnas. Cada columna en un DataFrame puede tener un tipo de datos diferente, y las columnas se pueden acceder y manipular individualmente.

Comprendiendo la estructura de un Pandas DataFrame

import pandas as pd
 
# Crear un DataFrame de ejemplo
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['Nueva York', 'Londres', 'París']}
 
df = pd.DataFrame(data)
print(df)

Salida:

       Name  Age       City
0    Alice   25  Nueva York
1      Bob   30    Londres
2  Charlie   35       París

Acceder y manipular datos de las columnas

Puede acceder a columnas individuales de un DataFrame utilizando el nombre de la columna como un atributo o como una clave entre corchetes:

print(df['Name'])
print(df.Age)

Salida:

0    Alice
1      Bob
2  Charlie
Name: Name, dtype: object
0    25
1    30
2    35
Name: Age, dtype: int64

También puede asignar nuevos valores a una columna:

df['Country'] = ['EE. UU.', 'Reino Unido', 'Francia']
print(df)

Salida:

       Name  Age       City    Country
0    Alice   25  Nueva York   EE. UU.
1      Bob   30    Londres  Reino Unido
2  Charlie   35       París    Francia

Cambiar nombres de columnas

Renombrar columnas en un Pandas DataFrame es una tarea común al trabajar con datos. Hay varias formas de lograr esto.

Usando el método rename()

El método rename() te permite renombrar una o más columnas. Puedes pasar un diccionario o una función al parámetro columns.

# Renombrar una sola columna usando un diccionario
df = df.rename(columns={'Name': 'Nombre completo'})
print(df)

Salida:

       Nombre completo  Age       City    Country
0               Alice   25  Nueva York   EE. UU.
1                 Bob   30    Londres  Reino Unido
2             Charlie   35       París    Francia

Pasar un diccionario a rename()

Puedes pasar un diccionario al parámetro columns, donde las claves son los antiguos nombres de las columnas y los valores son los nuevos nombres de las columnas.

# Renombrar múltiples columnas usando un diccionario
df = df.rename(columns={'Nombre completo': 'Participante', 'Age': 'Edad'})
print(df)

Salida:

       Participante  Edad       City    Country
0            Alice    25  Nueva York   EE. UU.
1              Bob    30    Londres  Reino Unido
2          Charlie    35       París    Francia

Pasar una función a rename()

También puedes pasar una función al parámetro columns, la cual se aplicará a cada nombre de columna.

# Renombrar columnas usando una función
df = df.rename(columns=lambda x: x.lower().replace(' ', '_'))
print(df)

Salida:

       participante  edad       city    country
0            Alice    25  Nueva York   EE. UU.
1              Bob    30    Londres  Reino Unido
2          Charlie    35       París    Francia

Cambiar múltiples columnas a la vez

Puedes renombrar múltiples columnas pasando un diccionario o una lista de tuplas al parámetro columns.

# Renombrar múltiples columnas a la vez
df = df.rename(columns={'participante': 'nombre', 'edad': 'edad'})
print(df)

Salida:

       nombre  edad       city    country
0      Alice    25  Nueva York   EE. UU.
1        Bob    30    Londres  Reino Unido
2    Charlie    35       París    Francia

Modificar los nombres de las columnas directamente

También puedes modificar los nombres de las columnas directamente accediendo al atributo columns del DataFrame.

Acceder y actualizar los nombres de las columnas

# Acceder y actualizar los nombres de las columnas
df.columns = ['Nombre', 'Edad', 'Ubicación', 'Nacionalidad']
print(df)

Salida:

       Nombre  Edad    Ubicación Nacionalidad
0      Alice    25  Nueva York       EE. UU.
1        Bob    30    Londres     Reino Unido
2    Charlie    35       París       Francia

Usar comprensión de listas para renombrar columnas

Puedes usar comprensión de listas para aplicar una transformación a los nombres de las columnas.

# Renombrar columnas usando comprensión de listas
df.columns = [col.upper() for col in df.columns]
print(df)

Salida:

       NOMBRE  EDAD    UBICACIÓN NACIONALIDAD
0      Alice    25  Nueva York       EE. UU.
1        Bob    30    Londres     Reino Unido
2    Charlie    35       París       Francia

Manejo de nombres de columna faltantes o duplicados

Es importante manejar los casos en los que faltan o están duplicados los nombres de las columnas.

Identificar y abordar nombres de columna faltantes

# Crear un DataFrame con un nombre de columna faltante
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)
print(df)

Salida:

       Name  Age
0    Alice   25
1      Bob   30
2  Charlie   35

Para abordar el nombre de columna faltante, puedes usar el método rename() o asignar un nuevo nombre directamente al atributo columns.

# Renombrar la columna faltante
df = df.rename(columns={None: 'Nueva Columna'})
print(df)

Salida:

       Name  Age  Nueva Columna
0    Alice   25           NaN
1      Bob   30           NaN
2  Charlie   35           NaN

Resolver nombres de columna duplicados

# Crear un DataFrame con nombres de columna duplicados
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'Name': [1, 2, 3]}
df = pd.DataFrame(data)
print(df)

Salida:

       Name  Age  Name
0    Alice   25     1
1      Bob   30     2
2  Charlie   35     3

Para resolver los nombres de columna duplicados, puedes usar el método rename() o el método set_axis().

# Resolver nombres de columna duplicados
df = df.rename(columns={'Name_x': 'Name', 'Name_y': 'Name_2'})
print(df)

Salida:

       Name  Age  Name_2
0    Alice   25       1
## Técnicas avanzadas de cambio de nombre de columnas

Pandas proporciona técnicas adicionales para escenarios de cambio de nombre de columnas más avanzados.

### Cambiar el nombre de las columnas en función de un patrón específico

```python
# Cambiar el nombre de las columnas en función de un patrón
data = {'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'target': [10, 20, 30]}
df = pd.DataFrame(data)
df = df.rename(columns=lambda x: x.replace('feature_', 'col_'))
print(df)

Salida:

   col_1  col_2  target
0      1      4      10
1      2      5      20
2      3      6      30

Cambiar el nombre de las columnas utilizando expresiones regulares

# Cambiar el nombre de las columnas utilizando expresiones regulares
data = {'feature1_a': [1, 2, 3], 'feature1_b': [4, 5, 6], 'feature2_a': [7, 8, 9]}
df = pd.DataFrame(data)
df = df.rename(columns=lambda x: re.sub(r'feature(\d+)_(\w+)', r'col_\1_\2', x))
print(df)

Salida:

   col_1_a  col_1_b  col_2_a
0        1        4        7
1        2        5        8
2        3        6        9

Cambiar el nombre de las columnas en un índice de columna multinivel

# Cambiar el nombre de las columnas en un índice de columna multinivel
data = {('group1', 'A'): [1, 2, 3], ('group1', 'B'): [4, 5, 6], ('group2', 'C'): [7, 8, 9]}
df = pd.DataFrame(data)
df.columns = pd.MultiIndex.from_tuples([('Group 1', 'Feature A'), ('Group 1', 'Feature B'), ('Group 2', 'Feature C')])
df = df.rename(columns=lambda x: (x[0].replace('Group', 'G'), x[1]))
print(df)

Salida:

   (G 1, Feature A)  (G 1, Feature B)  (G 2, Feature C)
0                 1                 4                 7
1                 2                 5                 8
2                 3                 6                 9

Cambiar el nombre de las columnas durante la creación del DataFrame

También puedes cambiar el nombre de las columnas al crear un DataFrame de Pandas.

Pasar nombres de columna durante la inicialización del DataFrame

# Cambiar el nombre de las columnas durante la inicialización del DataFrame
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
print(df)

Salida:

   A  B  C
0  1  2  3
1  4  5  6
2  7  8  9

Cambiar el nombre de las columnas al leer datos desde archivos

# Cambiar el nombre de las columnas al leer datos desde un archivo
df = pd.read_csv('data.csv', names=['Name', 'Age', 'City'])
print(df)

Mantener el orden de las columnas después de cambiar el nombre

Al cambiar el nombre de las columnas, es importante considerar el orden de las columnas.

Conservar el orden original de las columnas

# Conservar el orden original de las columnas
df = df[['Name', 'Age', 'City']]
print(df)

Salida:

       Name  Age       City
0    Alice   25  New York
1      Bob   30    London
2  Charlie   35     Paris

Reordenar las columnas después de cambiar el nombre

# Reordenar las columnas después de cambiar el nombre
df = df[['City', 'Name', 'Age']]
print(df)

Salida:

       City       Name  Age
0  New York    Alice   25
1    London      Bob   30
2     Paris  Charlie   35

Aplicar cambio de nombre en varios DataFrames

Cuando trabajas con varios DataFrames relacionados, a menudo es necesario asegurar convenciones de nomenclatura de columnas consistentes.

Cambiar el nombre de las columnas en DataFrames relacionados

# Cambiar el nombre de las columnas en DataFrames relacionados
df1 = pd.DataFrame({'Name': ['Alice', 'Bob'], 'Age': [25, 30]})
df2 = pd.DataFrame({'Name': ['Charlie', 'David'], 'City': ['New York', 'London']})
 
df1 = df1.rename(columns={'Name': 'Participant', 'Age': 'Years Old'})
df2 = df2.rename(columns={'Name': 'Participant', 'City': 'Location'})
 
print(df1)
print(df2)

Salida:

   Participant  Years Old
0       Alice         25
1         Bob         30

   Participant   Location
0     Charlie  New York
1       David    London

Asegurar convenciones de nomenclatura de columnas consistentes

# Asegurar convenciones de nomenclatura de columnas consistentes
df1 = df1.rename(columns={'Participant': 'name', 'Years Old': 'age'})
df2 = df2.rename(columns={'Participant': 'name', 'Location': 'city'})
 
print(df1)
rint(df2)

Salida:

      name  age
0   Alice   25
1     Bob   30

      name     city
0  Charlie  New York
1    David   London

Automatización del flujo de trabajo de cambio de nombre de columnas

Para hacer el cambio de nombre de columnas más eficiente, puedes desarrollar funciones reutilizables e integrarlas en tus flujos de procesamiento de datos.

Bucles y declaraciones condicionales

Los bucles y las declaraciones condicionales son esenciales en Python para controlar el flujo de tu programa y automatizar tareas repetitivas. Veamos algunas estructuras de bucle comunes y declaraciones condicionales.

Bucles for

Los bucles for se utilizan para iterar sobre una secuencia (como una lista, tupla o cadena) u otros objetos iterables. Aquí tienes un ejemplo de un bucle for que itera sobre una lista de números e imprime cada uno:

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

Salida:

1
2
3
4
5

También puedes usar la función range() para crear una secuencia de números sobre los que iterar:

for i in range(1, 6):
    print(i)

Salida:

1
2
3
4
5

Bucles while

Los bucles while se utilizan para ejecutar un bloque de código siempre que se cumpla una determinada condición. Aquí tienes un ejemplo de un bucle while que cuenta hacia atrás desde 5 hasta 1:

count = 5
while count > 0:
    print(count)
    count -= 1
print("¡Despegue!")

Salida:

5
4
3
2
1
¡Despegue!

Declaraciones condicionales

Las declaraciones condicionales, como if-elif-else, te permiten tomar decisiones basadas en ciertas condiciones. Aquí tienes un ejemplo de una declaración if-else simple:

age = 18
if age >= 18:
    print("Eres mayor de edad.")
else:
    print("Eres menor de edad.")

Salida:

Eres mayor de edad.

También puedes usar elif para verificar múltiples condiciones:

score = 85
if score >= 90:
    print("¡Obtuviste una A!")
elif score >= 80:
    print("Obtuviste una B.")
elif score >= 70:
    print("Obtuviste una C.")
else:
    print("Necesitas mejorar.")

Salida:

Obtuviste una B.

Bucles y declaraciones condicionales anidadas

También puedes anidar bucles y declaraciones condicionales dentro de sí mismos para crear una lógica más compleja. Aquí tienes un ejemplo de un bucle for anidado que verifica si un número es primo:

for num in range(2, 21):
    is_prime = True
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        print(f"{num} es un número primo.")
    else:
        print(f"{num} no es un número primo.")

Salida:

2 es un número primo.
3 es un número primo.
4 no es un número primo.
5 es un número primo.
6 no es un número primo.
7 es un número primo.
8 no es un número primo.
9 no es un número primo.
10 no es un número primo.
11 es un número primo.
12 no es un número primo.
13 es un número primo.
14 no es un número primo.
15 no es un número primo.
16 no es un número primo.
17 es un número primo.
18 no es un número primo.
19 es un número primo.
20 no es un número primo.

Funciones

Las funciones son un componente fundamental de Python. Te permiten agrupar código relacionado, lo que hace que tus programas sean más organizados, modulares y reutilizables.

Definición de funciones

Para definir una función en Python, se utiliza la palabra clave def, seguida del nombre de la función, un conjunto de paréntesis y dos puntos. El código que forma el cuerpo de la función se indenta.

Aquí tienes un ejemplo de una función simple que saluda al usuario:

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

Salida:

Hola, Alice!

También puedes definir funciones que tomen varios argumentos:

def sumar_numeros(a, b):
    return a + b
 
resultado = sumar_numeros(5, 3)
print(resultado)

Salida:

8

Argumentos predeterminados y de palabra clave

Las funciones pueden tener argumentos predeterminados, que se utilizan cuando no se proporciona un valor durante la llamada a la función. Aquí tienes un ejemplo:

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

Salida:

Hola, Alice!
Hola, Bob!

También puedes utilizar argumentos de palabra clave para llamar a las funciones, lo que puede hacer que el código sea más legible:

def calcular_area(longitud, ancho):
    return longitud * ancho
 
# Utilizando argumentos de palabra clave
area = calcular_area(longitud=5, ancho=3)
print(area)

Salida:

15

Alcance y tiempo de vida de las variables

El alcance de una variable determina dónde se puede acceder a ella en tu código. Python tiene alcance local y global. Las variables definidas dentro de una función tienen alcance local, mientras que las variables definidas fuera de las funciones tienen alcance global.

Aquí tienes un ejemplo que muestra la diferencia:

variable_global = "¡Soy global!"
 
def mi_funcion():
    variable_local = "Soy local."
    print(variable_global)
    print(variable_local)
 
mi_funcion()
print(variable_global)
# print(variable_local)  # Esto generará un error

Salida:

¡Soy global!
Soy local.
¡Soy global!

Ten en cuenta que variable_local no se puede acceder fuera de la función mi_funcion() porque tiene alcance local.

Funciones recursivas

Las funciones recursivas son funciones que se llaman a sí mismas para resolver un problema. Aquí tienes un ejemplo de una función recursiva que calcula el factorial de un número:

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)
 
print(factorial(5))

Salida:

120

En este ejemplo, la función factorial() se llama a sí misma con un valor menor de n hasta que alcanza el caso base (cuando n es 0 o 1), momento en el que devuelve 1.

Módulos y paquetes

En Python, los módulos y los paquetes se utilizan para organizar y reutilizar código. Los módulos son archivos Python individuales, mientras que los paquetes son colecciones de módulos relacionados.

Importación de módulos

Para utilizar código de un módulo, debes importarlo. Aquí tienes un ejemplo de importación del módulo integrado math:

import math
 
print(math.pi)
print(math.sqrt(16))

Salida:

3.141592653589793
4.0

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

from math import pi, sqrt
 
print(pi)
print(sqrt(16))

Salida:

3.141592653589793
4.0

Creación de módulos

Para crear tu propio módulo, simplemente guarda tu código Python en un archivo con extensión .py. Por ejemplo, creemos un módulo llamado mi_modulo.py con una función llamada saludar():

# mi_modulo.py
def saludar(nombre):
    print(f"Hola, {nombre}!")

Luego, puedes importar y utilizar la función saludar() en otro archivo Python:

# main.py
import mi_modulo
 
mi_modulo.saludar("Alice")

Salida:

Hola, Alice!

Paquetes

Los paquetes se utilizan para organizar módulos relacionados en una estructura jerárquica. Para crear un paquete, debes crear un directorio con un archivo __init__.py. Aquí tienes un ejemplo:

mi_paquete/
    __init__.py
    utilidades_matematicas.py
    utilidades_cadenas.py

El archivo __init__.py puede estar vacío, pero es necesario para que Python reconozca el directorio como un paquete.

Luego, puedes importar funciones de los módulos dentro del paquete:

# main.py
from mi_paquete.utilidades_matematicas import sumar
from mi_paquete.utilidades_cadenas import invertir
 
print(sumar(5, 3))
print(invertir("hola"))

Salida:

8
aloh

Conclusión

En este tutorial, has aprendido sobre los conceptos esenciales de Python, como los bucles, las declaraciones condicionales, las funciones, los módulos y los paquetes. Estas herramientas son fundamentales para construir programas sólidos y dinámicos en Python.

Recuerda que la mejor manera de mejorar tus habilidades en Python es practicar, experimentar y seguir aprendiendo. Explora el vasto ecosistema de bibliotecas y módulos de Python, y no dudes en sumergirte en la documentación oficial de Python para obtener información más detallada.

¡Feliz codificación!

MoeNagy Dev