Explorar guías rápidas · Python
Filtrar filas en pandas
Filtra filas de un DataFrame de pandas de forma segura y clara con máscaras booleanas, condiciones múltiples, pruebas de pertenencia, filtros de texto y fechas, comprobaciones de nulos y expresiones query.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. Filtrar con una condición
- 2. Filtrar con varias condiciones Y
- 3. Filtrar con condiciones O
- 4. Combinar Y y O con cuidado
- 5. Excluir filas con ~
- 6. Filtrar con .isin()
- 7. Filtrar filas nulas y no nulas
- 8. Filtrar por rango numérico
- 9. Filtrar fechas correctamente
- 10. Filtrar texto con .str.contains()
- 11. Filtrar por prefijo o sufijo de texto
- 12. Filtrar texto exacto después de normalizarlo
- 13. Filtrar con una máscara booleana reutilizable
- 14. Filtrar y seleccionar columnas a la vez
- 15. Usar .query() para expresiones legibles
- 16. Filtrar en función de otra columna
- 17. Filtrar grupos según una lógica de agregación
- 18. Conservar las N primeras filas después de filtrar
- 19. Filtrar duplicados por clave
- 20. Filtrar filas que coinciden con valores de otro DataFrame
- Qué significa el resultado
- Qué revisar
- El número de resultados es cero de forma inesperada
- El número de resultados es inesperadamente alto
- Los nulos desaparecen de forma inesperada
- El filtro de texto no encuentra coincidencias evidentes
- El filtro de fechas pierde las filas del final del día
- Notas de producción
- Prefiere .loc[] para un filtrado explícito
- Evita la asignación encadenada después de filtrar
- Los filtros recorren las columnas implicadas
- Las expresiones regulares pueden ser costosas
- Las zonas horarias importan
- La semántica de los nulos debe ser deliberada
- Errores comunes
- 1. Usar and / or en lugar de & / |
- 2. Olvidar los paréntesis
- 3. Comparar nulos con == np.nan
- 4. Usar expresiones regulares sin querer
- 5. Filtrar fechas mientras siguen siendo cadenas
- 6. Sobrescribir columnas de origen durante la exploración
- 7. Filtrar después de operaciones costosas
- Siguiente paso
- Para profundizar
Problema
Necesitas conservar solo las filas que cumplen una condición de negocio:
- pedidos por encima de un importe
- registros de países concretos
- filas entre dos fechas
- clientes con datos faltantes
- estados incluidos en una lista permitida
- texto que contiene un patrón
- filas que cumplen varias condiciones a la vez
El reto no es solo la sintaxis.
Quieres un filtrado que sea:
- correcto
- legible
- seguro ante nulos
- fácil de depurar
- seguro de mantener en código de producción
Respuesta rápida
Usa máscaras booleanas con .loc[].
filtered = df.loc[
(df["status"] == "active")
& (df["amount"] >= 100)
]
Para la pertenencia:
filtered = df.loc[
df["country"].isin(["US", "CA", "MX"])
]
Para las fechas:
filtered = df.loc[
df["event_time"].between(
pd.Timestamp("2026-10-01"),
pd.Timestamp("2026-10-31"),
inclusive="both",
)
]
Prefiere .loc[mask] en código de producción, porque la intención es explícita y fácil de ampliar.
Código / comandos
1. Filtrar con una condición
filtered = df.loc[df["amount"] > 100]
Úsalo para una condición numérica o de igualdad sencilla.
Ejemplos:
active = df.loc[df["status"] == "active"]
failed = df.loc[df["status"] == "failed"]
large_orders = df.loc[df["amount"] >= 1000]
2. Filtrar con varias condiciones Y
Usa & y envuelve cada comparación entre paréntesis.
filtered = df.loc[
(df["status"] == "active")
& (df["amount"] >= 100)
& (df["country"] == "US")
]
No uses el and de Python entre Series.
Incorrecto:
df["status"] == "active" and df["amount"] >= 100
Correcto:
(df["status"] == "active") & (df["amount"] >= 100)
3. Filtrar con condiciones O
Usa |.
filtered = df.loc[
(df["status"] == "failed")
| (df["status"] == "cancelled")
]
Cuando hay muchas opciones de igualdad, .isin() es más limpio.
filtered = df.loc[
df["status"].isin(["failed", "cancelled"])
]
4. Combinar Y y O con cuidado
filtered = df.loc[
(df["country"] == "US")
& (
(df["status"] == "active")
| (df["priority"] == "high")
)
]
Los paréntesis importan.
No confíes en la precedencia de operadores cuando la expresión es crítica para el negocio.
5. Excluir filas con ~
filtered = df.loc[
~df["status"].isin(["cancelled", "deleted"])
]
Esto significa:
conservar las filas cuyo estado no está en la lista
Para un solo valor:
filtered = df.loc[df["status"] != "cancelled"]
6. Filtrar con .isin()
allowed_countries = ["US", "CA", "MX"]
filtered = df.loc[
df["country"].isin(allowed_countries)
]
Usa .isin() cuando tengas una lista, un conjunto, una Series u otra colección de valores aceptados.
Suele ser más claro que encadenar muchas condiciones O.
7. Filtrar filas nulas y no nulas
Filas nulas:
missing_email = df.loc[
df["email"].isna()
]
Filas no nulas:
has_email = df.loc[
df["email"].notna()
]
No compares con == None ni con == np.nan.
Usa los métodos de pandas para nulos.
8. Filtrar por rango numérico
Usa .between().
filtered = df.loc[
df["amount"].between(100, 500, inclusive="both")
]
Equivalente:
filtered = df.loc[
(df["amount"] >= 100)
& (df["amount"] <= 500)
]
.between() suele ser más fácil de leer.
9. Filtrar fechas correctamente
Primero asegúrate de que la columna sea de tipo datetime:
df["event_time"] = pd.to_datetime(
df["event_time"],
errors="coerce",
)
Después filtra:
start = pd.Timestamp("2026-10-01")
end = pd.Timestamp("2026-10-31")
filtered = df.loc[
df["event_time"].between(
start,
end,
inclusive="both",
)
]
Si las marcas de tiempo incluyen la hora del día, ten cuidado con la lógica de fin de día.
Para un intervalo mensual semiabierto, esta forma suele ser más segura:
filtered = df.loc[
(df["event_time"] >= pd.Timestamp("2026-10-01"))
& (df["event_time"] < pd.Timestamp("2026-11-01"))
]
Así evitas excluir por accidente filas de horas posteriores del 31 de octubre.
10. Filtrar texto con .str.contains()
filtered = df.loc[
df["description"]
.str.contains("error", case=False, na=False)
]
Opciones importantes:
case=False→ no distingue entre mayúsculas y minúsculasna=False→ los valores nulos pasan a serFalseregex=→ controla si el patrón se trata como expresión regular
Para texto literal:
filtered = df.loc[
df["description"]
.str.contains(
"a+b",
case=False,
na=False,
regex=False,
)
]
Usa regex=False cuando el texto de búsqueda no deba interpretarse como expresión regular.
11. Filtrar por prefijo o sufijo de texto
Empieza por:
filtered = df.loc[
df["code"].str.startswith("ABC", na=False)
]
Termina en:
filtered = df.loc[
df["filename"].str.endswith(".csv", na=False)
]
12. Filtrar texto exacto después de normalizarlo
Cuando los datos de origen pueden tener mayúsculas, minúsculas o espacios incoherentes:
normalized_status = (
df["status"]
.astype("string")
.str.strip()
.str.lower()
)
filtered = df.loc[
normalized_status.eq("active")
]
Es más seguro que modificar permanentemente la columna original durante el análisis inicial.
13. Filtrar con una máscara booleana reutilizable
mask = (
(df["status"] == "active")
& (df["amount"] > 100)
& df["country"].isin(["US", "CA"])
)
filtered = df.loc[mask]
Es útil cuando:
- la condición es compleja
- quieres inspeccionar la máscara
- reutilizas la condición
- quieres facilitar la depuración
Comprueba cuántas filas coinciden:
print(mask.sum())
14. Filtrar y seleccionar columnas a la vez
filtered = df.loc[
df["status"] == "active",
["customer_id", "amount", "event_time"],
]
Esto puede reducir el uso de memoria y aclarar la lógica posterior.
15. Usar .query() para expresiones legibles
filtered = df.query(
"status == 'active' and amount >= 100"
)
Las variables externas se usan con @:
min_amount = 100
filtered = df.query(
"status == 'active' and amount >= @min_amount"
)
.query() puede ser muy legible para expresiones sencillas.
Prefiere las máscaras booleanas cuando:
- los nombres de columna son incómodos
- necesitas métodos de cadena complejos
- necesitas un manejo detallado de los nulos
- la expresión es más fácil de depurar de forma explícita
16. Filtrar en función de otra columna
filtered = df.loc[
df["actual_amount"] > df["expected_amount"]
]
Útil para comparaciones a nivel de fila.
Ejemplo:
late = df.loc[
df["actual_date"] > df["expected_date"]
]
17. Filtrar grupos según una lógica de agregación
Supón que quieres los clientes cuyos ingresos totales superan 10.000.
customer_totals = (
df.groupby("customer_id")["revenue"]
.transform("sum")
)
filtered = df.loc[
customer_totals > 10_000
]
Usa transform() cuando necesites lógica a nivel de grupo conservando la granularidad original de las filas.
18. Conservar las N primeras filas después de filtrar
filtered = (
df.loc[df["status"] == "active"]
.nlargest(10, "amount")
)
Para los valores más pequeños:
filtered = (
df.loc[df["status"] == "active"]
.nsmallest(10, "amount")
)
Es más directo que ordenar todo el DataFrame cuando solo necesitas las primeras filas.
19. Filtrar duplicados por clave
Conserva solo las filas con claves de negocio duplicadas:
duplicates = df.loc[
df.duplicated(
subset=["customer_id", "order_id"],
keep=False,
)
]
Úsalo para investigar antes de decidir cómo deduplicar.
20. Filtrar filas que coinciden con valores de otro DataFrame
valid_ids = lookup_df["customer_id"]
filtered = df.loc[
df["customer_id"].isin(valid_ids)
]
Para una correspondencia relacional amplia que necesita columnas de ambos conjuntos de datos, un merge suele ser más adecuado.
Usa .isin() para un filtrado sencillo de tipo semi-join.
Qué significa el resultado
Un filtro genera una decisión booleana para cada fila.
Por ejemplo:
mask = df["amount"] > 100
produce, conceptualmente, valores como:
True
False
True
False
...
Después:
df.loc[mask]
conserva solo las filas True.
Comportamientos importantes:
| Patrón | Significado |
|---|---|
& |
Y elemento a elemento |
| ` | ` |
~ |
NO elemento a elemento |
.isin() |
prueba de pertenencia |
.isna() |
valor faltante |
.notna() |
valor no faltante |
.between() |
prueba de rango inclusivo/exclusivo |
.str.contains() |
coincidencia de texto |
.eq() |
comparación de igualdad |
.ne() |
distinto de |
.gt() / .ge() |
mayor que / mayor o igual que |
.lt() / .le() |
menor que / menor o igual que |
Qué revisar
El número de resultados es cero de forma inesperada
Comprueba:
- discrepancia de dtype
- espacios en blanco
- mayúsculas y minúsculas
- conversión de fechas
- nulos
- agrupación booleana incorrecta
- discrepancia de zona horaria
Ejemplo:
print(df["status"].value_counts(dropna=False))
antes de dar por hecho que "active" existe exactamente como está escrito.
El número de resultados es inesperadamente alto
Comprueba si las condiciones O son demasiado amplias.
Ejemplo:
mask = (
(df["country"] == "US")
| (df["status"] == "active")
)
Esto conserva las filas que cumplen cualquiera de las dos condiciones.
Si querías ambas, usa &.
Los nulos desaparecen de forma inesperada
Las comparaciones con valores nulos suelen dar resultados equivalentes a falso al filtrar.
Si los nulos importan, trátalos de forma explícita.
Ejemplo:
mask = (
df["amount"].isna()
| (df["amount"] > 100)
)
El filtro de texto no encuentra coincidencias evidentes
Comprueba:
- mayúsculas y minúsculas
- espacios al principio o al final
- interpretación como expresión regular
- valores nulos
Usa normalización u opciones explícitas.
El filtro de fechas pierde las filas del final del día
Ocurre cuando se usa la medianoche como límite superior.
Prefiere los intervalos semiabiertos:
start <= timestamp < next_period_start
para ventanas de un día o un mes completos.
Notas de producción
Prefiere .loc[] para un filtrado explícito
Ambas formas son válidas:
df[df["amount"] > 100]
df.loc[df["amount"] > 100]
.loc[] suele ser más claro cuando más adelante agregas selección de columnas o asignaciones.
Evita la asignación encadenada después de filtrar
Patrón arriesgado:
df[df["amount"] > 100]["flag"] = True
Usa:
df.loc[df["amount"] > 100, "flag"] = True
Es más claro y evita la ambigüedad de la asignación encadenada.
Los filtros recorren las columnas implicadas
El filtrado booleano suele ser O(n) sobre las filas implicadas.
En DataFrames muy grandes:
- filtra pronto
- selecciona solo las columnas necesarias
- evita repetir máscaras equivalentes
- considera el predicate pushdown en la lectura cuando esté disponible
- considera un motor distribuido si el conjunto de datos ya no cabe cómodamente en memoria
Las expresiones regulares pueden ser costosas
str.contains() trata el patrón como expresión regular de forma predeterminada.
Para una coincidencia literal, usa:
regex=False
Esto también evita una semántica de expresión regular accidental.
Las zonas horarias importan
Comparar marcas de tiempo con y sin zona horaria puede fallar o producir una lógica incorrecta si se tratan de forma incoherente.
Normaliza el modelo temporal antes de filtrar.
La semántica de los nulos debe ser deliberada
No des por hecho que los valores faltantes deben excluirse.
Las reglas de negocio pueden exigir:
- conservar los nulos
- excluir los nulos
- tratar el nulo como desconocido
- derivar los nulos para su corrección
Expresa esa intención de forma explícita.
Errores comunes
1. Usar and / or en lugar de & / |
Incorrecto:
(df["a"] > 1) and (df["b"] < 5)
Correcto:
(df["a"] > 1) & (df["b"] < 5)
2. Olvidar los paréntesis
Incorrecto o ambiguo:
df["a"] > 1 & df["b"] < 5
Correcto:
(df["a"] > 1) & (df["b"] < 5)
3. Comparar nulos con == np.nan
Usa:
df["col"].isna()
no:
df["col"] == np.nan
4. Usar expresiones regulares sin querer
Esto:
str.contains("a+b")
trata + como sintaxis de expresión regular.
Usa:
str.contains("a+b", regex=False)
para texto literal.
5. Filtrar fechas mientras siguen siendo cadenas
El orden lexicográfico de las cadenas no sustituye de forma fiable a la semántica de fechas ya convertidas.
Conviértelas primero.
6. Sobrescribir columnas de origen durante la exploración
Construye primero Series derivadas cuando valides transformaciones.
Después, modifica los datos de forma deliberada.
7. Filtrar después de operaciones costosas
Si puedes reducir el conjunto de datos antes, hazlo.
Filtrar antes de joins y agregaciones puede reducir mucho la memoria y el trabajo.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.