PricingLoginStart free
Pandas & NumPy Academy · leksjon

Pandas kontra SQL: Velg riktig verktøy

Sammenlign groupby/merge i Pandas med GROUP BY/JOIN i SQL, og avgjør hvilket lag som bør håndtere hver transformasjon.

Leksjon 4 av 413 trinn

Pandas kontra SQL: Velg riktig verktøy er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 4 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.

To verktøy med komplementære styrker

Både Pandas og SQL er verktøy for databehandling, og begge brukes av profesjonelle dataanalytikere. Den viktigste innsikten er at de er komplementære, ikke konkurrerende: SQL er svært godt egnet til deklarative, mengdebaserte operasjoner på store tabeller som er lagret i relasjonsdatabaser, mens Pandas er svært godt egnet til imperative transformasjoner rad for rad og komplekse algoritmiske transformasjoner på data som allerede er lastet inn i minnet. De beste pipelinene bruker hvert verktøy til det det er best på.

SQLs styrker: Det SQL gjør bedre

SQL er vanligvis best når: datamengden er stor (gigabyte til terabyte) og må filtreres før innlasting; koblinger omfatter flere store tabeller der databaseindekser gir hastighetsforbedringer på en størrelsesorden; aggregeringene er enkle (SUM, COUNT, GROUP BY); resultatsettene er små sammenlignet med inndataene; eller samtidige lesinger og skrivinger er nødvendige (databasen håndterer transaksjoner og låsing). Den deklarative SQL-syntaksen lar også spørringsoptimalisatorer automatisk velge den beste fysiske planen.

-- SQL excels at:
-- 1. Filtering billions of rows using an index
SELECT * FROM orders WHERE customer_id = 12345;

-- 2. Joining large tables efficiently
SELECT o.order_id, c.name, SUM(o.amount)
FROM orders o
JOIN customers c ON o.customer_id = c.id
GROUP BY o.order_id, c.name;

-- 3. Window functions on ordered data
SELECT order_id, amount,
       SUM(amount) OVER (PARTITION BY customer_id ORDER BY order_date)
FROM orders;

Pandas' styrker: Det Pandas gjør bedre

Pandas er vanligvis best når: De trenger egendefinert Python-logikk som SQL ikke kan uttrykke (forbehandling for maskinlæring, egendefinert strengbehandling og komplekse algoritmer); datatransformasjonskjedene består av mange trinn; De trenger visualisering umiddelbart etter analysen; dataene allerede ligger i minnet og flere turer til SQL ville medført forsinkelser; eller De utfører utforskende analyse og ønsker å arbeide interaktivt. Pandas håndterer også ikke-tabellariske operasjoner, for eksempel matriseberegninger og utjevning av tidsserier.

import pandas as pd

# Pandas excels at:
# 1. Custom Python logic that SQL cannot express
df['clean_name'] = df['name'].str.strip().str.title().str.replace(r'[^a-zA-Z ]', '', regex=True)

# 2. Vectorised string parsing
df[['first', 'last']] = df['full_name'].str.split(' ', n=1, expand=True)

# 3. Rolling statistics and time series
df['7day_avg'] = df['daily_sales'].rolling(7).mean()

# 4. Direct visualisation
# df.groupby('category')['sales'].sum().plot(kind='bar')

Koble SQL-operasjoner til Pandas

De fleste SQL-operasjoner har direkte motstykker i Pandas. Når De kjenner begge syntaksene, blir De mer allsidig og kan lettere oversette mellom dem når De bytter verktøy. WHERE blir boolsk indeksering eller .query(); GROUP BY + SUM blir .groupby().sum(); JOIN blir pd.merge(); ORDER BY blir .sort_values(); og DISTINCT blir .drop_duplicates(). Den semantiske betydningen er identisk; det er bare syntaksen som er forskjellig.

import pandas as pd

df = pd.DataFrame({'region': ['N','S','N','E'], 'amount': [100,200,150,300]})

# SQL: SELECT region, SUM(amount) FROM df WHERE amount>100 GROUP BY region ORDER BY region
# Pandas:
result = (
    df[df['amount'] > 100]
    .groupby('region')['amount']
    .sum()
    .reset_index()
    .sort_values('region')
)
print(result)

Når datamengden avgjør valget

Et praktisk beslutningsrammeverk basert på datamengde: under 100 MB — bruk Pandas til alt, siden SQL-overheaden ikke er verdt det; 100 MB–10 GB — filtrer og aggreger i SQL, og last inn en oppsummerende DataFrame i Pandas; 10 GB–1 TB — bruk SQL eller Dask til behandlingen, og Pandas bare til det endelige sammendraget; over 1 TB — bruk distribuert SQL (BigQuery, Spark SQL, Redshift). Prøv aldri å laste inn en tabell på 100 GB i Pandas på en bærbar datamaskin med 16 GB minne — programmet vil krasje eller begynne å bruke disken intensivt.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///large.db')

# Right approach: SQL handles the heavy lifting
summary_df = pd.read_sql_query(
    '''
    SELECT region, product_category,
           SUM(revenue) AS total_revenue,
           COUNT(DISTINCT customer_id) AS unique_customers
    FROM orders
    WHERE order_date >= '2024-01-01'
    GROUP BY region, product_category
    ''',
    con=engine
)
# summary_df is small — now do Pandas things on it
print(summary_df.sort_values('total_revenue', ascending=False))

SQL-vindusfunksjoner kontra rullerende Pandas-beregninger

SQLs vindusfunksjoner (OVER (PARTITION BY ... ORDER BY ...)) er kraftige, men har begrensninger: De beregner løpende rangeringer, lag/lead og enkle rullerende aggregater godt, men komplekse rullerende statistiske mål (for eksempel rullerende Pearson-korrelasjon) kan ikke uttrykkes i SQL. Pandas' rolling() og expanding() dekker et langt større utvalg av vindusberegninger, inkludert egendefinerte funksjoner via .apply(). For standardvindusfunksjoner på store datamengder bør De foretrekke SQL; for kompleks vinduslogikk bør De foretrekke Pandas.

import pandas as pd

df = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=30),
    'sales': [100 + i*10 + (i%7)*20 for i in range(30)]
})

# Pandas rolling — easy with arbitrary window functions
df['7d_mean'] = df['sales'].rolling(7).mean()
df['7d_std']  = df['sales'].rolling(7).std()
df['7d_corr'] = df['sales'].rolling(7).corr(df['sales'].shift(1))
print(df.tail())

Komplekse koblinger: Pandas' fleksibilitet

SQL-koblinger er basert på likhet mellom nøkler (med enkelte unntak). Pandas pd.merge_asof() støtter uskarpe tidsbaserte koblinger (kobling mot den nærmeste nøkkelen i stedet for eksakt likhet), noe som er svært nyttig for justering av tidsserier (for eksempel ved å koble aksjekurser til handelshendelser med nærmeste foregående kurs). Pandas støtter også betingede koblinger ved å bruke merge etterfulgt av filtrering, noe som i SQL krever en subquery eller en LATERAL-kobling. Disse avanserte koblingsmønstrene er et område der Pandas tydelig har et fortrinn.

import pandas as pd

trades = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:05', '2024-01-01 10:12']),
    'symbol': ['AAPL', 'AAPL', 'AAPL'],
    'shares': [100, 200, 50]
})
prices = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:10']),
    'price': [185.0, 186.5]
})

# Fuzzy join: match each trade to the nearest preceding price
result = pd.merge_asof(trades.sort_values('time'),
                       prices.sort_values('time'),
                       on='time', direction='backward')
print(result)

Pandas for dataprofiler, SQL for produksjon

Et vanlig arbeidsmønster er å bruke Pandas til EDA og dataprofiler på et representativt utvalg (for eksempel de første én million radene), utvikle transformasjonslogikken trinnvis og deretter oversette de viktigste stegene til SQL for produksjonsskala. Pandas gjør det mulig å iterere raskt med umiddelbar visuell tilbakemelding, mens SQL kjører pålitelig i stor skala med et minimum av infrastruktur. Hold de to i synk: Når De legger til en ny funksjon i Pandas, bør De skrive den tilsvarende lagrede SQL-prosedyren eller visningen for produksjon.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///data.db')

# Development: sample in Pandas for fast iteration
df_sample = pd.read_sql_query(
    'SELECT * FROM orders ORDER BY RANDOM() LIMIT 10000',
    con=engine
)
# Explore and prototype:
df_sample['revenue_tier'] = pd.cut(
    df_sample['amount'],
    bins=[0, 100, 500, float('inf')],
    labels=['low', 'mid', 'high']
)
print(df_sample['revenue_tier'].value_counts())
# Production: translate cut logic to SQL CASE WHEN

pandasql: Skrive SQL mot DataFrames

Biblioteket pandasql lar Dem skrive SQL-spørringer direkte mot Pandas DataFrames ved å bruke SQLite i bakgrunnen. sqldf('SELECT * FROM df WHERE amount > 100', locals()) kjører spørringen på df-DataFrame-objektet. Dette er nyttig hvis De tenker i SQL, men dataene allerede ligger i Pandas, eller når De skal undervise i SQL-konsepter med data i minnet. Det er imidlertid tregere enn innebygd Pandas for de fleste operasjoner — bruk det for gjenkjennelighet, ikke ytelse.

# pip install pandasql
import pandas as pd
# from pandasql import sqldf

df = pd.DataFrame({
    'product': ['A', 'B', 'A', 'C', 'B'],
    'sales': [100, 200, 150, 80, 220]
})

# With pandasql (commented out as it requires install):
# result = sqldf('SELECT product, SUM(sales) AS total FROM df GROUP BY product', locals())

# Equivalent native Pandas:
result = df.groupby('product')['sales'].sum().reset_index()
print(result)

Beslutningsrammeverk: En rask referanse

Bruk denne veiledningen når De skal velge mellom SQL og Pandas:

  • Ligger dataene i en database, og er de omfattende? Filtrer og aggreger i SQL først.
  • Trenger De egendefinert Python-logikk? Bruk Pandas etter et SQL-forfilter.
  • Utforskende analyse på et utvalg? Pandas gir raskere iterasjon.
  • Tidsserier med komplekse rullerende statistiske mål? Pandas rolling/ewm.
  • Enkel GROUP BY på millioner av rader? SQL med indekser.
  • Har De allerede flere små DataFrames i minnet? pd.merge() fungerer fint.
  • Trenger De ACID-transaksjoner? SQL-database, ikke Pandas.

Kombiner begge: Den hybride datapipelinen

Den mest praktiske tilnærmingen er en hybrid datapipeline som utnytter styrkene til hvert verktøy. SQL håndterer innlasting, grovfiltrering og standardaggregeringer på store råtabeller. Resultatet — en håndterlig DataFrame — sendes til Pandas for utvikling av variabler, egendefinerte måltall, rullerende statistikk og visualisering. Resultatene kan eventuelt skrives tilbake til databasen for bruk. Denne pipelinen er oversiktlig, skalerbar og enkel å vedlikeholde for alle analytikere som kjenner både SQL og Python.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///pipeline.db')

# Step 1: SQL coarse aggregation
df = pd.read_sql_query('''
    SELECT DATE(order_date) AS date, region, SUM(amount) AS daily_revenue
    FROM orders WHERE status = 'completed'
    GROUP BY DATE(order_date), region
    ORDER BY date
''', con=engine, parse_dates=['date'])

# Step 2: Pandas rolling and pivoting (hard in SQL)
df['7d_avg'] = df.groupby('region')['daily_revenue'].transform(
    lambda x: x.rolling(7, min_periods=1).mean()
)
pivot = df.pivot(index='date', columns='region', values='7d_avg')
print(pivot.tail())

Rask kontroll

Test forståelsen Deres av konsepter innen dataanalyse fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at SQL er best til filtrering, kobling og enkle aggregeringer i stor skala på indekserte data, at Pandas er best til egendefinert Python-logikk, kompleks rullerende statistikk og utforskende analyse, og at den beste strategien er en hybrid datapipeline som bruker SQL til grov reduksjon og Pandas til komplekse transformasjoner av det håndterlige resultatet. Neste tema er inferensiell statistikk med SciPy: testing av normalitet og deskriptiv statistikk.

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 «Pandas kontra SQL: Velg riktig verktøy» gratis?

Ja – hele teksten i «Pandas kontra SQL: Velg riktig verktøy» 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 «Pandas kontra SQL: Velg riktig verktøy»?

Sammenlign groupby/merge i Pandas med GROUP BY/JOIN i SQL, og avgjør hvilket lag som bør håndtere hver transformasjon. 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 4 av 4.

Hvor lang tid tar leksjonen «Pandas kontra SQL: Velg riktig verktøy»?

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. Koble til en database med SQLAlchemy
  2. Kjøre SQL-spørringer fra Pandas
  3. Skrive DataFrames til databasetabeller
  4. Pandas kontra SQL: Velg riktig verktøy
← Tilbake til Pandas & NumPy Academy