0Pricing
Pandas & NumPy Academy · Lección

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     True

Aplicació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     2000

Condiciones 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   3979576

Combinació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   70000

Combinació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  Accessories

Negació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   refunded

Filtrado 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    200

Filtrado 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    8000

Uso 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  Pass

Asignació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     Available

Recuento 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     70

Comprobació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

  1. Indexación booleana en DataFrames
  2. El método query()
  3. Filtros isin() y between()
  4. Seleccionar columnas por patrón
← Volver a Pandas & NumPy Academy