Python
Reordenar Columnas de Pandas sin Esfuerzo: Guía para Principiantes

Reordenar Columnas de Pandas sin Esfuerzo: Guía para Principiantes

MoeNagy Dev

Importancia de Reordenar Columnas en Pandas

Reordenar columnas en DataFrames de Pandas es una habilidad esencial para analistas de datos e investigadores. Puede mejorar el análisis y visualización de datos, mejorar la legibilidad y organización de conjuntos de datos, y alinear los datos para casos de uso específicos.

Al reorganizar el orden de las columnas, puedes:

  • Mejorar el análisis y visualización de datos agrupando columnas relacionadas, lo que facilita la comprensión e interpretación de los datos.
  • Mejorar la legibilidad y organización de tus conjuntos de datos, lo que facilita la navegación y comprensión de la estructura de los datos.
  • Alinear los datos para casos de uso específicos, como preparar datos para modelos de aprendizaje automático o crear informes personalizados.

Entendiendo el Orden de Columnas en DataFrames de Pandas

En Pandas, el orden de las columnas en un DataFrame está determinado por el orden en que se crean o se agregan las columnas al DataFrame. Cuando creas un nuevo DataFrame, las columnas suelen ordenarse en el mismo orden en que se proporcionaron durante el proceso de creación.

Puedes acceder al orden de las columnas de un DataFrame utilizando el atributo columns:

import pandas as pd
 
# Crear un DataFrame de ejemplo
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Mostrar el orden de las columnas
print(df.columns)
# Salida: Index(['A', 'B', 'C'], dtype='object')

Reordenar Columnas Usando Métodos Integrados

Pandas proporciona varios métodos integrados para reordenar columnas en un DataFrame.

df.reindex(columns=new_order)

El método reindex() te permite reordenar las columnas especificando un nuevo orden en el parámetro columns. Este método conserva los tipos de datos originales de las columnas.

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

Si especificas una columna que no existe en el DataFrame original, reindex() agregará una nueva columna con valores NaN.

df[new_order]

También puedes reordenar las columnas seleccionándolas en el orden deseado utilizando los nombres de columna entre corchetes cuadrados.

# Reordenar las columnas
new_order = ['C', 'A', 'B']
df_reordenado = df[new_order]
print(df_reordenado)
#    C  A  B
# 0  7  1  4
# 1  8  2  5
# 2  9  3  6

Este método es más conciso que usar reindex(), pero no maneja columnas faltantes en el nuevo orden.

Técnicas Avanzadas de Reordenamiento

Reordenar basado en nombres de columna

Puedes reordenar columnas basándote en sus nombres, ya sea en orden alfabético o en un orden específico definido por una lista.

# Reordenar columnas en orden alfabético
df_alfabetico = df[sorted(df.columns)]
print(df_alfabetico)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9
 
# Reordenar columnas en un orden específico
orden_especifico = ['B', 'C', 'A']
df_orden_especifico = df[orden_especifico]
print(df_orden_especifico)
#    B  C  A
# 0  4  7  1
# 1  5  8  2
# 2  6  9  3

Reordenar basado en tipos de datos de columna

Puedes agrupar columnas por sus tipos de datos y reordenar el orden de los tipos de datos.

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

En este ejemplo, las columnas se ordenan primero por sus tipos de datos, y luego por sus nombres (como criterio de ordenación secundario).

Reordenar basado en estadísticas de columna

Puedes reordenar columnas basándote en estadísticas específicas, como los valores mínimos, máximos o medios de las columnas.

# Reordenar columnas por valor mínimo
df_por_minimo = df.reindex(df.min().sort_values().index, axis=1)
print(df_por_minimo)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9

En este ejemplo, las columnas se reordenan según el valor mínimo de cada columna, según lo determinado por df.min().sort_values().index.

Reordenamiento Condicional de Columnas

Puedes reordenar columnas basándote en condiciones específicas, como seleccionar columnas que coincidan con un patrón o excluir columnas que cumplan ciertos criterios.

# Reordenar columnas que contengan la letra 'A'
df_con_A = df[df.columns[df.columns.str.contains('A')]]
print(df_con_A)
#    A
# 0  1
# 1  2
# 2  3
 
# Reordenar columnas excluyendo aquellas que contengan la letra 'A'
df_sin_A = df[df.columns[~df.columns.str.contains('A')]]
print(df_sin_A)
#    B  C
# 0  4  7
# 1  5  8
# 2  6  9

Puedes combinar el reordenamiento condicional con los métodos de reordenamiento integrados, como reindex() o la selección de columnas con corchetes cuadrados.

Preservar el Orden Original de Columnas

Si necesitas restablecer el orden de las columnas al estado inicial, puedes usar el método reindex() con el orden de columna original.

# Restablecer el orden de las columnas al estado original
df_orden_original = df.reindex(df.columns, axis=1)
print(df_orden_original)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9

Esto asegura que el orden de las columnas se restaure al estado inicial, incluso si el orden se modificó durante el flujo de trabajo de procesamiento de datos.

Reordenar Columnas en Columnas de Múltiples Niveles

Pandas también admite estructuras de columnas de múltiples niveles, donde cada columna tiene un encabezado jerárquico. Puedes aplicar las técnicas de reordenamiento discutidas anteriormente a niveles individuales de la estructura de columnas de múltiples niveles.

# Crear un DataFrame con columnas de múltiples niveles
df_multinivel = pd.DataFrame({
    ('nivel1', 'A'): [1, 2, 3],
    ('nivel1', 'B'): [4, 5, 6],
    ('nivel2', 'C'): [7, 8, 9]
})
 
# Reordenar las columnas por el primer nivel
df_reordenado_multinivel = df_multinivel[sorted(df_multinivel.columns.get_level_values(0))]
print(df_reordenado_multinivel)
#    (nivel1, A)  (nivel1, B)  (nivel2, C)
# 0           1           4            7
# 1           2           5            8
# 2           3           6            9

En este ejemplo, las columnas se reordenan en función del primer nivel de la estructura de columnas multinivel.

Declaraciones condicionales

Las declaraciones condicionales en Python te permiten ejecutar diferentes bloques de código en función de ciertas condiciones. Las declaraciones condicionales más comunes son if, elif y else.

edad = 25
if edad >= 18:
    print("Eres un adulto.")
else:
    print("Eres un menor.")

En este ejemplo, si la variable edad es mayor o igual a 18, se ejecutará el bloque de código bajo la declaración if. De lo contrario, se ejecutará el bloque de código bajo la declaración else.

También puedes utilizar la declaración elif para comprobar múltiples condiciones:

puntaje = 85
if puntaje >= 90:
    print("Obtuviste una A.")
elif puntaje >= 80:
    print("Obtuviste una B.")
elif puntaje >= 70:
    print("Obtuviste una C.")
else:
    print("Has fallado.")

Bucles

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

Bucles for

Los bucles for se utilizan para iterar sobre una secuencia (como una lista, tupla o cadena).

frutas = ["manzana", "plátano", "cereza"]
for fruta in frutas:
    print(fruta)

Esto dará como resultado:

manzana
plátano
cereza

También puedes utilizar la función range() para crear una secuencia de números para iterar:

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

Esto dará como resultado:

0
1
2
3
4

Bucles while

Los bucles while se utilizan para ejecutar un bloque de código siempre que se cumpla una determinada condición.

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

Esto dará como resultado:

0
1
2
3
4

Funciones

Las funciones en Python son bloques de código reutilizable que realizan una tarea específica. Pueden recibir argumentos y devolver valores.

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

Esto dará como resultado:

Hola, Alice!
Hola, Bob!

También puedes definir funciones con argumentos predeterminados y argumentos de longitud variable:

def calcular_area(largo, ancho, altura=None):
    if altura:
        return largo * ancho * altura
    else:
        return largo * ancho
 
print(calcular_area(5, 3))       # Resultado: 15
print(calcular_area(4, 2, 6))    # Resultado: 48

Módulos y paquetes

La biblioteca estándar de Python proporciona una amplia gama de módulos integrados, y también puedes crear tus propios módulos y paquetes.

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

También puedes importar funciones o atributos específicos de un módulo:

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

Los paquetes son colecciones de módulos, y ayudan a organizar tu código en una estructura jerárquica.

mi_paquete/
    __init__.py
    modulo1.py
    modulo2.py
    subpaquete/
        __init__.py
        modulo3.py

Manejo de excepciones

Los mecanismos de manejo de excepciones de Python te permiten manejar errores y situaciones inesperadas en tu código.

try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("Error: División por cero.")

También puedes utilizar bloques except para manejar múltiples tipos de excepciones e incluir un bloque else y finally opcional.

try:
    num = int(input("Ingrese un número: "))
    print(10 / num)
except ValueError:
    print("Error: Entrada inválida. Por favor, ingrese un número.")
except ZeroDivisionError:
    print("Error: División por cero.")
else:
    print("La operación fue exitosa.")
finally:
    print("Este bloque se ejecutará siempre.")

Entrada/Salida de archivos

Python proporciona funciones integradas para leer y escribir en archivos.

# Escribir en un archivo
with open("ejemplo.txt", "w") as archivo:
    archivo.write("¡Hola, mundo!")
 
# Leer desde un archivo
with open("ejemplo.txt", "r") as archivo:
    contenido = archivo.read()
    print(contenido)  # Resultado: ¡Hola, mundo!

La declaración with asegura que el archivo se cierre correctamente después de que se completen las operaciones.

Programación orientada a objetos (POO)

Python admite la programación orientada a objetos, lo que te permite crear clases y objetos personalizados.

class Carro:
    def __init__(self, marca, modelo, año):
        self.marca = marca
        self.modelo = modelo
        self.año = año
 
    def iniciar(self):
        print(f"El {self.año} {self.marca} {self.modelo} está arrancando.")
 
mi_carro = Carro("Toyota", "Camry", 2020)
mi_carro.iniciar()  # Resultado: El 2020 Toyota Camry está arrancando.

En este ejemplo, definimos una clase Carro con un método __init__ para inicializar los atributos del objeto, y un método iniciar para realizar una acción.

Conclusión

En este tutorial, hemos cubierto una amplia gama de conceptos de Python, incluyendo declaraciones condicionales, bucles, funciones, módulos y paquetes, manejo de excepciones, entrada/salida de archivos y programación orientada a objetos. Estos temas son esenciales para construir aplicaciones Python robustas y eficientes. Recuerda practicar y experimentar con los ejemplos de código proporcionados para afianzar tu comprensión de estos conceptos. ¡Feliz programación!

MoeNagy Dev