Pandas & NumPy Academy · Pelajaran

Pandas vs. SQL: Memilih Alat yang Tepat

Bandingkan groupby/merge dalam Pandas dengan GROUP BY/JOIN dalam SQL, lalu tentukan lapisan yang seharusnya menangani setiap transformasi.

Pandas vs. SQL: Memilih Alat yang Tepat adalah pelajaran Pandas & NumPy Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Pandas & NumPy Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

Dua Alat dengan Keunggulan yang Saling Melengkapi

Pandas dan SQL sama-sama merupakan alat untuk manipulasi data, dan keduanya digunakan oleh analis data profesional. Inti pemahamannya adalah bahwa keduanya saling melengkapi, bukan bersaing: SQL unggul dalam operasi deklaratif berbasis himpunan pada tabel besar yang tersimpan di basis data relasional, sedangkan Pandas unggul dalam transformasi imperatif per baris dan transformasi algoritmik kompleks pada data yang sudah dimuat ke memori. Alur kerja terbaik menggunakan setiap alat untuk tugas yang paling dikuasainya.

Keunggulan SQL: Hal yang Lebih Baik Dilakukan SQL

SQL umumnya lebih unggul ketika: data berukuran besar (gigabita hingga terabita) dan harus difilter sebelum dimuat; penggabungan mencakup beberapa tabel besar dan indeks basis data memberikan peningkatan kecepatan hingga berorde besaran; agregasi bersifat sederhana (SUM, COUNT, GROUP BY); kumpulan hasil berukuran kecil dibandingkan input; atau pembacaan/penulisan secara bersamaan diperlukan (basis data menangani transaksi dan penguncian). Sintaks deklaratif SQL juga memungkinkan pengoptimal kueri memilih rencana fisik terbaik secara otomatis.

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

Keunggulan Pandas: Hal yang Lebih Baik Dilakukan Pandas

Pandas umumnya lebih unggul ketika: Anda memerlukan logika Python khusus yang tidak dapat diekspresikan oleh SQL (prapemrosesan pembelajaran mesin, penguraian string khusus, algoritme kompleks); rantai transformasi data terdiri dari banyak langkah; Anda memerlukan visualisasi segera setelah analisis; data sudah berada di memori dan perjalanan pulang-pergi SQL tambahan akan menambah latensi; atau Anda melakukan analisis eksploratif yang memerlukan iterasi interaktif. Pandas juga menangani operasi non-tabular seperti perhitungan matriks dan penghalusan deret waktu.

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

Memetakan Operasi SQL ke Pandas

Sebagian besar operasi SQL memiliki padanan langsung di Pandas. Dengan mengetahui kedua sintaks, Anda menjadi lebih serbaguna dan dapat menerjemahkan satu sintaks ke sintaks lainnya ketika berpindah alat. WHERE menjadi pengindeksan boolean atau .query(); GROUP BY + SUM menjadi .groupby().sum(); JOIN menjadi pd.merge(); ORDER BY menjadi .sort_values(); dan DISTINCT menjadi .drop_duplicates(). Makna semantiknya identik; hanya sintaksnya yang berbeda.

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)

Ketika Ukuran Data Menentukan Pilihan

Kerangka keputusan praktis berdasarkan ukuran data: di bawah 100 MB — gunakan Pandas sepenuhnya karena beban tambahan SQL tidak sepadan; 100 MB–10 GB — lakukan filter dan agregasi di SQL, lalu muat DataFrame ringkasan ke Pandas; 10 GB–1 TB — gunakan SQL atau Dask untuk pemrosesan, dan Pandas hanya untuk ringkasan akhir; di atas 1 TB — gunakan SQL terdistribusi (BigQuery, Spark SQL, Redshift). Jangan pernah mencoba memuat tabel berukuran 100 GB ke Pandas pada laptop dengan memori 16 GB — prosesnya akan gagal atau menyebabkan aktivitas disk berlebihan.

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

Fungsi Jendela SQL vs Rolling Pandas

Fungsi jendela SQL (OVER (PARTITION BY ... ORDER BY ...)) sangat kuat, tetapi memiliki keterbatasan: fungsi ini dapat menghitung peringkat berjalan, lag/lead, dan agregasi bergulir sederhana dengan baik, tetapi statistik bergulir yang kompleks (misalnya, korelasi Pearson bergulir) tidak dapat diekspresikan dalam SQL. rolling() dan expanding() milik Pandas mencakup rentang perhitungan jendela yang jauh lebih luas, termasuk fungsi khusus melalui .apply(). Untuk fungsi jendela standar pada data berukuran besar, utamakan SQL; untuk logika jendela yang kompleks, utamakan 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())

Gabungan Kompleks: Fleksibilitas Pandas

Gabungan SQL didasarkan pada kesamaan kunci (dengan beberapa pengecualian). Pandas menyediakan gabungan berbasis waktu yang fleksibel melalui pd.merge_asof() (mencocokkan kunci terdekat, bukan kesamaan yang persis), yang sangat berguna untuk menyelaraskan deret waktu (misalnya, menggabungkan harga saham dengan peristiwa perdagangan berdasarkan harga terdekat sebelumnya). Pandas juga mendukung gabungan bersyarat menggunakan merge yang diikuti penyaringan, sedangkan SQL memerlukan subkueri atau gabungan LATERAL untuk mengekspresikannya. Pola gabungan tingkat lanjut ini adalah salah satu area yang jelas dimenangkan oleh Pandas.

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 untuk Pembuatan Profil Data, SQL untuk Produksi

Pola alur kerja yang umum: gunakan Pandas untuk EDA dan pembuatan profil data pada sampel yang mewakili (misalnya, satu juta baris pertama), kembangkan logika transformasi secara iteratif, lalu terjemahkan langkah-langkah utama ke SQL untuk skala produksi. Pandas memungkinkan iterasi cepat dengan umpan balik visual secara langsung; SQL berjalan andal pada skala besar dengan infrastruktur minimal. Selaraskan keduanya: saat menambahkan fitur baru di Pandas, tulis prosedur tersimpan atau tampilan SQL yang setara untuk produksi.

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: Menulis SQL pada DataFrames

Pustaka pandasql memungkinkan Anda menulis kueri SQL secara langsung pada DataFrames Pandas menggunakan SQLite di balik layar. sqldf('SELECT * FROM df WHERE amount > 100', locals()) menjalankan kueri pada DataFrame df. Ini berguna jika Anda berpikir dalam SQL tetapi data sudah berada di Pandas, atau untuk mengajarkan konsep SQL dengan data dalam memori. Namun, untuk sebagian besar operasi, cara ini lebih lambat daripada Pandas asli—gunakan untuk kemudahan penggunaan, bukan kinerja.

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

Kerangka Pengambilan Keputusan: Referensi Singkat

Gunakan panduan keputusan ini saat memilih antara SQL dan Pandas:

Data berada dalam basis data DAN berukuran besar? Lakukan penyaringan dan agregasi terlebih dahulu dalam SQL.
Memerlukan logika Python khusus? Gunakan Pandas setelah penyaringan awal dengan SQL.
Analisis eksploratif pada sampel? Pandas memungkinkan iterasi yang lebih cepat.
Deret waktu dengan statistik bergulir yang kompleks? Gunakan rolling/ewm Pandas.
GROUP BY sederhana pada jutaan baris? Gunakan SQL dengan indeks.
Beberapa DataFrame kecil sudah berada dalam memori? Gunakan pd.merge().
Memerlukan transaksi ACID? Gunakan basis data SQL, bukan Pandas.

Menggabungkan Keduanya: Alur Kerja Hibrida

Pendekatan yang paling praktis adalah alur kerja hibrida yang memanfaatkan keunggulan setiap alat. SQL menangani pemasukan data, penyaringan kasar, dan agregasi standar pada tabel mentah berukuran besar. Hasilnya—sebuah DataFrame yang mudah dikelola—diserahkan kepada Pandas untuk rekayasa fitur, metrik khusus, statistik bergulir, dan visualisasi. Hasilnya secara opsional dapat ditulis kembali ke basis data untuk penyajian. Alur kerja ini mudah dibaca, dapat diskalakan, dan dapat dipelihara oleh analis mana pun yang menguasai SQL dan 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())

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Analisis Data dari pelajaran ini.

Ringkasan Pelajaran

Dalam pelajaran ini, Anda mempelajari bahwa SQL unggul dalam penyaringan, penggabungan, dan agregasi sederhana berskala besar pada data berindeks, Pandas unggul dalam logika Python khusus, statistik bergulir yang kompleks, dan analisis eksploratif, serta strategi terbaik adalah alur kerja hibrida yang menggunakan SQL untuk reduksi kasar dan Pandas untuk transformasi kompleks pada hasil yang mudah dikelola. Selanjutnya, kita akan memulai statistik inferensial dengan SciPy: pengujian kenormalan dan statistik deskriptif.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pandas vs. SQL: Memilih Alat yang Tepat” gratis?

Ya — teks lengkap “Pandas vs. SQL: Memilih Alat yang Tepat” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Pandas & NumPy Academy, upgrade ke CoddyKit PRO. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pandas vs. SQL: Memilih Alat yang Tepat”?

Bandingkan groupby/merge dalam Pandas dengan GROUP BY/JOIN dalam SQL, lalu tentukan lapisan yang seharusnya menangani setiap transformasi. Kamu berlatih Pandas & NumPy Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Pandas & NumPy Academy?

Tidak diperlukan pengalaman sebelumnya. Pandas & NumPy Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pandas vs. SQL: Memilih Alat yang Tepat” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Pandas & NumPy Academy ini?

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Menghubungkan ke Basis Data dengan SQLAlchemy
Menjalankan Kueri SQL dari Pandas
Menulis DataFrames ke Tabel Basis Data
Pandas vs. SQL: Memilih Alat yang Tepat

← Kembali ke Pandas & NumPy Academy