Pandas & NumPy Academy · Lekcja

Pandas a SQL: wybór odpowiedniego narzędzia

Porównaj groupby/merge w Pandas z GROUP BY/JOIN w SQL i zdecyduj, która warstwa powinna obsługiwać poszczególne transformacje.

Pandas a SQL: wybór odpowiedniego narzędzia to bezpłatna lekcja Pandas & NumPy Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Pandas & NumPy Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Pandas & NumPy Academy zawiera 4 lekcji w sumie.

Dwa narzędzia, uzupełniające się zalety

Zarówno Pandas, jak i SQL służą do manipulowania danymi i oba narzędzia są używane przez profesjonalnych analityków danych. Kluczowy wniosek jest taki, że są one uzupełniające się, a nie konkurencyjne: SQL doskonale sprawdza się w deklaratywnych operacjach na zbiorach wykonywanych na dużych tabelach przechowywanych w relacyjnych bazach danych, natomiast Pandas lepiej nadaje się do imperatywnych przekształceń wiersz po wierszu oraz złożonych przekształceń algorytmicznych na danych już wczytanych do pamięci. Najlepsze potoki wykorzystują każde narzędzie do zadań, w których sprawdza się ono najlepiej.

Zalety SQL: co SQL robi lepiej

SQL jest zazwyczaj lepszym rozwiązaniem, gdy: danych jest dużo (od gigabajtów do terabajtów) i trzeba je odfiltrować przed wczytaniem; złączenia obejmują wiele dużych tabel, a indeksy bazy danych zapewniają wielokrotne przyspieszenie; agregacje są proste (SUM, COUNT, GROUP BY); zbiory wyników są małe w porównaniu z danymi wejściowymi; lub potrzebne są jednoczesne odczyty i zapisy (baza danych obsługuje transakcje i blokady). Deklaratywna składnia SQL pozwala także optymalizatorom zapytań automatycznie wybierać najlepszy plan fizycznego wykonania.

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

Zalety Pandas: co Pandas robi lepiej

Pandas jest zazwyczaj lepszym rozwiązaniem, gdy potrzebna jest niestandardowa logika języka Python, której nie można wyrazić w SQL (wstępne przetwarzanie na potrzeby uczenia maszynowego, niestandardowe analizowanie ciągów znaków, złożone algorytmy); łańcuchy przekształceń danych składają się z wielu kroków; potrzebna jest natychmiastowa wizualizacja po analizie; dane są już w pamięci, a kolejne odwołania do SQL zwiększałyby opóźnienie; lub wykonywana jest analiza eksploracyjna wymagająca interaktywnego iterowania. Pandas obsługuje również operacje nietabelaryczne, takie jak obliczenia macierzowe i wygładzanie szeregów czasowych.

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

Mapowanie operacji SQL na Pandas

Większość operacji SQL ma bezpośrednie odpowiedniki w Pandas. Znajomość obu składni zwiększa wszechstronność i ułatwia przechodzenie między narzędziami. WHERE odpowiada indeksowaniu logicznemu lub .query(); GROUP BY + SUM odpowiada .groupby().sum(); JOIN odpowiada pd.merge(); ORDER BY odpowiada .sort_values(); a DISTINCT odpowiada .drop_duplicates(). Znaczenie semantyczne jest identyczne — różni się tylko składnia.

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)

Gdy rozmiar danych decyduje o wyborze

Praktyczne wytyczne dotyczące wyboru na podstawie rozmiaru danych: poniżej 100 MB — należy używać wyłącznie Pandas, ponieważ narzut SQL nie jest wart poniesienia; od 100 MB do 10 GB — należy filtrować i agregować dane w SQL, a następnie wczytać do Pandas podsumowującą strukturę DataFrame; od 10 GB do 1 TB — należy używać SQL lub Dask do przetwarzania, a Pandas tylko do końcowego podsumowania; powyżej 1 TB — należy używać rozproszonego SQL (BigQuery, Spark SQL, Redshift). Nie należy próbować wczytywać tabeli o rozmiarze 100 GB do Pandas na laptopie z 16 GB pamięci — spowoduje to awarię programu lub intensywne użycie dysku.

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

Funkcje okna SQL a operacje rolling w Pandas

SQL-owe funkcje okna (OVER (PARTITION BY ... ORDER BY ...)) są potężne, ale mają ograniczenia: dobrze obliczają rangi narastające, wartości opóźnione i wyprzedzające oraz proste agregaty kroczące, jednak złożonych statystyk kroczących (np. kroczącej korelacji Pearsona) nie da się wyrazić w SQL. Funkcje rolling() i expanding() biblioteki Pandas obejmują znacznie szerszy zakres obliczeń okienkowych, w tym funkcje niestandardowe za pomocą .apply(). W przypadku standardowych funkcji okna na dużych zbiorach danych należy preferować SQL, a w przypadku złożonej logiki okienkowej — 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())

Złożone złączenia: elastyczność Pandas

Złączenia SQL opierają się na równości kluczy (z pewnymi wyjątkami). Funkcja Pandas pd.merge_asof() obsługuje przybliżone złączenia oparte na czasie (dopasowuje najbliższy klucz zamiast wymagać dokładnej równości), co jest niezwykle przydatne przy wyrównywaniu szeregów czasowych (np. przy łączeniu cen akcji ze zdarzeniami transakcyjnymi według najbliższej wcześniejszej ceny). Pandas obsługuje również złączenia warunkowe za pomocą merge, a następnie filtrowania; w SQL trzeba do tego użyć podzapytania lub złączenia LATERAL. Te zaawansowane wzorce złączeń to jeden z obszarów, w których Pandas wyraźnie przewyższa SQL.

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 do profilowania danych, SQL na potrzeby produkcji

Typowy schemat pracy wygląda następująco: użyj Pandas do EDA i profilowania danych na reprezentatywnej próbce (np. na pierwszym milionie wierszy), iteracyjnie opracuj logikę transformacji, a następnie przenieś kluczowe kroki do SQL, aby obsłużyć skalę produkcyjną. Pandas umożliwia szybką iterację i natychmiastową wizualną informację zwrotną, natomiast SQL działa niezawodnie na dużą skalę przy minimalnej infrastrukturze. Należy utrzymywać oba rozwiązania w zgodności: po dodaniu nowej funkcji w Pandas należy napisać odpowiadającą jej procedurę składowaną lub widok SQL na potrzeby produkcji.

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: pisanie zapytań SQL dla ramek danych

Biblioteka pandasql umożliwia pisanie zapytań SQL bezpośrednio dla ramek danych Pandas, wykorzystując wewnętrznie SQLite. Wyrażenie sqldf('SELECT * FROM df WHERE amount > 100', locals()) wykonuje zapytanie na ramce danych df. Jest to przydatne, jeśli myślą Państwo w kategoriach SQL, ale dane znajdują się już w Pandas, a także podczas nauki pojęć związanych z SQL na danych przechowywanych w pamięci. Jednak w przypadku większości operacji rozwiązanie to jest wolniejsze niż natywny Pandas — należy używać go ze względu na znajomość składni, a nie wydajność.

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

Schemat decyzyjny: szybki przewodnik

Przy wyborze między SQL a Pandas należy skorzystać z poniższych wskazówek:

Dane znajdują się w bazie danych i jest ich dużo? Najpierw filtruj i agreguj je w SQL.
Potrzebujesz niestandardowej logiki w Pythonie? Użyj Pandas po wstępnym filtrowaniu w SQL.
Analiza eksploracyjna na próbce? Pandas zapewnia szybszą iterację.
Szereg czasowy ze złożonymi statystykami kroczącymi? Użyj rolling/ewm w Pandas.
Proste GROUP BY na milionach wierszy? Użyj SQL z indeksami.
Masz już w pamięci wiele małych ramek danych? pd.merge() będzie odpowiednie.
Potrzebujesz transakcji ACID? Użyj bazy danych SQL, a nie Pandas.

Łączenie obu narzędzi: potok hybrydowy

Najbardziej praktycznym podejściem jest potok hybrydowy, który wykorzystuje mocne strony każdego narzędzia. SQL obsługuje pobieranie danych, wstępne filtrowanie i standardowe agregacje na dużych tabelach surowych danych. Wynik — poręczna ramka danych — jest przekazywany do Pandas w celu inżynierii cech, obliczania niestandardowych metryk, statystyk kroczących i wizualizacji. Wyniki można opcjonalnie zapisać z powrotem w bazie danych, aby je udostępniać. Taki potok jest czytelny, skalowalny i łatwy w utrzymaniu dla każdego analityka znającego zarówno SQL, jak i 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())

Szybki sprawdzian

Sprawdź swoją znajomość pojęć związanych z analizą danych z tej lekcji.

Podsumowanie lekcji

W tej lekcji dowiedziałeś się, że: SQL doskonale sprawdza się przy filtrowaniu na dużą skalę, złączaniu i prostych agregacjach indeksowanych danych, Pandas doskonale sprawdza się przy niestandardowej logice w Pythonie, złożonych statystykach kroczących i analizie eksploracyjnej, a najlepszą strategią jest potok hybrydowy, który wykorzystuje SQL do wstępnej redukcji danych, a Pandas do złożonych transformacji otrzymanego, poręcznego wyniku. W następnej części rozpoczniemy statystykę inferencyjną z SciPy: testowanie normalności i statystyki opisowe.

Często zadawane pytania

Czy lekcja „Pandas a SQL: wybór odpowiedniego narzędzia” jest bezpłatna?

Tak — pełny tekst „Pandas a SQL: wybór odpowiedniego narzędzia” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Pandas & NumPy Academy, przejdź na CoddyKit PRO. Kurs Pandas & NumPy Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Pandas a SQL: wybór odpowiedniego narzędzia”?

Porównaj groupby/merge w Pandas z GROUP BY/JOIN w SQL i zdecyduj, która warstwa powinna obsługiwać poszczególne transformacje. Ćwiczysz Pandas & NumPy Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Pandas & NumPy Academy?

Nie wymagamy żadnego doświadczenia. Pandas & NumPy Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Pandas a SQL: wybór odpowiedniego narzędzia”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Pandas & NumPy Academy?

Tak. Każda lekcja Pandas & NumPy Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Łączenie z bazą danych za pomocą SQLAlchemy
Wykonywanie zapytań SQL z Pandas
Zapisywanie obiektów DataFrame w tabelach bazy danych
Pandas a SQL: wybór odpowiedniego narzędzia

← Powrót do Pandas & NumPy Academy