El método query()
Escriba expresiones de filtro legibles como cadenas con query(), use variables de Python dentro de las consultas mediante @ y encadene filtros.
El método query() es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 2 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.
¿Por qué utilizar query()?
La indexación booleana de Pandas es potente, pero puede volverse difícil de leer al combinar muchas condiciones. El método query() permite escribir expresiones de filtro como cadenas de texto normales, lo que a muchas personas les resulta más legible, especialmente si tienen experiencia con SQL. En lugar de df[(df['age'] > 30) & (df['salary'] > 50000)], puede escribir df.query('age > 30 and salary > 50000').
La cadena de consulta se evalúa con respecto a los nombres de las columnas del DataFrame, por lo que los nombres de las columnas actúan como nombres de variables dentro de la cadena.
import pandas as pd
df = pd.DataFrame({
'name': ['Alice', 'Bob', 'Carol', 'Dave'],
'age': [25, 35, 28, 45],
'salary': [50000, 90000, 70000, 120000]
})
# Boolean indexing style
result1 = df[(df['age'] > 27) & (df['salary'] > 60000)]
# Equivalent query() style
result2 = df.query('age > 27 and salary > 60000')
print(result2)
# name age salary
# 1 Bob 35 90000
# 2 Carol 28 70000Reglas de sintaxis dentro de una cadena de consulta
Dentro de una cadena de consulta puede usar los operadores de comparación estándar de Python (>, <, ==, !=, >=, <=) y los conectores lógicos and, or, not. A diferencia de la indexación booleana habitual, aquí puede usar las palabras en inglés; no necesita ampersands ni barras verticales.
Los nombres de columnas que contienen espacios o que coinciden con palabras clave de Python deben encerrarse entre comillas invertidas: df.query('`first name` == "Alice"').
import pandas as pd
df = pd.DataFrame({
'product': ['A', 'B', 'C', 'D'],
'price': [10, 200, 50, 300],
'in_stock': [True, False, True, True]
})
# Use 'and', 'or', 'not' in query strings
result = df.query('price > 40 and in_stock == True')
print(result)
# product price in_stock
# 2 C 50 True
# 3 D 300 TrueReferencia de variables de Python con @
Una característica clave de query() es la posibilidad de hacer referencia a variables de Python del ámbito circundante mediante el prefijo @. Esto facilita la parametrización de filtros: calcule un umbral, guárdelo en una variable y, a continuación, use @variable_name dentro de la cadena de consulta en lugar de codificar el valor directamente.
Este patrón resulta muy útil en funciones que aceptan argumentos de filtrado durante la ejecución.
import pandas as pd
df = pd.DataFrame({
'city': ['NYC', 'LA', 'Chicago', 'Houston'],
'population': [8336817, 3979576, 2693976, 2320268]
})
min_pop = 3_000_000 # Python variable
# Use @ to inject the variable into the query
result = df.query('population > @min_pop')
print(result)
# city population
# 0 NYC 8336817
# 1 LA 3979576Encadenamiento de llamadas a query()
Como query() devuelve un DataFrame nuevo, puede encadenar varias llamadas a query o combinarlas con otros métodos de Pandas en una canalización. El encadenamiento mantiene cada paso de filtrado en su propia línea, lo que facilita leer, depurar y modificar la lógica.
También puede encadenar query() con métodos como .groupby(), .sort_values() o .head() para crear canalizaciones de análisis concisas.
import pandas as pd
df = pd.DataFrame({
'region': ['North', 'South', 'North', 'East', 'South'],
'year': [2022, 2022, 2023, 2023, 2023],
'revenue': [100, 200, 150, 80, 300]
})
# Chain two query calls
result = (df
.query('year == 2023')
.query('revenue > 100')
.sort_values('revenue', ascending=False)
)
print(result)
# region year revenue
# 4 South 2023 300
# 2 North 2023 150Comparación entre query() y la indexación booleana
Ambos métodos producen el mismo resultado, pero cada uno tiene su utilidad. query() resulta especialmente adecuado para filtros con varias condiciones que requerirían muchos paréntesis con la indexación booleana. La indexación booleana es mejor cuando la condición incluye expresiones complejas de Python, como llamadas a métodos que no son compatibles con las cadenas de consulta.
El rendimiento es similar en la mayoría de los casos; query() puede ser ligeramente más rápido en DataFrames muy grandes porque utiliza la biblioteca numexpr internamente.
import pandas as pd
df = pd.DataFrame({
'A': range(10),
'B': range(10, 20)
})
# Boolean indexing
result_bool = df[(df['A'] > 2) & (df['B'] < 18) & (df['A'] != 5)]
# Equivalent query — much more readable
result_query = df.query('A > 2 and B < 18 and A != 5')
print(result_query)
# A B
# 3 3 13
# 4 4 14
# 6 6 16
# 7 7 17Comparaciones de cadenas en query()
Puede filtrar los valores de una columna de tipo cadena dentro de una cadena de consulta escribiendo entre comillas el literal de cadena. Use comillas dobles para la cadena de consulta externa y comillas simples para el valor de cadena, o al revés; lo importante es mantener la coherencia. Tenga en cuenta que query() no admite métodos .str como contains(); para esos casos, use la indexación booleana con .str.
import pandas as pd
df = pd.DataFrame({
'country': ['USA', 'UK', 'Canada', 'USA', 'Germany'],
'sales': [400, 150, 200, 600, 300]
})
# Single quotes for the string value inside double-quoted query
result = df.query('country == "USA"')
print(result)
# country sales
# 0 USA 400
# 3 USA 600Uso de los operadores in y not in
Dentro de las cadenas de consulta, Pandas admite los operadores in y not in para comprobar la pertenencia, de forma similar a las listas de Python. Esta es una alternativa clara a encadenar varias condiciones == con or. La lista de valores se escribe directamente en la cadena de consulta.
import pandas as pd
df = pd.DataFrame({
'status': ['active', 'inactive', 'pending', 'active', 'closed'],
'amount': [100, 200, 50, 300, 150]
})
# Keep rows where status is in a specific list
result = df.query('status in ["active", "pending"]')
print(result)
# status amount
# 0 active 100
# 2 pending 50
# 3 active 300
# Exclude certain statuses
excluded = df.query('status not in ["closed", "inactive"]')
print(excluded.shape) # (3, 2)Filtros de rangos numéricos con query()
Las comparaciones encadenadas de Python, como 10 < price < 500, funcionan dentro de las cadenas de consulta, lo que permite expresar filtros de rango de forma muy intuitiva. Esto no es posible con la indexación booleana estándar sin usar between() o dos condiciones independientes combinadas con &.
import pandas as pd
df = pd.DataFrame({
'product': ['A', 'B', 'C', 'D', 'E'],
'price': [5, 50, 150, 300, 500]
})
# Chained comparison — only works inside query()
result = df.query('50 <= price <= 300')
print(result)
# product price
# 1 B 50
# 2 C 150
# 3 D 300Limitaciones de query()
query() es potente, pero tiene algunas limitaciones. Los nombres de columnas que contienen espacios o caracteres especiales necesitan escribirse entre comillas invertidas. Las expresiones de Python muy complejas, como las funciones personalizadas o la lógica de varias líneas, no son compatibles dentro de la cadena. Además, query() puede producir resultados inesperados si los nombres de columnas coinciden con palabras clave de Python, como class o if; en esos casos, escríbalos también entre comillas invertidas.
Para cualquier operación que query() no pueda expresar claramente, vuelva a utilizar la indexación booleana estándar.
import pandas as pd
df = pd.DataFrame({'first name': ['Alice', 'Bob'], 'class': [1, 2]})
# Backtick-quote column names with spaces or reserved words
result = df.query('`first name` == "Alice" and `class` == 1')
print(result)
# first name class
# 0 Alice 1Ejemplo práctico: filtrado de pedidos
A continuación se muestra una demostración práctica que combina query() con una referencia a una variable y un encadenamiento hasta groupby. Este patrón —filtrar primero y agregar después— evita procesar filas innecesarias, lo que resulta más claro y rápido en conjuntos de datos grandes.
import pandas as pd
orders = pd.DataFrame({
'region': ['East', 'West', 'East', 'West', 'East'],
'year': [2023, 2023, 2024, 2024, 2024],
'revenue': [100, 200, 300, 400, 500]
})
min_year = 2024
# Filter to recent orders in the East region, then sum revenue
summary = (
orders
.query('year >= @min_year and region == "East"')
.groupby('region')['revenue'].sum()
)
print(summary)
# region
# East 800
# Name: revenue, dtype: int64Prácticas recomendadas para query() y el encadenamiento de métodos
Usar query() dentro de una cadena de métodos es una práctica recomendada en el código moderno de Pandas. Esto hace que cada paso de la canalización de transformación sea claro y se explique por sí mismo. Encierre toda la cadena entre paréntesis para poder dividirla en varias líneas sin usar barras invertidas.
Combine query() con assign() para añadir columnas, groupby() para realizar agregaciones y pipe() para aplicar funciones personalizadas, y así crear canalizaciones completamente legibles.
import pandas as pd
df = pd.DataFrame({
'dept': ['Eng', 'HR', 'Eng', 'Sales', 'HR'],
'salary': [90000, 50000, 120000, 70000, 55000],
'years': [3, 5, 8, 2, 4]
})
result = (
df
.query('years > 2 and dept != "HR"')
.assign(bonus=lambda x: x['salary'] * 0.1)
.sort_values('salary', ascending=False)
)
print(result[['dept', 'salary', 'bonus']])
# dept salary bonus
# 2 Eng 120000 12000.0
# 0 Eng 90000 9000.0Comprobación rápida
Compruebe cuánto comprende del método query().
Resumen de la lección
En esta lección ha aprendido que query() acepta expresiones de filtrado como cadenas, lo que hace más legibles los filtros con varias condiciones; @variable_name inserta variables de Python en la consulta; y puede usar in/not in y comparaciones encadenadas, algo que no es posible con la indexación booleana estándar. A continuación, exploraremos isin() y between() para crear filtros concisos de pertenencia y de rango.
Preguntas frecuentes
¿La lección «El método query()» es gratis?
Sí — el texto completo de «El método query()» 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 «El método query()»?
Escriba expresiones de filtro legibles como cadenas con query(), use variables de Python dentro de las consultas mediante @ y encadene filtros. 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 2 de 4.
¿Cuánto tiempo toma la lección «El método query()»?
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