Pandas & NumPy Academy · Lektion

Pandas kontra SQL: välj rätt verktyg

Jämför groupby/merge i Pandas med GROUP BY/JOIN i SQL och avgör vilket lager som ska hantera varje transformering.

Lektion 4 av 413 steg

Pandas kontra SQL: välj rätt verktyg är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Pandas & NumPy Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Två verktyg med kompletterande styrkor

Både Pandas och SQL är verktyg för databearbetning och båda används av professionella dataanalytiker. Den viktiga insikten är att de är kompletterande, inte konkurrerande: SQL är bäst på deklarativa mängdbaserade operationer på stora tabeller i relationsdatabaser, medan Pandas är bäst på imperativa transformationer rad för rad och på komplexa algoritmiska transformationer av data som redan har lästs in i minnet. De bästa pipelinerna använder varje verktyg till det som det är bäst på.

SQL:s styrkor: det SQL gör bättre

SQL är i allmänhet överlägset när: datamängden är stor (gigabyte till terabyte) och måste filtreras före inläsning; joinar omfattar flera stora tabeller där databasindex ger storleksordningars snabbare körning; aggregeringarna är enkla (SUM, COUNT, GROUP BY); resultatmängderna är små i förhållande till indata; eller när samtidiga läsningar och skrivningar behövs (databasen hanterar transaktioner och låsning). SQL:s deklarativa syntax låter dessutom frågeoptimeraren automatiskt välja den bästa fysiska 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 styrkor: det Pandas gör bättre

Pandas är i allmänhet överlägset när: du behöver anpassad Python-logik som SQL inte kan uttrycka (förbehandling för maskininlärning, anpassad strängtolkning och komplexa algoritmer); datatransformationskedjor består av många steg; du behöver visualisering direkt efter analysen; data redan finns i minnet och ytterligare SQL-anrop skulle öka fördröjningen; eller när du gör en explorativ analys där du vill arbeta interaktivt. Pandas hanterar också icke-tabellbaserade operationer som matrिसberäkningar och utjämning 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')

Mappa SQL-operationer till Pandas

De flesta SQL-operationer har direkta motsvarigheter i Pandas. Om du kan båda syntaxerna blir du mer mångsidig och kan lättare översätta mellan dem när du växlar mellan verktyg. WHERE motsvaras av boolesk indexering eller .query(); GROUP BY + SUM motsvaras av .groupby().sum(); JOIN motsvaras av pd.merge(); ORDER BY motsvaras av .sort_values(); och DISTINCT motsvaras av .drop_duplicates(). Den semantiska betydelsen är identisk, det är bara syntaxen som skiljer sig.

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 datamängden avgör valet

En praktisk beslutsmodell baserad på datamängden: under 100 MB — använd enbart Pandas, SQL-överheaden är inte värd det; 100 MB–10 GB — filtrera och aggregera i SQL och läs in en sammanfattande DataFrame i Pandas; 10 GB–1 TB — använd SQL eller Dask för bearbetningen och Pandas endast för den slutliga sammanfattningen; över 1 TB — använd distribuerad SQL (BigQuery, Spark SQL, Redshift). Försök aldrig läsa in en tabell på 100 GB i Pandas på en bärbar dator med 16 GB RAM — datorn kommer att krascha eller börja växla data mot disken.

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-fönsterfunktioner jämfört med Pandas rolling

SQL:s fönsterfunktioner (OVER (PARTITION BY ... ORDER BY ...)) är kraftfulla men har begränsningar: de beräknar löpande rangordningar, lag/lead och enkla rullande aggregat väl, men komplex rullande statistik (till exempel rullande Pearson-korrelation) kan inte uttryckas i SQL. Pandas rolling() och expanding() täcker ett mycket bredare spektrum av fönsterberäkningar, inklusive anpassade funktioner via .apply(). För standardiserade fönsterfunktioner på stora datamängder bör Ni föredra SQL; för komplex fönsterlogik bör Ni föredra 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())

Komplexa join-operationer: Pandas flexibilitet

SQL-join-operationer baseras på likhet mellan nycklar (med vissa undantag). Pandas pd.merge_asof() stöder ungefärliga tidsbaserade join-operationer (matchning mot den närmaste nyckeln i stället för exakt likhet), vilket är ovärderligt för justering av tidsserier (till exempel att koppla aktiekurser till handelshändelser vid den närmast föregående kursen). Pandas stöder också villkorsstyrda join-operationer genom att använda merge följt av filtrering, något som i SQL kräver en underfråga eller en LATERAL-join för att uttryckas. Dessa avancerade join-mönster är ett område där Pandas tydligt är bättre.

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 för dataprofilering, SQL för produktion

Ett vanligt arbetsflöde är att använda Pandas för EDA och dataprofilering på ett representativt urval (till exempel de första miljon raderna), iterativt utveckla transformeringslogiken och sedan översätta de viktigaste stegen till SQL för produktionsskala. Pandas möjliggör snabb iteration med omedelbar visuell återkoppling; SQL körs tillförlitligt i stor skala med minimal infrastruktur. Håll de två i synk: när Ni lägger till en ny funktion i Pandas bör Ni skriva motsvarande lagrade SQL-procedur eller vy för produktion.

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: skriva SQL mot DataFrames

Biblioteket pandasql låter Er skriva SQL-frågor direkt mot Pandas DataFrames med SQLite i bakgrunden. sqldf('SELECT * FROM df WHERE amount > 100', locals()) kör frågan på df-DataFrame. Detta är användbart om Ni tänker i SQL men redan har data i Pandas, eller om Ni vill undervisa i SQL-koncept med data i minnet. Det är dock långsammare än inbyggd Pandas för de flesta operationer — använd det för bekantskap, inte för prestanda.

# 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)

Beslutsramverk: en snabbguide

Använd denna beslutsguide när Ni väljer mellan SQL och Pandas:

Finns data i en databas OCH är den stor? Filtrera och aggregera först i SQL.
Behöver Ni anpassad Python-logik? Använd Pandas efter ett SQL-förfilter.
Explorativ analys på ett urval? Pandas ger snabbare iteration.
Tidsserier med komplex rullande statistik? Pandas rolling/ewm.
Enkel GROUP BY på miljontals rader? SQL med index.
Har Ni redan flera små DataFrames i minnet? pd.merge() fungerar bra.
Behöver Ni ACID-transaktioner? En SQL-databas, inte Pandas.

Kombinera båda: den hybrida datapipelinen

Det mest praktiska tillvägagångssättet är en hybrid datapipeline som utnyttjar varje verktygs styrkor. SQL hanterar inläsning, grov filtrering och standardaggregeringar på stora råtabeller. Resultatet — en hanterbar DataFrame — överlämnas till Pandas för funktionskonstruktion, anpassade mått, rullande statistik och visualisering. Resultaten kan vid behov skrivas tillbaka till databasen för användning. Denna pipeline är lättläst, skalbar och underhållbar för alla analytiker som kan både SQL och 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())

Snabb kontroll

Testa Er förståelse av dataanalysens begrepp från denna lektion.

Besvara frågan i den interaktiva lektionen

Lektionssammanfattning

I denna lektion har Ni lärt Er att SQL är bäst för filtrering, join-operationer och enkla aggregeringar i stor skala på indexerade data, att Pandas är bäst för anpassad Python-logik, komplex rullande statistik och explorativ analys, samt att den bästa strategin är en hybrid pipeline som använder SQL för grov reducering och Pandas för komplexa transformationer av det hanterbara resultatet. Nästa steg är att börja med inferentiell statistik i SciPy: normalitetstest och deskriptiv statistik.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 30
Lektioner: 120

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Pandas kontra SQL: välj rätt verktyg” gratis?

Ja – hela texten till ”Pandas kontra SQL: välj rätt verktyg” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Pandas & NumPy Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Pandas kontra SQL: välj rätt verktyg”?

Jämför groupby/merge i Pandas med GROUP BY/JOIN i SQL och avgör vilket lager som ska hantera varje transformering. Ni övar på Pandas & NumPy Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Pandas & NumPy Academy?

Du behöver inga förkunskaper. Utbildningen i Pandas & NumPy Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Pandas kontra SQL: välj rätt verktyg”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Pandas & NumPy Academy-lektionen?

Ja. Varje Pandas & NumPy Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Pandas & NumPy Academy