Pandas vs Polars vs DuckDB: Mana yang Pas untuk Proyek Data Anda?

Di dunia analisis data, memilih library yang tepat adalah kunci. Kita sering berhadapan dengan data lokal, mulai dari notebook untuk eksplorasi sampai pipeline data yang kompleks. Lalu, di antara Pandas vs Polars vs DuckDB, mana yang harus kita pilih?

Pandas tetap menjadi pilihan standar untuk notebook, analisis eksplorasi, visualisasi, dan alur kerja machine learning. Polars berfokus pada pemrosesan DataFrame yang cepat dan efisien memori. Sementara itu, DuckDB menawarkan pendekatan SQL-first untuk mengkueri file lokal dan analitik tertanam. Setiap alat ini pas untuk jenis alur kerja data lokal yang berbeda. Artikel ini akan membandingkan ketiganya dari sisi performa, arsitektur, interoperabilitas, dan kasus penggunaan di dunia nyata.

Perbedaan Utama: Sekilas Pandang

Bagi kamu yang mencari perbedaan level tinggi antara ketiga library ini, tabel berikut bisa memberikan gambaran cepat:

Fitur Utama	Pandas	Polars	DuckDB
Fokus Utama	Kompatibilitas Python Data Science	Performa DataFrame cepat	SQL dan Analitik Lokal
Arsitektur	Berbasis DataFrame, eager, step-by-step	Engine kolumnar, lazy execution, teroptimasi	SQL-first, mesin database lokal tertanam
Memori & Performa	Eager, lebih banyak memori untuk data besar	Efisien memori, multi-core, cepat	Efisien untuk beban kerja analitik besar, disk
Kasus Terbaik	Notebook, eksplorasi, ML, visualisasi	ETL, feature engineering, pipeline cepat	Joins, agregasi, kueri file langsung (Parquet)
Persistensi	Tidak ada bawaan	Tidak ada bawaan	Dapat menyimpan ke file database lokal

Singkatnya, Pandas terbaik saat kompatibilitas menjadi prioritas. Polars unggul saat performa DataFrame sangat penting. Sementara DuckDB paling pas jika SQL dan analitik lokal jadi fokus utama.

Arsitektur dan Alur Kerja

Perbedaan terbesar di antara Pandas, Polars, dan DuckDB adalah cara mereka memikirkan data.

Pandas dibangun di sekitar objek DataFrame di Python. Ia sangat bagus saat kamu menganalisis data langkah demi langkah di notebook. Kamu memuat data, memeriksanya, memfilter baris, membuat kolom, mengelompokkan nilai, lalu meneruskan hasilnya ke library plotting atau machine learning. Ini membuat Pandas sangat alami untuk analisis interaktif. Namun, banyak operasinya berjalan secara eager (langsung dieksekusi) dan mungkin menciptakan objek perantara di memori.

Polars juga menawarkan API DataFrame, tetapi desainnya lebih berorientasi performa. Ia memakai mesin kolumnar dan mendukung eksekusi lazy. Artinya, seluruh rencana kueri dapat dioptimalkan sebelum hasilnya benar-benar dihitung. Ini membuat Polars kuat untuk pipeline data yang berulang, feature engineering, dan transformasi di mana kecepatan serta efisiensi memori sangat penting.

DuckDB berbeda. Ia tidak mulai dengan operasi DataFrame, tetapi dengan SQL. Ini membuatnya sangat pas untuk join, agregasi, fungsi window, dan analisis terhadap file seperti CSV dan Parquet. Ia juga bisa menyimpan hasilnya dalam file database DuckDB lokal, memberikan keuntungan persistensi dibanding Pandas dan Polars.

Secara ringkas, Pandas terasa seperti alat DataFrame yang mengutamakan notebook. Polars terasa seperti mesin analitik cepat yang dibungkus dalam API DataFrame. Dan DuckDB terasa seperti gudang SQL lokal yang berjalan di dalam lingkungan Python-mu.

Performa dan Penggunaan Memori

Performa adalah salah satu alasan utama orang membandingkan Pandas, Polars, dan DuckDB. Untuk dataset kecil dan menengah, Pandas sering kali cukup baik, terutama jika tugasnya sederhana dan data muat dengan nyaman di memori. Ia masih pilihan praktis untuk banyak alur kerja berbasis notebook.

Perbedaannya menjadi lebih jelas saat data bertambah besar. Pandas biasanya butuh lebih banyak memori karena banyak operasi bersifat eager dan hasil perantara mungkin dimaterialisasi. Ini bisa membuat operasi pemindaian besar, join, dan group-by menjadi lebih lambat dan memakan banyak memori.

Polars dirancang untuk pemrosesan DataFrame berkinerja tinggi. Mesin eksekusi lazy-nya dapat mengoptimalkan seluruh kueri sebelum menjalankannya. Ia dapat mendorong filter dan pemilihan kolom lebih dekat ke sumber data, menggunakan banyak core CPU, dan mengurangi penggunaan memori yang tidak perlu.

DuckDB juga sangat kuat dalam beban kerja analitik lokal yang besar. Ia dibangun seperti mesin database, sehingga ia menangani kueri SQL, join, agregasi, dan pemindaian file secara efisien. Ia bisa mengkueri file Parquet dan CSV secara langsung, dan juga bisa melimpahkan data ke disk jika diperlukan.

Secara umum, Pandas bagus untuk pekerjaan di memori yang familiar. Polars lebih baik untuk pipeline DataFrame yang cepat. Sedangkan DuckDB lebih baik untuk analitik yang banyak memakai SQL di atas file lokal berukuran besar. Benchmark sering menempatkan Polars dan DuckDB di depan Pandas untuk beban kerja analitik besar, tetapi hasil pastinya tergantung pada format file, bentuk kueri, tipe data, dan hardware.

Kasus Penggunaan dan Pilihan Terbaik

Pilihan terbaik tergantung pada jenis pekerjaan yang paling sering kamu lakukan.

Pilih Pandas saat pekerjaanmu berpusat di sekitar notebook, eksplorasi, visualisasi, statistik, atau machine learning. Ia adalah opsi termudah ketika kamu butuh kompatibilitas kuat dengan ekosistem ilmu data Python. Banyak library masih mengharapkan DataFrame Pandas, jadi Pandas tetap pilihan paling minim gesekan untuk alur kerja ilmu data klasik.

Gunakan Polars saat kamu butuh pemrosesan DataFrame yang lebih cepat di satu mesin. Ini cocok untuk ETL, feature engineering, preprocessing, dan pipeline transformasi data yang dapat diulang. Model eksekusi lazy-nya sangat berguna saat kamu ingin memindai file, memfilter kolom, mengelompokkan data, dan menunda komputasi hingga hasil akhirnya dibutuhkan.

Pilih DuckDB saat alur kerjamu secara alami berbasis SQL. Ia kuat untuk join, agregasi, fungsi window, dan analitik ad hoc di atas file CSV atau Parquet. Ia juga berguna saat kamu ingin menyimpan hasilnya dalam file database lokal daripada hanya menulis output ke file terpisah.

Dalam praktiknya, alat-alat ini tidak harus bersaing. Banyak alur kerja modern justru menggabungkannya. DuckDB bisa menangani kueri SQL dan pemindaian file, Polars bisa melakukan transformasi DataFrame yang cepat, dan Pandas bisa digunakan di tahap akhir untuk visualisasi, pemodelan, atau kompatibilitas library.

Interoperabilitas dan Dukungan Ekosistem

Interoperabilitas adalah salah satu alasan mengapa alat-alat ini sering digunakan bersama, bukan sebagai pengganti langsung satu sama lain.

Pandas memiliki kompatibilitas ekosistem yang luar biasa. Banyak library Python untuk visualisasi, statistik, machine learning, dan pelaporan dibangun di sekitar DataFrame Pandas. Ini membuat Pandas sangat berguna di akhir alur kerja, di mana data mungkin perlu dipindahkan ke alat seperti scikit-learn, statsmodels, matplotlib, atau package Python familiar lainnya.

Polars telah banyak meningkat di area ini. Ia dapat bekerja dengan Arrow, NumPy, Pandas, dan beberapa alur kerja machine learning. Ini membuatnya lebih mudah menggunakan Polars untuk preprocessing cepat lalu mengkonversi hasilnya saat library lain mengharapkan format berbeda. Desain berbasis Arrow-nya juga membuat pertukaran data efisien dalam banyak kasus.

DuckDB juga terhubung dengan baik ke ekosistem data yang lebih luas. Di Python, ia dapat mengkueri DataFrame Pandas, DataFrame Polars, tabel Arrow, file CSV, dan file Parquet secara langsung. Ini membuatnya berguna sebagai jembatan antara alur kerja SQL dan alur kerja DataFrame.

Oleh karena itu, alur kerja praktis bisa menggunakan DuckDB untuk kueri SQL dan pemindaian file, Polars untuk transformasi cepat, dan Pandas untuk analisis akhir, visualisasi, atau kompatibilitas machine learning. Pendekatan hibrida ini seringkali lebih berguna daripada mencoba memaksakan satu alat untuk melakukan segalanya.

Studi Kasus: Memecahkan Masalah Data Bersama

Sejauh ini, kita telah membandingkan Pandas, Polars, dan DuckDB berdasarkan arsitektur, performa, penggunaan memori, dukungan ekosistem, dan kasus penggunaan. Sekarang mari kita bandingkan secara praktis dengan menyelesaikan pipeline data yang sama di ketiga alat tersebut.

Dalam perbandingan langsung ini, kita akan menggunakan dua contoh dataset:

orders.parquet, berisi detail pesanan
customers.csv, berisi informasi segmen pelanggan

Tujuannya sama untuk ketiga alat:

Membaca data pesanan dan pelanggan
Memfilter hanya pesanan yang selesai
Menggabungkan pesanan dengan segmen pelanggan
Menghitung pendapatan harian berdasarkan segmen
Menyimpan hasil akhir

Contoh ini membuat perbandingan lebih praktis karena menunjukkan bagaimana setiap alat mendekati tugas yang sama. Pandas menggunakan gaya DataFrame yang familiar, Polars menggunakan alur kerja berbasis ekspresi lazy, dan DuckDB menggunakan SQL langsung di atas file.

Membuat Contoh Data

Pertama, kita membuat dua file kecil yang akan digunakan oleh ketiga alat. Ini menjaga perbandingan tetap adil karena Pandas, Polars, dan DuckDB akan bekerja dengan data masukan yang sama.

python
import pandas as pd
import numpy as np

# Create sample orders data
orders_data = {
    'order_id': range(1, 11),
    'customer_id': np.random.randint(1, 5, 10),
    'order_date': pd.to_datetime(['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-02', '2023-01-03', '2023-01-03', '2023-01-04', '2023-01-04', '2023-01-05', '2023-01-05']),
    'status': ['completed', 'pending', 'completed', 'completed', 'pending', 'completed', 'completed', 'completed', 'completed', 'completed'],
    'revenue': np.random.randint(50, 200, 10)
}
orders_df = pd.DataFrame(orders_data)
orders_df.to_parquet('orders.parquet', index=False)

# Create sample customers data
customers_data = {
    'customer_id': range(1, 5),
    'segment': ['retail', 'enterprise', 'retail', 'small_business']
}
customers_df = pd.DataFrame(customers_data)
customers_df.to_csv('customers.csv', index=False)

print("Sample data created: orders.parquet and customers.csv")

Ini membuat dua file: orders.parquet dan customers.csv. Sekarang mari kita selesaikan tugas yang sama menggunakan Pandas, Polars, dan DuckDB.

Menggunakan Pandas

Pandas adalah opsi paling familiar bagi banyak pengguna Python. Ia sangat berguna saat kamu bekerja di notebook, melakukan analisis eksplorasi, atau menyiapkan data untuk visualisasi dan machine learning.

Dalam versi Pandas, data dimuat ke memori terlebih dahulu. Langkah-langkah pemfilteran, penggabungan, konversi tanggal, pengelompokan, dan penyimpanan ditulis sebagai operasi DataFrame.

python
import pandas as pd

# Read data
orders_pd = pd.read_parquet('orders.parquet')
customers_pd = pd.read_csv('customers.csv')

# Filter completed orders
completed_orders_pd = orders_pd[orders_pd['status'] == 'completed']

# Join with customer segments
joined_df_pd = completed_orders_pd.merge(customers_pd, on='customer_id', how='inner')

# Calculate daily revenue by segment
joined_df_pd['order_date'] = pd.to_datetime(joined_df_pd['order_date']).dt.date
daily_revenue_pd = joined_df_pd.groupby(['order_date', 'segment'])['revenue'].sum().reset_index()

# Save the result
daily_revenue_pd.to_parquet('daily_revenue_by_segment_pandas.parquet', index=False)
print("Pandas version completed and saved.")

Pendekatan ini mudah dibaca dan bekerja dengan baik untuk dataset kecil hingga menengah. Namun, untuk dataset yang lebih besar, penggunaan memori bisa menjadi perhatian karena Pandas biasanya bekerja secara eager dan mungkin membuat objek perantara.

Menggunakan Polars

Polars juga merupakan alat DataFrame, tetapi dirancang untuk performa. Ia mendukung eksekusi lazy, yang berarti kueri dapat dioptimalkan sebelum benar-benar dijalankan.

Dalam versi Polars, scan_parquet dan scan_csv membuat rencana kueri lazy alih-alih memuat data segera. Komputasi sebenarnya terjadi hanya saat .collect() dipanggil.

python
import polars as pl

# Read data lazily
orders_pl = pl.scan_parquet('orders.parquet')
customers_pl = pl.scan_csv('customers.csv')

# Filter completed orders and join with customer segments (lazy operations)
daily_revenue_pl = (
    orders_pl.filter(pl.col('status') == 'completed')
    .join(customers_pl, on='customer_id', how='inner')
    .with_columns(pl.col('order_date').cast(pl.Date)) # Convert to Date type
    .group_by(['order_date', 'segment'])
    .agg(pl.col('revenue').sum())
    .sort(['order_date', 'segment'])
)

# Execute the query and save the result
daily_revenue_pl.collect().write_parquet('daily_revenue_by_segment_polars.parquet')
print("Polars version completed and saved.")

Dibandingkan dengan Pandas, pendekatan ini lebih berorientasi performa. Ini berguna saat kamu memiliki transformasi yang lebih besar, langkah-langkah ETL yang berulang, atau alur kerja di mana optimasi kueri dapat mengurangi pekerjaan yang tidak perlu.

Menggunakan DuckDB

DuckDB berbeda dari Pandas dan Polars karena ia bersifat SQL-first. Alih-alih menggunakan API DataFrame, kita bisa menulis seluruh pipeline sebagai kueri SQL.

Dalam versi DuckDB, file Parquet dan CSV dikueri secara langsung. DuckDB menangani pemfilteran, penggabungan, agregasi, dan pembuatan tabel melalui SQL.

python
import duckdb

# Connect to an in-memory DuckDB database
con = duckdb.connect(database=':memory:', read_only=False)

# Execute the SQL query directly on files
con.execute("""
    CREATE TABLE daily_revenue_duckdb AS
    SELECT
        CAST(o.order_date AS DATE) AS order_date,
        c.segment,
        SUM(o.revenue) AS revenue
    FROM 'orders.parquet' AS o
    JOIN 'customers.csv' AS c
        ON o.customer_id = c.customer_id
    WHERE o.status = 'completed'
    GROUP BY 1, 2
    ORDER BY 1, 2;
""")

# Fetch the result (optional, but good for verification)
daily_revenue_duckdb = con.fetchdf()

# Save the result to a parquet file
con.execute("COPY daily_revenue_duckdb TO 'daily_revenue_by_segment_duckdb.parquet' (FORMAT PARQUET);")
con.close()
print("DuckDB version completed and saved.")

Dibandingkan dengan Pandas dan Polars, DuckDB terasa lebih seperti database analitik lokal. Ini sangat berguna saat alur kerjamu melibatkan SQL, join, agregasi, fungsi window, atau kueri langsung di atas file.

Membandingkan Ketiga Pendekatan

Ketiga alat ini memecahkan masalah yang sama, tetapi mereka melakukannya dengan cara yang berbeda. Output akhirnya sama, yaitu file daily_revenue_by_segment.parquet. Perbedaan utamanya ada pada alur kerjanya.

Pandas adalah yang paling mudah diikuti jika kamu sudah terbiasa dengan DataFrame Python. Polars lebih baik saat kamu ingin pemrosesan DataFrame yang lebih cepat dan eksekusi lazy. DuckDB lebih baik saat tugasnya secara alami berbasis SQL atau saat kamu ingin mengkueri file langsung tanpa memuatnya ke dalam DataFrame terlebih dahulu.

Untuk mengkonfirmasi bahwa ketiga alat membuat output yang serupa, kita bisa membandingkan hasil yang disimpan.

python
import pandas as pd

pandas_result = pd.read_parquet('daily_revenue_by_segment_pandas.parquet')
polars_result = pd.read_parquet('daily_revenue_by_segment_polars.parquet')
duckdb_result = pd.read_parquet('daily_revenue_by_segment_duckdb.parquet')

print("Pandas Result:\n", pandas_result)
print("\nPolars Result:\n", polars_result)
print("\nDuckDB Result:\n", duckdb_result)

# Quick check for equality (after sorting to ensure consistent order)
print("\nAre results from Pandas and Polars equal?\n", pandas_result.sort_values(['order_date', 'segment']).equals(polars_result.sort_values(['order_date', 'segment'])))
print("Are results from Pandas and DuckDB equal?\n", pandas_result.sort_values(['order_date', 'segment']).equals(duckdb_result.sort_values(['order_date', 'segment'])))

Kita bisa melihat bahwa nilai pendapatan cocok di ketiga alat tersebut.

Rekomendasi dan Matriks Keputusan

Alat terbaik tergantung pada bentuk pekerjaanmu dan prioritasmu. Pandas, Polars, dan DuckDB semuanya memiliki kekuatan, tetapi mereka paling kuat dalam situasi yang berbeda.

Aturan sederhana sangat berguna di sini. Pilih Pandas saat kompatibilitas paling penting. Polars saat performa DataFrame paling penting. Pilih DuckDB saat SQL, analitik berbasis file, atau persistensi lokal paling penting.

Untuk banyak proyek nyata, jawaban terkuat bukanlah satu alat saja. Alur kerja praktis mungkin menggunakan DuckDB untuk mengkueri file, Polars untuk mengubah data secara efisien, dan Pandas untuk mendukung visualisasi atau machine learning di tahap akhir.

Pandas, Polars, dan DuckDB semuanya berguna, tetapi dengan cara yang berbeda.

Pandas masih pilihan terbaik saat kamu butuh familiaritas, alur kerja yang ramah notebook, dan dukungan kuat dari ekosistem ilmu data Python. Ini sangat membantu untuk eksplorasi, visualisasi, statistik, dan machine learning.
Polars adalah pilihan yang lebih baik saat kamu ingin pemrosesan DataFrame yang cepat di satu mesin. Ia bekerja dengan baik untuk ETL, feature engineering, dan transformasi besar di mana kecepatan dan efisiensi memori penting.
DuckDB adalah pilihan terkuat saat alur kerjamu SQL-first. Ia juga paling pas saat kamu ingin mengkueri file langsung atau menyimpan hasil dalam database lokal yang ringan.

Dalam praktiknya, pengaturan terbaik seringkali menggunakan lebih dari satu alat. DuckDB dapat menangani SQL dan pemindaian file, Polars dapat menjalankan transformasi cepat, dan Pandas dapat mendukung analisis akhir, visualisasi, dan alur kerja machine learning.