Indexación booleana en DataFrames
Filtre filas aplicando una condición booleana a una columna y combinando varias condiciones con los operadores & y |.
Indexación booleana en DataFrames es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué es la indexación booleana?
La indexación booleana permite filtrar filas de un DataFrame aplicando una condición que produce una Series con valores True y False. Solo se devuelven las filas cuya condición es True. Esta es una de las técnicas de selección más utilizadas en Pandas porque resulta legible y rápida.
Por ejemplo, dado un DataFrame de ventas, puede recuperar al instante todas las filas cuyos ingresos superen 1000 sin escribir un bucle.
import pandas as pd
df = pd.DataFrame({
'product': ['A', 'B', 'C', 'D'],
'revenue': [500, 1500, 800, 2000]
})
# Boolean condition produces a Series of True/False
mask = df['revenue'] > 1000
print(mask)
# 0 False
# 1 True
# 2 False
# 3 TrueAplicación de la máscara booleana
Una vez que tiene una máscara booleana, pásela entre corchetes al DataFrame para seleccionar únicamente las filas coincidentes. El resultado es un DataFrame nuevo; el original nunca se modifica. Los índices de fila del original se conservan, por lo que siempre sabrá de dónde procede cada fila.
Este patrón —crear la máscara y aplicarla después— es la forma idiomática estándar de Pandas para filtrar filas.
import pandas as pd
df = pd.DataFrame({
'product': ['A', 'B', 'C', 'D'],
'revenue': [500, 1500, 800, 2000]
})
mask = df['revenue'] > 1000
filtered = df[mask]
print(filtered)
# product revenue
# 1 B 1500
# 3 D 2000Condiciones en línea sin una variable de máscara
No es necesario asignar la Series booleana a una variable. Puede escribir la condición en línea directamente entre los corchetes: df[df['col'] > value]. Este estilo de una sola línea es muy habitual en los notebooks de análisis de datos porque mantiene el código compacto y legible.
Ambos enfoques —variable de máscara y condición en línea— producen resultados idénticos. Utilice una variable cuando la condición sea compleja o se reutilice; use la condición en línea para filtros sencillos y puntuales.
import pandas as pd
df = pd.DataFrame({
'city': ['NYC', 'LA', 'Chicago', 'Houston'],
'population': [8_336_817, 3_979_576, 2_693_976, 2_320_268]
})
# Inline boolean filter
large_cities = df[df['population'] > 3_000_000]
print(large_cities)
# city population
# 0 NYC 8336817
# 1 LA 3979576Combinación de condiciones con & (AND)
Para exigir que ambas condiciones sean verdaderas, combínelas con el operador &, no con la palabra clave and de Python, que no funciona elemento a elemento en los arrays. Cada condición debe estar entre paréntesis porque & tiene mayor precedencia que los operadores de comparación.
El resultado conserva únicamente las filas en las que todas las subcondiciones se evalúan como True.
import pandas as pd
df = pd.DataFrame({
'name': ['Alice', 'Bob', 'Carol', 'Dave'],
'age': [25, 35, 28, 45],
'salary': [50000, 90000, 70000, 120000]
})
# Both conditions must be true
result = df[(df['age'] > 27) & (df['salary'] > 60000)]
print(result)
# name age salary
# 1 Bob 35 90000
# 2 Carol 28 70000Combinación de condiciones con | (OR)
Utilice el operador | para conservar las filas en las que al menos una condición sea verdadera. Al igual que con &, cada subcondición debe estar entre paréntesis. El operador | realiza un OR lógico elemento a elemento en los arrays booleanos.
Es totalmente válido combinar & y |; solo debe prestar atención a los paréntesis para establecer el orden de evaluación correcto y evitar errores lógicos sutiles.
import pandas as pd
df = pd.DataFrame({
'product': ['Laptop', 'Mouse', 'Monitor', 'Keyboard'],
'price': [1200, 25, 300, 80],
'category': ['Electronics', 'Accessories', 'Electronics', 'Accessories']
})
# Rows where price > 200 OR category is Accessories
result = df[(df['price'] > 200) | (df['category'] == 'Accessories')]
print(result)
# product price category
# 0 Laptop 1200 Electronics
# 1 Mouse 25 Accessories
# 2 Monitor 300 Electronics
# 3 Keyboard 80 AccessoriesNegación de una condición con ~
El operador tilde ~ invierte una Series booleana: convierte True en False y viceversa. Utilice ~ para expresar una lógica «NOT»: conserve las filas que no coincidan con una condición. Esto es más limpio que construir manualmente la condición opuesta.
Por ejemplo, df[~df['status'].isin(['cancelled', 'refunded'])] conserva todas las filas excepto las correspondientes a esos dos estados.
import pandas as pd
df = pd.DataFrame({
'order_id': [1, 2, 3, 4],
'status': ['shipped', 'cancelled', 'delivered', 'refunded']
})
# Keep only rows that are NOT cancelled
active = df[~(df['status'] == 'cancelled')]
print(active)
# order_id status
# 0 1 shipped
# 2 3 delivered
# 3 4 refundedFiltrado de valores de texto
La indexación booleana funciona igual de bien con columnas de texto. Puede filtrar una coincidencia exacta con == o utilizar métodos de .str como .str.startswith(), .str.contains() o .str.upper() dentro de la condición para realizar un filtrado de texto flexible.
Las comparaciones de cadenas en Pandas distinguen entre mayúsculas y minúsculas de forma predeterminada, por lo que 'NYC' y 'nyc' se tratan como valores distintos. Normalice las mayúsculas y minúsculas antes si es necesario.
import pandas as pd
df = pd.DataFrame({
'country': ['USA', 'Germany', 'UK', 'USA', 'France'],
'sales': [400, 200, 150, 600, 300]
})
# Filter rows where country equals USA
us_sales = df[df['country'] == 'USA']
print(us_sales)
# country sales
# 0 USA 400
# 3 USA 600
# Filter rows where country starts with 'G'
g_countries = df[df['country'].str.startswith('G')]
print(g_countries)
# country sales
# 1 Germany 200Filtrado en varias columnas
Los análisis complejos suelen requerir condiciones en varias columnas combinadas con & y |. Divida las condiciones muy largas en Series booleanas con nombre para mejorar la legibilidad; cada una actúa como un subfiltro con nombre que combinará al final.
Este enfoque deja clara su intención: cada línea se lee como una frase que describe una parte de la lógica del filtro.
import pandas as pd
df = pd.DataFrame({
'region': ['North', 'South', 'North', 'East'],
'year': [2022, 2023, 2023, 2022],
'profit': [5000, -200, 8000, 3000]
})
is_north = df['region'] == 'North'
is_2023 = df['year'] == 2023
is_profitable = df['profit'] > 0
result = df[is_north & is_2023 & is_profitable]
print(result)
# region year profit
# 2 North 2023 8000Uso de np.where para columnas condicionales
La indexación booleana filtra filas, pero a veces querrá añadir una columna nueva según una condición en lugar de eliminar filas. np.where(condition, value_if_true, value_if_false) es el equivalente vectorizado de un if/else aplicado elemento a elemento a una columna, y es mucho más rápido que usar apply con una lambda.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'score': [45, 72, 88, 61, 95]
})
# Create a new column based on a condition
df['grade'] = np.where(df['score'] >= 70, 'Pass', 'Fail')
print(df)
# score grade
# 0 45 Fail
# 1 72 Pass
# 2 88 Pass
# 3 61 Fail
# 4 95 PassAsignación de valores a un subconjunto filtrado
Puede actualizar valores directamente en las filas filtradas mediante .loc[mask, column]. Esta es la forma segura de establecer valores en un subconjunto; utilizar indexación encadenada como df[mask]['col'] = value puede generar un SettingWithCopyWarning porque opera sobre una copia.
Prefiera siempre df.loc[mask, 'col'] = value cuando quiera modificar directamente el DataFrame original.
import pandas as pd
df = pd.DataFrame({
'item': ['A', 'B', 'C', 'D'],
'stock': [0, 5, 0, 12]
})
# Mark out-of-stock items
df.loc[df['stock'] == 0, 'status'] = 'Out of Stock'
df.loc[df['stock'] > 0, 'status'] = 'Available'
print(df)
# item stock status
# 0 A 0 Out of Stock
# 1 B 5 Available
# 2 C 0 Out of Stock
# 3 D 12 AvailableRecuento y suma de la máscara
Como internamente los valores booleanos son 1 (True) y 0 (False), puede llamar a .sum() en una máscara para contar las filas coincidentes o a .mean() para obtener la fracción de filas que coinciden. Estos recuentos rápidos le ayudan a verificar la lógica del filtro antes de aplicarlo para seleccionar filas.
import pandas as pd
df = pd.DataFrame({'value': [10, 55, 30, 80, 20, 70]})
mask = df['value'] > 40
print('Count of rows > 40:', mask.sum()) # 3
print('Fraction > 40:', mask.mean().round(2)) # 0.5
# Now apply
print(df[mask])
# value
# 1 55
# 3 80
# 5 70Comprobación rápida
Compruebe su comprensión de la indexación booleana en DataFrames.
Resumen de la lección
En esta lección ha aprendido: las máscaras booleanas filtran filas aplicando una condición a una columna, los operadores & y | combinan varias condiciones (no son las palabras clave and/or de Python) y ~ invierte una máscara booleana para aplicar una lógica NOT. Utilice df.loc[mask, col] = value para asignar valores de forma segura a las filas filtradas. A continuación, exploraremos el método query() para escribir filtros como cadenas legibles.
Preguntas frecuentes
¿La lección «Indexación booleana en DataFrames» es gratis?
Sí — el texto completo de «Indexación booleana en DataFrames» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Indexación booleana en DataFrames»?
Filtre filas aplicando una condición booleana a una columna y combinando varias condiciones con los operadores & y |. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Pandas & NumPy Academy?
No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Indexación booleana en DataFrames»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?
Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Indexación booleana en DataFrames
- El método query()
- Filtros isin() y between()
- Seleccionar columnas por patrón