Pandas & NumPy Academy · Oppitunti

Pandas vai SQL: oikean työkalun valinta

Vertaa Pandasin groupby- ja merge-toimintoja SQL:n GROUP BY- ja JOIN-lauseisiin ja päätä, kummalla tasolla kukin muunnos kannattaa tehdä.

Oppitunti 4/413 vaihetta

Pandas vai SQL: oikean työkalun valinta on ilmainen Pandas & NumPy Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Pandas & NumPy Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Pandas & NumPy Academy-kurssilla on yhteensä 4 oppituntia.

Kaksi työkalua, toisiaan täydentävät vahvuudet

Sekä Pandas että SQL ovat tietojen käsittelyyn tarkoitettuja työkaluja, ja data-analyytikot käyttävät molempia. Keskeinen havainto on, että ne ovat toisiaan täydentäviä eivätkä kilpailevia: SQL soveltuu erinomaisesti deklaratiivisiin joukko-operaatioihin suurissa relaatiotietokantoihin tallennetuissa tauluissa, kun taas Pandas soveltuu erinomaisesti pakottavaan, rivi kerrallaan tapahtuvaan ja monimutkaiseen algoritmiseen muunnokseen, kun tiedot on jo ladattu muistiin. Parhaissa putkissa kumpaakin työkalua käytetään siihen, missä se on parhaimmillaan.

SQL:n vahvuudet: missä SQL on parempi

SQL on yleensä parempi, kun: dataa on paljon (gigatavuista teratavuihin) ja se on suodatettava ennen lataamista; liitokset kattavat useita suuria tauluja, jolloin tietokannan indeksit tarjoavat moninkertaisia nopeutuksia; koostamiset ovat yksinkertaisia (SUM, COUNT, GROUP BY); tulosjoukot ovat pieniä suhteessa syötteeseen; tai tarvitaan samanaikaisia luku- ja kirjoitustoimintoja (tietokanta käsittelee tapahtumat ja lukitukset). SQL:n deklaratiivisen syntaksin ansiosta kyselyoptimointiohjelmat voivat myös valita parhaan fyysisen suoritussuunnitelman automaattisesti.

-- 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;

Pandasin vahvuudet: missä Pandas on parempi

Pandas on yleensä parempi, kun tarvitaan mukautettua Python-logiikkaa, jota SQL ei pysty ilmaisemaan (koneoppimisen esikäsittely, mukautettu merkkijonojen jäsentäminen, monimutkaiset algoritmit); tietojen muunnosketjuissa on useita vaiheita; tarvitaan visualisointi heti analyysin jälkeen; data on jo muistissa ja uudet SQL-kierrokset lisäisivät viivettä; tai tehdään tutkivaa analyysia, jossa halutaan iteroida vuorovaikutteisesti. Pandas käsittelee myös taulukkomuodosta poikkeavia operaatioita, kuten matriisilaskentaa ja aikasarjojen tasoitusta.

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

SQL-operaatioiden vastaavuudet Pandasissa

Useimmilla SQL-operaatioilla on suora vastine Pandasissa. Molempien syntaksien tunteminen tekee teistä monipuolisempia ja auttaa kääntämään operaatiot työkalusta toiseen siirryttäessä. WHERE vastaa boolean-indeksointia tai .query()-kutsua; GROUP BY + SUM vastaa kutsua .groupby().sum(); JOIN vastaa kutsua pd.merge(); ORDER BY vastaa kutsua .sort_values(); ja DISTINCT vastaa kutsua .drop_duplicates(). Semanttinen merkitys on sama, vain syntaksi eroaa.

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)

Milloin datan koko ratkaisee valinnan

Käytännöllinen datan kokoon perustuva päätösmalli: alle 100 Mt — käytä pelkästään Pandasia, sillä SQL:n yleiskustannus ei ole sen arvoinen; 100 Mt – 10 Gt — suodata ja koostaa SQL:ssä ja lataa yhteenveto-DataFrame Pandasiin; 10 Gt – 1 Tt — käytä käsittelyyn SQL:ää tai Daskia ja Pandasia vain lopulliseen yhteenvetoon; yli 1 Tt — käytä hajautettua SQL:ää (BigQuery, Spark SQL, Redshift). Älä koskaan yritä ladata 100 Gt:n taulua Pandasiin 16 Gt:n kannettavalla — ohjelma kaatuu tai levy joutuu jatkuvan sivutuksen kuormittamaksi.

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:n ikkunafunktiot ja Pandasin rolling-operaatiot

SQL:n ikkunafunktiot (OVER (PARTITION BY ... ORDER BY ...)) ovat tehokkaita, mutta niillä on rajoituksensa: ne soveltuvat hyvin juoksevien sijoitusten, viiveiden ja ennakoivien arvojen sekä yksinkertaisten liukuvien aggregaattien laskemiseen, mutta monimutkaisia liukuvia tilastoja, kuten liukuvaa Pearsonin korrelaatiota, ei voi ilmaista SQL:llä. Pandasin rolling() ja expanding() kattavat paljon laajemman valikoiman ikkunalaskutoimituksia, mukaan lukien mukautetut funktiot .apply()-menetelmällä. Suurten aineistojen vakiomuotoisissa ikkunafunktioissa kannattaa suosia SQL:ää; monimutkaisessa ikkunalogiikassa kannattaa suosia Pandasia.

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

Monimutkaiset liitokset: Pandasin joustavuus

SQL-liitokset perustuvat avainten yhtäsuuruuteen muutamia poikkeuksia lukuun ottamatta. Pandasin pd.merge_asof() tukee epätarkkoja aikaperusteisia liitoksia (lähimmän avaimen etsimistä tarkan yhtäsuuruuden sijaan), mikä on erittäin hyödyllistä aikasarjojen kohdistamisessa, esimerkiksi osakehintojen liittämisessä kaupankäyntitapahtumiin lähimmän aiemman hinnan perusteella. Pandas tukee myös ehdollisia liitoksia, jotka toteutetaan merge-toiminnolla ja suodatuksella, kun taas SQL:ssä niiden ilmaisemiseen tarvitaan alikysely tai LATERAL-liitos. Nämä edistyneet liitosmallit ovat yksi alue, jolla Pandas on selvästi parempi.

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 aineiston profilointiin, SQL tuotantoon

Yleinen työnkulku on seuraava: käyttäkää Pandasia EDA:han ja aineiston profilointiin edustavalla otoksella, esimerkiksi ensimmäisellä miljoonalla rivillä, kehittäkää muunnoslogiikkaa iteroiden ja kääntäkää sitten keskeiset vaiheet SQL:ksi tuotantomittakaavaa varten. Pandas mahdollistaa nopean iteroinnin ja välittömän visuaalisen palautteen, kun taas SQL toimii luotettavasti suurilla aineistomäärillä vähäisellä infrastruktuurilla. Pitäkää toteutukset synkronoituna: kun lisäätte Pandasiin uuden ominaisuuden, kirjoittakaa tuotantoa varten vastaava SQL-tallennettu proseduurikutsu tai näkymä.

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: SQL-kyselyjen kirjoittaminen DataFrame-kehyksiä vasten

pandasql-kirjaston avulla voitte kirjoittaa SQL-kyselyjä suoraan Pandas DataFrame -kehyksiä vasten käyttämällä taustalla SQLiteä. sqldf('SELECT * FROM df WHERE amount > 100', locals()) suorittaa kyselyn df-DataFrame-kehykselle. Tämä on hyödyllistä, jos ajattelette SQL:n avulla mutta aineistonne on jo Pandasissa, tai jos opetatte SQL:n käsitteitä muistissa olevalla aineistolla. Se on kuitenkin useimmissa operaatioissa hitaampi kuin Pandasin natiivitoiminnot — käyttäkää sitä tuttuuden, ei suorituskyvyn vuoksi.

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

Päätöksenteon viitekehys: pikaopas

Käyttäkää tätä päätösopasta valitessanne SQL:n ja Pandasin välillä:

Onko aineisto tietokannassa ja suuri? Suodattakaa ja aggregoikaa ensin SQL:llä.
Tarvitsetteko mukautettua Python-logiikkaa? Käyttäkää Pandasia SQL-esisuodatuksen jälkeen.
Teettekö eksploratiivista analyysiä otoksella? Pandas mahdollistaa nopeamman iteroinnin.
Onko kyseessä aikasarja, jossa on monimutkaisia liukuvia tilastoja? Käyttäkää Pandasin rolling-/ewm-toimintoja.
Tarvitsetteko yksinkertaisen GROUP BY -kyselyn miljoonille riveille? Käyttäkää SQL:ää indeksien kanssa.
Onko muistissa jo useita pieniä DataFrame-kehyksiä? pd.merge() sopii tähän.
Tarvitsetteko ACID-transaktioita? Käyttäkää SQL-tietokantaa, älkää Pandasia.

Yhdistäkää molemmat: hybridiputki

Käytännöllisin lähestymistapa on hybridiputki, jossa hyödynnetään kummankin työkalun vahvuuksia. SQL käsittelee suurten raakadata-taulujen aineiston noudon, karkean suodatuksen ja vakiomuotoiset aggregoinnit. Tuloste — hallittavan kokoinen DataFrame — siirretään Pandasiin ominaisuuksien muodostamista, mukautettuja metriikoita, liukuvia tilastoja ja visualisointia varten. Tulokset voidaan haluttaessa kirjoittaa takaisin tietokantaan tarjoilua varten. Tämä putki on selkeä, skaalautuva ja ylläpidettävä kaikille analyytikoille, jotka tuntevat sekä SQL:n että Pythonin.

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

Pikatarkistus

Testatkaa tämän oppitunnin data-analyysin käsitteiden ymmärtämistä.

Vastaa interaktiivisessa oppitunnissa

Oppitunnin kertaus

Tässä oppitunnissa opitte, että SQL on parhaimmillaan indeksoidun aineiston laajamittaisessa suodatuksessa, liittämisessä ja yksinkertaisissa aggregoinneissa, Pandas on parhaimmillaan mukautetussa Python-logiikassa, monimutkaisissa liukuvissa tilastoissa ja eksploratiivisessa analyysissä, ja paras strategia on hybridiputki, jossa SQL:ää käytetään aineiston karkeaan supistamiseen ja Pandasia monimutkaisiin muunnoksiin hallittavan kokoiselle tulokselle. Seuraavaksi aloitamme päättelytilastotieteen SciPyllä: normaalisuustestit ja kuvailevat tilastot.

Aloita maksutta

Opi Python tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 30
Oppitunnit: 120

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Pandas vai SQL: oikean työkalun valinta” ilmainen?

Kyllä – oppitunnin ”Pandas vai SQL: oikean työkalun valinta” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Pandas & NumPy Academy-kurssin, päivitä CoddyKit PROhon. Pandas & NumPy Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Pandas vai SQL: oikean työkalun valinta”?

Vertaa Pandasin groupby- ja merge-toimintoja SQL:n GROUP BY- ja JOIN-lauseisiin ja päätä, kummalla tasolla kukin muunnos kannattaa tehdä. Harjoittelet Pandas & NumPy Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Pandas & NumPy Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Pandas & NumPy Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Pandas vai SQL: oikean työkalun valinta”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Pandas & NumPy Academy-oppitunnilla?

Kyllä. Jokainen Pandas & NumPy Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Yhteyden muodostaminen tietokantaan SQLAlchemylla
SQL-kyselyiden suorittaminen Pandasista
DataFrame-rakenteiden kirjoittaminen tietokantatauluihin
Pandas vai SQL: oikean työkalun valinta

← Takaisin: Pandas & NumPy Academy