Data Analysis · Lección 04 de 19

pandas: Selección y Filtrado

Cuando un gerente te dice "Dame los clientes de CABA con más de $500K de saldo", necesitás extraer filas y columnas específicas de una tabla de millones de registros. Esa capacidad de consultar datos se llama selección y filtrado, y es lo que más vas a hacer en tu día a día como Data Analyst.

90–120 min Prerrequisitos: Lección 03 (Lectura de datos)

Concepto teórico

Las 3 formas de acceder a datos en pandas

Pandas te ofrece tres mecanismos principales para acceder a datos dentro de un DataFrame. Entender cuándo usar cada uno es fundamental:

Mecanismo	Selecciona por	Ejemplo	¿Cuándo usarlo?
`df["col"]`	Nombre de columna	`df["Nombre"]`	Cuando solo necesitás una o varias columnas
`df.loc[fila, col]`	Etiqueta (nombre)	`df.loc[0, "Nombre"]`	Cuando sabés el nombre de fila y/o columna
`df.iloc[fila, col]`	Posición (número)	`df.iloc[0, 2]`	Cuando querés acceder por posición numérica

Analogía: Pensá en una planilla de Excel. df["col"] es como seleccionar una columna entera haciendo click en la letra "C". df.loc es como ir a la celda por nombre: "fila García, columna Saldo". df.iloc es como ir por coordenadas: "fila 3, columna 2" sin importar cómo se llamen.

Selección de columnas

La operación más básica. Podés seleccionar una columna (te devuelve una Serie) o varias columnas (te devuelve un DataFrame).

# Una columna → Serie
df["Nombre"]

# Varias columnas → DataFrame (nota los dobles corchetes [[ ]])
df[["Nombre", "Saldo"]]

Error clásico: dobles corchetes. df["Nombre", "Saldo"] da KeyError. Para varias columnas necesitás pasar una lista dentro de los corchetes: df[["Nombre", "Saldo"]]. Los corchetes exteriores son del DataFrame, los interiores son de la lista Python.

Filtrado con máscaras booleanas

Acá es donde pandas se vuelve brutalmente poderoso. Una máscara booleana es una Serie de True/False que le dice a pandas "quedate con las filas que son True, descartá las que son False".

# Paso 1: Crear la máscara (Serie booleana)
mascara = df["Saldo"] > 500000    # True donde Saldo > 500K

# Paso 2: Aplicar la máscara al DataFrame
resultado = df[mascara]           # Solo las filas donde mascara es True

# O en una sola línea (lo más común):
resultado = df[df["Saldo"] > 500000]

¿Por qué se repite df dos veces? Porque el df interno genera la máscara booleana, y el df externo la usa para filtrar. Es como decirle al DataFrame "filtrarte a vos mismo según esta condición sobre vos mismo".

Combinando condiciones: & (AND), | (OR), ~ (NOT)

Para filtros complejos combinás condiciones. Atención: en pandas se usan & y | (operadores bitwise), NO and y or (operadores lógicos de Python). Y cada condición debe ir entre paréntesis obligatoriamente.

# AND: ambas condiciones deben ser True
df[(df["Saldo"] > 500000) & (df["Ciudad"] == "CABA")]

# OR: al menos una condición True
df[(df["Canal"] == "Web") | (df["Canal"] == "App")]

# NOT: invertir la condición
df[~(df["Estado"] == "Inactivo")]

Error mortal: olvidar los paréntesis. df[df["Saldo"] > 500000 & df["Ciudad"] == "CABA"] explota porque & tiene mayor precedencia que > y ==. Siempre encerrá cada condición entre paréntesis.

En el trabajo real: cuando el área de Marketing te pide "clientes activos de CABA con saldo mayor a 500K que compraron en los últimos 30 días", estás combinando 4 filtros con &. Dominar esta sintaxis es el 80% del trabajo diario de un analista.

Ejemplos explicados paso a paso

Ejemplo 1: Seleccionar columnas y filas básicas

Operaciones fundamentales de extracción sobre un DataFrame de clientes bancarios.

ejemplo_01_seleccion.pyPython

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa", "Luna"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA", "Mendoza"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000, 450000],
    "Activo": [True, True, False, True, True, False]
})

# 1. Una columna (Serie)
print("=== Columna Saldo ===")
print(df["Saldo"])

# 2. Varias columnas (DataFrame)
print("\n=== Cliente + Saldo ===")
print(df[["Cliente", "Saldo"]])

# 3. Una fila por posición con iloc
print("\n=== Fila 0 (iloc) ===")
print(df.iloc[0])

# 4. Un rango de filas con iloc
print("\n=== Filas 1 a 3 (iloc) ===")
print(df.iloc[1:4])

# 5. Celda específica con loc
print("\n=== Celda [2, Cliente] (loc) ===")
print(df.loc[2, "Cliente"])

Hacé clic en ▶ Ejecutar

Ejemplo 2: Filtrado con una condición

El caso más habitual: necesitamos solo las filas que cumplen una condición. Observá cómo creamos la máscara booleana y la aplicamos.

ejemplo_02_filtro_simple.pyPython

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa", "Luna"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA", "Mendoza"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000, 450000],
    "Activo": [True, True, False, True, True, False]
})

# Paso 1: La máscara booleana (True/False por fila)
mascara = df["Saldo"] > 500000
print("=== Máscara booleana ===")
print(mascara)

# Paso 2: Aplicar la máscara al DataFrame
ricos = df[mascara]
print("\n=== Clientes con saldo > 500K ===")
print(ricos)
print(f"\nTotal encontrados: {len(ricos)}")
print(f"Saldo total de ese segmento: ${ricos['Saldo'].sum():,}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Múltiples condiciones con & y |

El gerente necesita: clientes activos de CABA con saldo mayor a 600K. Tres filtros combinados.

ejemplo_03_multi_filtro.pyPython

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa", "Luna"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA", "Mendoza"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000, 450000],
    "Activo": [True, True, False, True, True, False]
})

# AND: clientes activos de CABA con saldo > 600K
segmento = df[
    (df["Ciudad"] == "CABA") &
    (df["Activo"] == True) &
    (df["Saldo"] > 600000)
]
print("=== Activos de CABA con saldo > 600K ===")
print(segmento)

# OR: clientes de CABA o Rosario
print("\n=== CABA o Rosario ===")
caba_ros = df[(df["Ciudad"] == "CABA") | (df["Ciudad"] == "Rosario")]
print(caba_ros)

# Alternativa elegante con .isin()
print("\n=== Mismo resultado con isin() ===")
caba_ros_v2 = df[df["Ciudad"].isin(["CABA", "Rosario"])]
print(caba_ros_v2)

Hacé clic en ▶ Ejecutar

Ejemplo 4: loc vs iloc en acción

La diferencia entre acceder por etiqueta (loc) y por posición numérica (iloc) es sutil pero crítica.

ejemplo_04_loc_iloc.pyPython

import pandas as pd

df = pd.DataFrame({
    "Producto": ["Plazo Fijo", "FCI", "Acciones", "Cripto", "Bonos"],
    "Rendimiento": [85.0, 72.5, 120.3, -15.4, 95.0],
    "Riesgo": ["Bajo", "Bajo", "Alto", "Alto", "Medio"]
}, index=["PF", "FCI", "ACC", "CRP", "BON"])  # Índice personalizado

print("=== DataFrame con índice personalizado ===")
print(df)

# loc: por etiqueta (nombre del índice y columna)
print("\n=== loc['ACC', 'Rendimiento'] ===")
print(df.loc["ACC", "Rendimiento"])  # → 120.3

# iloc: por posición numérica (fila 2, columna 1)
print("\n=== iloc[2, 1] ===")
print(df.iloc[2, 1])  # → 120.3 (mismo dato, distinto acceso)

# loc con slicing → INCLUYE ambos extremos
print("\n=== loc['FCI':'CRP'] (incluye CRP) ===")
print(df.loc["FCI":"CRP"])

# iloc con slicing → EXCLUYE el extremo final (como Python)
print("\n=== iloc[1:4] (excluye posición 4) ===")
print(df.iloc[1:4])

Hacé clic en ▶ Ejecutar

Regla de oro: .loc incluye ambos extremos del rango (como decir "desde A hasta B, incluyendo B"). .iloc excluye el final (como el slicing estándar de Python). Memorizá esto o te va a generar bugs silenciosos.

Ejemplo 5: Filtro + selección de columnas (query compuesta)

El patrón más potente: filtrar filas Y seleccionar solo las columnas que necesitás. Es el equivalente al SELECT col1, col2 FROM tabla WHERE condicion de SQL.

ejemplo_05_query_compuesta.pyPython

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa", "Luna"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA", "Mendoza"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000, 450000],
    "Activo": [True, True, False, True, True, False]
})

# Query compuesta: filtrar filas + seleccionar columnas
# "Dame nombre y saldo de los activos con saldo > 300K"
resultado = df.loc[
    (df["Activo"] == True) & (df["Saldo"] > 300000),
    ["Cliente", "Saldo"]
]
print("=== SELECT Cliente, Saldo WHERE Activo AND Saldo > 300K ===")
print(resultado)

# Equivalente SQL: SELECT Cliente, Saldo FROM df WHERE Activo = True AND Saldo > 300000

# Ordenar por saldo descendente
print("\n=== Ordenados por Saldo (desc) ===")
print(resultado.sort_values("Saldo", ascending=False))

Hacé clic en ▶ Ejecutar

Referencia rápida

Operación	Sintaxis	Devuelve
Una columna	`df["col"]`	Serie
Varias columnas	`df[["c1","c2"]]`	DataFrame
Fila por etiqueta	`df.loc[etiqueta]`	Serie
Fila por posición	`df.iloc[n]`	Serie
Celda específica	`df.loc[fila, col]`	Valor escalar
Rango de filas	`df.iloc[a:b]`	DataFrame
Filtro booleano	`df[df["col"] > x]`	DataFrame filtrado
AND	`(cond1) & (cond2)`	Máscara combinada
OR	`(cond1) \| (cond2)`	Máscara combinada
NOT	`~(cond)`	Máscara invertida
Pertenencia	`df["col"].isin([...])`	Máscara booleana

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Seleccionar una columna

Del DataFrame provisto, extraé la columna "Producto" e imprimila. El output debe contener Galletas.

ejercicio_01.pyDebe incluir "Galletas"

import pandas as pd

df = pd.DataFrame({
    "Producto": ["Galletas", "Vino", "Detergente", "Arroz"],
    "Precio": [350, 2800, 900, 480],
    "Stock": [150, 80, 200, 300]
})

# Extraé la columna Producto e imprimila

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Seleccionar varias columnas

Seleccioná las columnas "Producto" y "Precio" simultáneamente usando doble corchete e imprimí el resultado. Debe incluir 2800.

ejercicio_02.pyDebe incluir "2800"

import pandas as pd

df = pd.DataFrame({
    "Producto": ["Galletas", "Vino", "Detergente", "Arroz"],
    "Precio": [350, 2800, 900, 480],
    "Stock": [150, 80, 200, 300]
})

# Seleccioná Producto y Precio (doble corchete [[ ]])

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Filtro simple con una condición

Filtrá los productos con Precio > 500 e imprimí el resultado. Debe mostrar Vino y Detergente. Tu output debe incluir Detergente.

ejercicio_03.pyDebe incluir "Detergente"

import pandas as pd

df = pd.DataFrame({
    "Producto": ["Galletas", "Vino", "Detergente", "Arroz"],
    "Precio": [350, 2800, 900, 480],
    "Stock": [150, 80, 200, 300]
})

# Filtrá donde Precio > 500

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Filtro con dos condiciones AND

Del dataset de clientes, filtrá los que sean de "CABA" Y tengan Saldo > 500000. Imprimí solo las columnas Cliente y Saldo. Debe incluir García.

ejercicio_04.pyDebe incluir "García"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000],
    "Activo": [True, True, False, True, True]
})

# Filtrá CABA AND Saldo > 500K, mostrá solo Cliente y Saldo

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Filtro con isin()

Filtrá los clientes que sean de "CABA" o "Rosario" usando .isin(). Imprimí cuántos encontraste con len(). Debe incluir el número 4.

ejercicio_05.pyDebe incluir "4"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000]
})

# Usá .isin() para filtrar CABA y Rosario, imprimí len()

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Acceso con iloc

Usando iloc, extraé las filas de la 1 a la 3 (inclusive) y las columnas de la 0 a la 1 (inclusive). Imprimí el resultado. Debe incluir López.

ejercicio_06.pyDebe incluir "López"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000]
})

# iloc filas 1:4, columnas 0:2

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Negación con ~ (NOT)

Filtrá todos los clientes que NO estén en CABA usando el operador ~. Imprimí solo los nombres. Debe incluir Pérez.

ejercicio_07.pyDebe incluir "Pérez"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000]
})

# Filtrá los que NO son de CABA con ~ e imprimí solo la columna Cliente

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Query compuesta con loc

Usando .loc, filtrá clientes activos con saldo > 300K y seleccioná solo las columnas Cliente y Saldo. Imprimí el saldo promedio de ese segmento con .mean(). Debe incluir 613333.

ejercicio_08.pyDebe incluir "613333"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000],
    "Activo": [True, True, False, True, True]
})

# Filtrá activos con saldo > 300K, mostrá Cliente y Saldo, calculá promedio

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Filtro + sort + head

Filtrá los clientes activos, ordenalos por saldo descendente con sort_values(), y mostrá solo los top 2 con .head(2). Debe incluir García.

ejercicio_09.pyDebe incluir "García"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000],
    "Activo": [True, True, False, True, True]
})

# Filtrar activos, ordenar por Saldo desc, top 2

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte segmentado completo

Generá un mini reporte: (1) Contá cuántos clientes son de CABA, (2) Cuántos están activos, (3) Cuál es el saldo promedio de los activos de CABA. Debe incluir 760000.

ejercicio_10_desafio.pyDebe incluir "760000"

import pandas as pd

df = pd.DataFrame({
    "Cliente": ["García", "López", "Martínez", "Pérez", "Sosa"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Córdoba", "CABA"],
    "Saldo": [850000, 320000, 1200000, 95000, 670000],
    "Activo": [True, True, False, True, True]
})

# 1. Clientes de CABA
# 2. Clientes activos
# 3. Saldo promedio de activos de CABA (García 850K + Sosa 670K) / 2 = 760K

Hacé clic en ▶ Ejecutar

Resumen y conexión

df["col"] selecciona columnas. df[["c1","c2"]] selecciona varias.
df.loc accede por etiqueta (nombre). df.iloc accede por posición numérica.
Las máscaras booleanas (df[df["col"] > x]) son el mecanismo de filtrado más poderoso.
Usá & (AND), | (OR), ~ (NOT) para combinar condiciones. Siempre con paréntesis.
.isin() es la alternativa elegante para filtrar por múltiples valores.
Combiná filtros con .loc[filtro, columnas] para queries compuestas estilo SQL.

En la siguiente lección (05 · pandas: limpieza) vas a aprender a enfrentar el caos real de los datos: valores nulos, duplicados, tipos inconsistentes y formatos rotos. Sin limpieza, todo el análisis posterior está contaminado.

Recursos: pandas docs — Indexing and Selecting Data

Hecho con ❤️ por Rodri Gonzalez