Pandas & NumPy Academy · Aula

O método query()

Escreva expressões de filtro legíveis como strings com query(), use variáveis Python dentro das consultas com @ e encadeie filtros.

Aula 2 de 413 etapas

O método query() é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

Por que usar query()?

A indexação booleana do Pandas é poderosa, mas pode ficar prolixa ao combinar muitas condições. O método query() permite escrever expressões de filtro como strings simples, o que muitas pessoas consideram mais legível — especialmente quem vem de uma experiência com SQL. Em vez de df[(df['age'] > 30) & (df['salary'] > 50000)], escreva df.query('age > 30 and salary > 50000').

A string da consulta é avaliada com base nos nomes das colunas do DataFrame, portanto os nomes das colunas funcionam como nomes de variáveis dentro da string.

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

Regras de sintaxe dentro de uma string de consulta

Dentro de uma string de consulta, você pode usar os operadores de comparação padrão do Python (>, <, ==, !=, >=, <=) e os conectores lógicos and, or, not. Diferentemente da indexação booleana comum, aqui você pode usar as palavras em inglês — não é necessário usar e comerciais ou barras verticais.

Nomes de colunas com espaços ou que entrem em conflito com palavras-chave do Python devem ser delimitados por crases: 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

Referenciando variáveis do Python com @

Um recurso importante de query() é a possibilidade de referenciar variáveis do Python do escopo ao redor usando o prefixo @. Isso facilita a parametrização de filtros: calcule um limite, armazene-o em uma variável e use @variable_name dentro da string da consulta em vez de inserir o valor diretamente.

Esse padrão é muito útil em funções que aceitam argumentos de filtro durante a execução.

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

Encadeando chamadas de query()

Como query() retorna um novo DataFrame, você pode encadear várias chamadas de query ou combiná-las com outros métodos do Pandas em um pipeline. O encadeamento mantém cada etapa de filtragem em sua própria linha, facilitando a leitura, a depuração e a modificação da lógica.

Você também pode encadear query() com métodos como .groupby(), .sort_values() ou .head() para criar pipelines de análise concisos.

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

Comparando query() com a indexação booleana

Ambos os métodos produzem o mesmo resultado, mas cada um é adequado a uma situação. query() é excelente para filtros com várias condições que exigiriam muitos parênteses na indexação booleana. A indexação booleana é melhor quando sua condição envolve expressões complexas do Python, como chamadas de métodos que não são compatíveis com strings de consulta.

O desempenho é semelhante na maioria dos casos; query() pode ser um pouco mais rápido em DataFrames muito grandes porque usa a 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

Comparações de strings em query()

Você pode filtrar valores de colunas de strings dentro de uma string de consulta colocando o literal de string entre aspas. Use aspas duplas para a string de consulta externa e aspas simples para o valor da string, ou vice-versa — basta manter a consistência. Observe que query() não oferece suporte a métodos .str, como contains(); nesses casos, use a indexação booleana com .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

Usando os operadores in e not in

Dentro das strings de consulta, o Pandas oferece suporte aos operadores in e not in para testes de pertencimento, de forma semelhante às listas do Python. Essa é uma alternativa clara ao encadeamento de várias condições == com or. A lista de valores é escrita diretamente na string da 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 intervalo numérico com query()

As comparações encadeadas do Python, como 10 < price < 500, funcionam dentro de strings de consulta, tornando os filtros de intervalo muito expressivos. Isso não é possível com a indexação booleana padrão sem usar between() ou duas condições separadas combinadas com &.

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

Limitações de query()

query() é poderoso, mas tem algumas limitações. Nomes de colunas com espaços ou caracteres especiais precisam ser delimitados por crases. Expressões muito complexas do Python, como funções personalizadas e lógica distribuída em várias linhas, não são compatíveis dentro da string. Além disso, query() pode produzir resultados inesperados se os nomes das colunas entrarem em conflito com palavras-chave do Python, como class ou if — delimite esses nomes com crases também.

Para qualquer situação que query() não consiga expressar de forma clara, recorra à indexação booleana padrão.

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

Exemplo prático: filtrando pedidos

Aqui está uma demonstração prática que combina query() com uma referência a uma variável e um encadeamento até um groupby. Esse padrão — filtrar primeiro e agregar depois — evita processar linhas desnecessárias, o que é mais claro e mais rápido em grandes conjuntos de dados.

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áticas recomendadas para query() e encadeamento de métodos

Usar query() dentro de um encadeamento de métodos é uma prática recomendada no código moderno do Pandas. Isso torna cada etapa do pipeline de transformação clara e autodocumentada. Coloque todo o encadeamento entre parênteses para poder dividi-lo em várias linhas sem barras invertidas.

Combine query() com assign() para adicionar colunas, groupby() para agregações e pipe() para funções personalizadas, criando pipelines totalmente legíveis.

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

Verificação rápida

Teste sua compreensão do método query().

Resumo da lição

Nesta lição, você aprendeu que: query() aceita expressões de filtro como strings, tornando os filtros com várias condições mais legíveis; @variable_name insere variáveis do Python na consulta; e é possível usar in/not in e comparações encadeadas, algo que não é possível com a indexação booleana padrão. A seguir, exploraremos isin() e between() para criar filtros concisos de pertencimento e intervalo.

Grátis para começar

Aprenda Python com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
30
Aulas
120

Perguntas Frequentes

A aula “O método query()” é grátis?

Sim — o texto completo de “O método query()” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

O que vou aprender em “O método query()”?

Escreva expressões de filtro legíveis como strings com query(), use variáveis Python dentro das consultas com @ e encadeie filtros. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Pandas & NumPy Academy?

Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “O método query()”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Pandas & NumPy Academy?

Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Indexação booleana em DataFrames
  2. O método query()
  3. Filtros isin() e between()
  4. Selecionando colunas por padrão
← Voltar para Pandas & NumPy Academy