0Pricing
Pandas & NumPy Academy · Lección

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   70000

Reglas 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      True

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

Encadenamiento 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      150

Comparació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  17

Comparaciones 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    600

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

Limitaciones 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      1

Ejemplo 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: int64

Prá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.0

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

  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