Data Analysis · Lección 06 de 19

pandas: Transformaciones

Los datos limpios todavía no responden preguntas de negocio. Necesitás transformarlos: crear columnas nuevas, calcular métricas, categorizar clientes, aplicar reglas. Transformar datos es el momento en que dejás de ser un técnico y empezás a generar valor para la empresa.

90–120 min Prerrequisitos: Lección 05 (Limpieza)

Concepto teórico

¿Qué es una transformación?

Una transformación es cualquier operación que toma los datos existentes y produce datos nuevos o modificados. Las operaciones más comunes en el día a día de un analista son:

Crear columnas calculadas: "Ganancia = Ingreso - Costo"
Mapear valores: Convertir 1/2/3 a "Bajo"/"Medio"/"Alto"
Aplicar funciones: Aplicar una función personalizada a cada fila
Operaciones aritméticas vectorizadas: Sumar/restar/multiplicar columnas enteras
Renombrar columnas: Cambiar "Mnt_Brto" a "Monto_Bruto"

Principio clave: las operaciones en pandas son vectorizadas. Esto significa que cuando escribís df["Precio"] * 1.21, pandas aplica el cálculo a TODAS las filas simultáneamente, en una sola operación. No necesitás un bucle for. Esto es miles de veces más rápido y es la razón por la que pandas puede procesar millones de filas en segundos.

Crear columnas nuevas

Crear una columna nueva es tan simple como asignar un valor a un nombre de columna que no existe. Si el nombre ya existe, sobreescribe la columna.

# Columna calculada a partir de otras
df["Ganancia"] = df["Ingreso"] - df["Costo"]

# Columna con valor fijo
df["Moneda"] = "ARS"

# Columna con una operación matemática
df["IVA"] = df["Monto"] * 0.21
df["Total"] = df["Monto"] + df["IVA"]

map() vs apply() vs np.where()

Tres herramientas para transformaciones más complejas:

Método	Qué hace	Trabaja sobre	Uso típico
`.map(dict)`	Reemplaza valores 1-a-1	Serie (una columna)	Codificar categorías: {"M": "Masculino"}
`.apply(func)`	Aplica función a cada elemento/fila	Serie o DataFrame	Lógica personalizada compleja
`np.where(cond, si, no)`	Asigna valor según condición	Serie/array	If/else vectorizado rápido

Analogía: map() es como un diccionario de traducción (buscás la palabra y te da la traducción directa). apply() es como contratar un traductor humano (puede hacer cosas complejas pero es más lento). np.where() es un semáforo: verde pasa, rojo no pasa.

Performance: apply() es la más lenta de las tres porque ejecuta la función fila por fila en Python puro. Siempre intentá usar operaciones vectorizadas (+, *, np.where) antes de recurrir a apply(). En datasets de millones de filas, la diferencia puede ser de segundos vs minutos.

Ejemplos explicados paso a paso

Ejemplo 1: Columnas calculadas — operaciones aritméticas

El caso más directo: crear nuevas columnas a partir de operaciones matemáticas entre columnas existentes.

ejemplo_01_columnas_calc.pyPython

import pandas as pd

df = pd.DataFrame({
    "Producto": ["Notebook", "Mouse", "Monitor", "Teclado", "Auriculares"],
    "Precio_Base": [450000, 15000, 180000, 25000, 35000],
    "Cantidad": [3, 50, 10, 30, 20]
})

# Columnas calculadas
df["IVA"] = df["Precio_Base"] * 0.21
df["Precio_Final"] = df["Precio_Base"] + df["IVA"]
df["Subtotal"] = df["Precio_Final"] * df["Cantidad"]

print("=== Tabla con columnas calculadas ===")
print(df)

# Estadísticas sobre las nuevas columnas
print(f"\nIngreso total estimado: ${df['Subtotal'].sum():,.0f}")
print(f"Ticket promedio: ${df['Precio_Final'].mean():,.0f}")
print(f"Producto más caro (con IVA): {df.loc[df['Precio_Final'].idxmax(), 'Producto']}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: map() — Traducir códigos a nombres legibles

Los sistemas internos guardan datos codificados ("A", "B", "C"). Para el reporte final necesitás nombres legibles. map() es perfecto para esto.

ejemplo_02_map.pyPython

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Pérez", "Sosa", "Luna"],
    "Segmento_Cod": ["A", "C", "B", "A", "C"],
    "Canal_Cod": [1, 2, 1, 3, 2]
})

# map() con diccionario: código → nombre legible
df["Segmento"] = df["Segmento_Cod"].map({
    "A": "Premium",
    "B": "Estándar",
    "C": "Básico"
})

df["Canal"] = df["Canal_Cod"].map({
    1: "Sucursal",
    2: "App Mobile",
    3: "Web"
})

print("=== Datos decodificados ===")
print(df[["Cliente", "Segmento", "Canal"]])

# Conteo por segmento
print("\n=== Distribución por segmento ===")
print(df["Segmento"].value_counts())

Hacé clic en ▶ Ejecutar

Ejemplo 3: np.where() — If/else vectorizado

Cuando necesitás clasificar con una condición simple (True/False), np.where() es más rápido y limpio que apply().

ejemplo_03_npwhere.pyPython

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "Cliente": ["García", "López", "Pérez", "Sosa", "Luna"],
    "Saldo": [850000, 320000, 95000, 670000, 1200000],
    "Meses_Inactivo": [0, 3, 8, 1, 0]
})

# np.where: condición → valor_si_true → valor_si_false
df["Nivel"] = np.where(df["Saldo"] >= 500000, "Alto", "Bajo")

# Combinando condiciones
df["Estado"] = np.where(
    df["Meses_Inactivo"] <= 2,
    "🟢 Activo",
    "🔴 En riesgo"
)

# np.where anidado (como if/elif/else)
df["Prioridad"] = np.where(
    df["Saldo"] >= 1000000, "VIP",
    np.where(df["Saldo"] >= 500000, "Alta", "Normal")
)

print("=== Clasificaciones ===")
print(df)
print(f"\nClientes VIP: {(df['Prioridad'] == 'VIP').sum()}")
print(f"Clientes en riesgo: {(df['Estado'].str.contains('riesgo')).sum()}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: apply() — Lógica personalizada

Cuando la lógica es demasiado compleja para np.where(), definís una función Python y la aplicás a cada fila con apply().

ejemplo_04_apply.pyPython

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Pérez", "Sosa", "Luna"],
    "Ingreso": [450000, 180000, 95000, 320000, 800000],
    "Cuota": [85000, 62000, 45000, 50000, 120000],
    "Score": [720, 580, 490, 650, 810]
})

# Función personalizada de scoring
def evaluar_credito(fila):
    ratio = fila["Cuota"] / fila["Ingreso"] * 100
    if fila["Score"] < 500:
        return "❌ Rechazado (score bajo)"
    elif ratio > 35:
        return f"❌ Rechazado (ratio {ratio:.0f}%)"
    elif fila["Score"] >= 750 and ratio <= 20:
        return "✅ Aprobado Premium"
    elif fila["Score"] >= 600:
        return "✅ Aprobado Estándar"
    else:
        return "⚠️ Revisión manual"

# apply con axis=1 → aplica la función a cada FILA
df["Decision"] = df.apply(evaluar_credito, axis=1)

# Calculamos el ratio para mostrar
df["Ratio_%"] = round(df["Cuota"] / df["Ingreso"] * 100, 1)

print("=== Evaluación Crediticia ===")
print(df[["Cliente", "Score", "Ratio_%", "Decision"]])

Hacé clic en ▶ Ejecutar

Tip profesional — axis=0 vs axis=1: axis=0 (default) aplica la función a cada columna. axis=1 aplica la función a cada fila. Cuando tu función necesita acceder a varias columnas de la misma fila (como nuestro scoring), necesitás axis=1.

Ejemplo 5: Renombrar, reordenar y eliminar columnas

El toque final antes de entregar un reporte: que las columnas tengan nombres profesionales y estén en orden lógico.

ejemplo_05_renombrar.pyPython

import pandas as pd

df = pd.DataFrame({
    "cli_nom": ["García", "López", "Pérez"],
    "cli_sal": [850000, 320000, 95000],
    "cli_cd_ciud": ["CABA", "ROS", "CBA"],
    "tmp_flag": [1, 0, 1]  # Columna temporal que no va al reporte
})

print("=== Original (nombres internos) ===")
print(df)

# Renombrar columnas
df = df.rename(columns={
    "cli_nom": "Nombre",
    "cli_sal": "Saldo",
    "cli_cd_ciud": "Ciudad"
})

# Eliminar columna temporal
df = df.drop(columns=["tmp_flag"])

# Reordenar columnas
df = df[["Ciudad", "Nombre", "Saldo"]]

print("\n=== Listo para el reporte ===")
print(df)

# Bonus: renombrar con una función (todo a minúsculas)
df.columns = [c.lower() for c in df.columns]
print(f"\nColumnas finales: {list(df.columns)}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Operación	Sintaxis	Uso
Crear columna calculada	`df["new"] = df["a"] + df["b"]`	Operaciones aritméticas
Valor fijo	`df["moneda"] = "ARS"`	Asignar constante a toda la columna
Mapear valores	`df["col"].map(dict)`	Traducir códigos 1-a-1
If/else vectorizado	`np.where(cond, si, no)`	Clasificación binaria rápida
Función personalizada	`df.apply(func, axis=1)`	Lógica compleja fila por fila
Renombrar columnas	`df.rename(columns=dict)`	Nombres profesionales
Eliminar columnas	`df.drop(columns=[...])`	Quitar columnas temporales
Reordenar columnas	`df[["c2","c1","c3"]]`	Orden lógico para reporte

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Crear columna calculada

Creá una columna "Total" que sea Precio * Cantidad. Imprimí la suma de Total. Debe dar 18500.

ejercicio_01.pyDebe incluir "18500"

import pandas as pd

df = pd.DataFrame({
    "Producto": ["A", "B", "C"],
    "Precio": [500, 300, 200],
    "Cantidad": [10, 25, 20]
})

# Creá la columna Total y sumá

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Agregar IVA

Creá columnas "IVA" (21% del precio) y "Precio_Final" (Precio + IVA). Imprimí el Precio_Final del primer producto. Debe incluir 605.0.

ejercicio_02.pyDebe incluir "605.0"

import pandas as pd

df = pd.DataFrame({
    "Producto": ["Notebook", "Mouse", "Monitor"],
    "Precio": [500, 25, 300]
})

# Creá IVA y Precio_Final, imprimí el primer Precio_Final

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: map() para decodificar

Usá map() para convertir la columna "Nivel" de códigos numéricos a texto: 1→"Junior", 2→"Semi", 3→"Senior". Imprimí el DataFrame. Debe incluir Senior.

ejercicio_03.pyDebe incluir "Senior"

import pandas as pd

df = pd.DataFrame({
    "Nombre": ["Ana", "Luis", "María"],
    "Nivel": [1, 3, 2]
})

# Usá map() para crear columna "Cargo"

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: np.where() para clasificar

Usá np.where() para crear una columna "Rango": "Alto" si Saldo >= 500000, "Bajo" si no. Contá cuántos son "Alto". Debe dar 3.

ejercicio_04.pyDebe incluir "3"

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "Cliente": ["García", "López", "Pérez", "Sosa", "Luna"],
    "Saldo": [850000, 320000, 95000, 670000, 1200000]
})

# Usá np.where para crear "Rango" y contá los "Alto"

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Calcular ratio y porcentaje

Creá una columna "Ratio_Cuota" que sea Cuota / Ingreso * 100 (porcentaje). Imprimí el ratio máximo redondeado. Debe incluir 47.

ejercicio_05.pyDebe incluir "47"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Pérez"],
    "Ingreso": [450000, 180000, 95000],
    "Cuota": [85000, 62000, 45000]
})

# Calculá Ratio_Cuota (%) e imprimí el máximo redondeado

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Renombrar y reordenar

Renombrá "cli_nom" a "Nombre" y "cli_sal" a "Saldo". Eliminá "tmp". Imprimí las columnas finales. Debe incluir Nombre.

ejercicio_06.pyDebe incluir "Nombre"

import pandas as pd

df = pd.DataFrame({
    "cli_nom": ["García", "López", "Pérez"],
    "cli_sal": [850000, 320000, 95000],
    "tmp": [0, 0, 0]
})

# Renombrá, eliminá tmp, imprimí

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: apply() con función personalizada

Escribí una función clasificar_saldo que reciba un número y devuelva "VIP" si >= 1M, "Premium" si >= 500K, "Estándar" si no. Aplicala con apply(). Debe incluir VIP.

ejercicio_07.pyDebe incluir "VIP"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Pérez"],
    "Saldo": [1500000, 320000, 670000]
})

# Definí la función y aplicala con apply

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: apply() con axis=1 (acceso a varias columnas)

Creá una función que evalúe si un cliente es "✅ Aprobado" (score >= 650 Y ratio_cuota <= 35%) o "❌ Rechazado" . Usá apply(func, axis=1). Debe incluir Aprobado.

ejercicio_08.pyDebe incluir "Aprobado"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Pérez"],
    "Score": [720, 580, 700],
    "Ingreso": [450000, 180000, 300000],
    "Cuota": [85000, 62000, 90000]
})

# Función que recibe una FILA (axis=1) y evalúa

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: np.where() anidado (3 categorías)

Usá np.where() anidado para crear 3 niveles: "Alto" (>= 800K), "Medio" (>= 300K), "Bajo" (resto). Imprimí el value_counts. Debe incluir Medio.

ejercicio_09.pyDebe incluir "Medio"

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "Cliente": ["García", "López", "Pérez", "Sosa", "Luna"],
    "Saldo": [850000, 320000, 95000, 670000, 1200000]
})

# np.where anidado para 3 niveles

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Pipeline de transformación completo

A partir del dataset: (1) Creá columna "Ganancia" = Ingreso - Costo, (2) Creá "Margen_%" = Ganancia/Ingreso*100, (3) Clasificá con np.where: margen >= 30 → "Rentable", else "Ajustar", (4) Imprimí solo Producto + Margen_% + Clasificación. Debe incluir Rentable.

ejercicio_10_desafio.pyDebe incluir "Rentable"

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "Producto": ["Notebook", "Mouse", "Monitor", "Teclado"],
    "Ingreso": [800000, 50000, 350000, 120000],
    "Costo": [500000, 20000, 280000, 70000]
})

# Pipeline completo: Ganancia → Margen → Clasificación → Reporte

Hacé clic en ▶ Ejecutar

Resumen y conexión

Crear columnas es tan simple como df["nueva"] = expresión.
Las operaciones vectorizadas (+, *, etc.) son rapidísimas — no uses for.
map(dict) traduce códigos a nombres legibles, 1 a 1.
np.where(cond, si, no) es el if/else vectorizado más rápido.
apply(func, axis=1) permite lógica compleja accediendo a varias columnas por fila.
rename(), drop() y reordenamiento preparan tus datos para el reporte final.

En la siguiente lección (07 · pandas: groupby y pivot) vas a aprender a agrupar datos por categoría y calcular métricas agregadas — la herramienta preferida de todo analista para responder preguntas como "¿cuánto factura cada sucursal?" o "¿cuál es el ticket promedio por canal?".

Recursos: pandas docs — Essential Basic Functionality

Hecho con ❤️ por Rodri Gonzalez