PricingLoginStart free
Pandas & NumPy Academy · leksjon

query()-metoden

Skriv lettleste filteruttrykk som strenger med query(), bruk Python-variabler i spørringer med @, og kjed sammen filtre.

Leksjon 2 av 413 trinn

query()-metoden er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Hvorfor bruke query()?

Boolsk indeksering i Pandas er kraftig, men kan bli omstendelig når du kombinerer mange betingelser. Metoden query() lar deg skrive filteruttrykk som vanlige strenger, noe mange synes er mer lesbart – særlig de som har bakgrunn fra SQL. I stedet for df[(df['age'] > 30) & (df['salary'] > 50000)] skriver du df.query('age > 30 and salary > 50000').

Spørringsstrengen evalueres mot kolonnenavnene i DataFrame-et, så kolonnenavn fungerer som variabelnavn inne i strengen.

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

Syntaksregler i en spørringsstreng

Inne i en spørringsstreng kan du bruke standardoperatorene for sammenligning i Python (>, <, ==, !=, >=, <=) og logiske operatorer som and, or og not. I motsetning til vanlig boolsk indeksering kan du bruke de engelske ordene her – du trenger verken ampersand-tegn eller pipe-tegn.

Kolonnenavn med mellomrom eller navn som kolliderer med Python-nøkkelord, må omsluttes av backticks: 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

Referere til Python-variabler med @

En viktig funksjon i query() er muligheten til å referere til Python-variabler fra det omkringliggende området ved hjelp av prefikset @. Dette gjør det enkelt å parameterisere filtre: Beregn en terskel, lagre den i en variabel, og bruk deretter @variable_name i spørringsstrengen i stedet for å skrive verdien direkte.

Dette mønsteret er svært nyttig i funksjoner som tar imot filterargumenter under kjøring.

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

Kjede kall til query()

Fordi query() returnerer et nytt DataFrame, kan du kjede flere kall til query() eller kombinere dem med andre Pandas-metoder i en pipeline. Kjedingen holder hvert filtreringstrinn på sin egen linje, noe som gjør logikken enkel å lese, feilsøke og endre.

Du kan også kjede query() med metoder som .groupby(), .sort_values() eller .head() for å bygge kompakte analysepipelines.

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

Sammenligne query() med boolsk indeksering

Begge metodene gir samme resultat, men de passer til ulike situasjoner. query() er spesielt godt egnet for filtre med flere betingelser som ellers ville krevd mange parenteser ved boolsk indeksering. Boolsk indeksering er bedre når betingelsen inneholder komplekse Python-uttrykk, for eksempel metodekall som ikke støttes i spørringsstrenger.

Ytelsen er omtrent den samme i de fleste tilfeller. query() kan være litt raskere på svært store DataFrame-er fordi metoden bruker numexpr-biblioteket internt.

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

Sammenligning av strenger i query()

Du kan filtrere på verdier i strengkolonner i en spørringsstreng ved å sette strenglitteralen i anførselstegn. Bruk doble anførselstegn rundt spørringsstrengen og enkle anførselstegn rundt strengverdien, eller omvendt – bare vær konsekvent. Merk at query() ikke støtter .str-metoder som contains(); bruk i stedet boolsk indeksering med .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

Bruke operatorene in og not in

Inne i spørringsstrenger støtter Pandas operatorene in og not in for medlemskapstester, på samme måte som i Python-lister. Dette er et ryddig alternativ til å kjede flere ==-betingelser med or. Listen over verdier skrives direkte i spørringsstrengen.

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)

Numeriske intervallfiltre med query()

Pythons kjede sammenligninger, for eksempel 10 < price < 500, fungerer i spørringsstrenger og gjør intervallfiltre svært uttrykksfulle. Dette er ikke mulig med standard boolsk indeksering uten å bruke between() eller to separate betingelser kombinert med &.

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

Begrensninger ved query()

query() er kraftig, men har noen begrensninger. Kolonnenavn med mellomrom eller spesialtegn må settes i backticks. Svært komplekse Python-uttrykk, som egendefinerte funksjoner og logikk over flere linjer, støttes ikke inne i strengen. query() kan også gi uventede resultater hvis kolonnenavn kolliderer med Python-nøkkelord som class eller if – sett også disse i backticks.

For alt query() ikke kan uttrykke på en ryddig måte, bør du gå tilbake til standard boolsk indeksering.

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

Praktisk eksempel: filtrere bestillinger

Her er en praktisk demonstrasjon som kombinerer query() med en variabelreferanse og kjeding til en groupby. Dette mønsteret – filtrer først, og aggreger deretter – unngår å behandle rader du ikke trenger, noe som både er tydeligere og raskere på store datasett.

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

Beste praksis for query() og kjeding av metoder

Å bruke query() i en metodekjede er beste praksis i moderne Pandas-kode. Det gjør hvert trinn i transformasjonspipelinen tydelig og selvforklarende. Omslutt hele kjeden med parenteser, slik at du kan dele den over flere linjer uten tilbakeskråstreker.

Kombiner query() med assign() for å legge til kolonner, groupby() for aggregering og pipe() for egendefinerte funksjoner, slik at du bygger lettleste pipelines.

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

Hurtigsjekk

Test forståelsen din av query()-metoden.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte du at query() godtar filteruttrykk som strenger, noe som gjør filtre med flere betingelser mer lesbare, at @variable_name setter inn Python-variabler i spørringen, og at du kan bruke in/not in og kjedede sammenligninger som ikke er mulig med standard boolsk indeksering. Deretter skal vi se på isin() og between() for kompakte medlemskaps- og intervallfiltre.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
30
Leksjoner
120
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «query()-metoden» gratis?

Ja – hele teksten i «query()-metoden» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «query()-metoden»?

Skriv lettleste filteruttrykk som strenger med query(), bruk Python-variabler i spørringer med @, og kjed sammen filtre. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?

Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «query()-metoden»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?

Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Boolsk indeksering av DataFrames
  2. query()-metoden
  3. Filtre med isin() og between()
  4. Velge kolonner etter mønster
← Tilbake til Pandas & NumPy Academy