Mengolah Dataset Besar dengan Dask sebagai Alternatif Pandas untuk Data Skala Besar

13 April 2026 Lhuqita Fazry

Data Science Dask Big Data

Mengolah Dataset Besar dengan Dask sebagai Alternatif Pandas untuk Data Skala Besar

Pandas menjadi library standar untuk data manipulation di Python, namun ketika dataset melebihi kapasitas RAM, Pandas mengalami crash atau performance degradation yang signifikan. Dask menyediakan API yang mirip Pandas namun memproses data secara lazy dan parallel, memungkinkan kita mengolah dataset berukuran gigabytes tanpa memuat seluruhnya ke memori sekaligus.

Kapan Menggunakan Dask

Dask dirancang untuk situasi di mana dataset tidak muat di memori. Pandas meng-load seluruh data ke RAM, sedangkan Dask membagi data menjadi chunks yang diproses satu per satu. Perbedaan fundamental ini membuat Dask cocok untuk file CSV berukuran ratusan megabytes hingga gigabytes.

Sebagai aturan praktis: jika dataset berukuran lebih dari 30-50% RAM yang tersedia, Dask memberikan keunggulan yang nyata. Untuk dataset yang muat dengan nyaman di memori, Pandas tetap lebih cepat karena tidak ada overhead dari task scheduling dan chunk management.

Membaca Dataset Besar dengan Dask

python— python

!pip install dask[dataframe] pandas numpy

import dask.dataframe as dd
import pandas as pd
import numpy as np

# Membuat dataset contoh ukuran sedang
np.random.seed(42)
n_rows = 100000
df_sample = pd.DataFrame({
    'city': np.random.choice(['Jakarta', 'Surabaya', 'Bandung', 'Medan', 'Semarang'], n_rows),
    'category': np.random.choice(['A', 'B', 'C', 'D'], n_rows),
    'sales': np.random.uniform(100, 5000, n_rows),
    'quantity': np.random.randint(1, 50, n_rows),
    'date': pd.date_range('2024-01-01', periods=n_rows, freq='h'),
})

# Simpan ke CSV untuk simulasi file besar
df_sample.to_csv('/tmp/blog-sandbox/dask-demo-data.csv', index=False)
print(f"Dataset Pandas: {len(df_sample)} rows, {df_sample.memory_usage(deep=True).sum() / 1e6:.1f} MB in memory")
print(df_sample.head())
print(df_sample.dtypes)

Output:

text

Dataset Pandas: 100000 rows, 4.8 MB in memory
        city category        sales  quantity                date
0     Medan        B  1956.296325        31 2024-01-01 00:00:00
1  Semarang        B  3602.082764        36 2024-01-01 01:00:00
2   Bandung        B  4534.390556         2 2024-01-01 02:00:00
3  Semarang        A  3173.331674        34 2024-01-01 03:00:00
4  Semarang        C  2907.470441        42 2024-01-01 04:00:00
city                   str
category               str
sales              float64
quantity             int64
date        datetime64[us]
dtype: object

Metode to_csv() mengkonversi DataFrame Pandas ke file untuk simulasi skenario data besar. Dalam production, data biasanya sudah tersedia dalam format CSV, Parquet, atau database yang perlu diproses.

Lazy Evaluation dan Dask DataFrame

Kunci perbedaan Dask dengan Pandas adalah lazy evaluation. Operasi pada Dask DataFrame tidak dieksekusi langsung, melainkan ditambahkan ke task graph. Eksekusi baru terjadi saat kita memanggil compute().

python— python

# Membaca dataset dengan Dask
ddf = dd.read_csv('/tmp/blog-sandbox/dask-demo-data.csv')

print(f"Tipe objek: {type(ddf)}")
print(f"Jumlah partitions: {ddf.npartitions}")
print(f"Kolom: {list(ddf.columns)}")

# Lazy evaluation - operasi tidak langsung dieksekusi
filtered = ddf[ddf['sales'] > 1000]
grouped = filtered.groupby('city')['sales'].mean()

print(f"Tipe hasil groupby: {type(grouped)}")

Output:

text

Tipe objek: <class 'dask.dataframe.dask_expr._collection.DataFrame'>
Jumlah partitions: 1
Kolom: ['city', 'category', 'sales', 'quantity', 'date']

Tipe hasil groupby: <class 'dask.dataframe.dask_expr._collection.Series'>

Tipe objek dask.dataframe.core.Series menunjukkan bahwa operasi belum dieksekusi. Dask menyusun task graph terlebih dahulu, lalu mengeksekusi seluruh chain secara optimal ketika compute() dipanggil. Pendekatan ini menghindari redundant computation.

Data Science • Beginner

Data Science with Python

Master the art of data analysis, visualization, and predictive modeling.

Project: E-commerce Sales Dashboard

Daftar

Operasi Agregasi dan Compute

Setelah menyusun task graph, kita memanggil compute() untuk mengeksekusi seluruh operasi dan mendapatkan hasil sebagai Pandas object.

python— python

import time

# Eksekusi dengan Dask
start = time.time()
result_dask = grouped.compute()
dask_time = time.time() - start

print("Hasil agregasi Dask:")
print(result_dask)
print(f"\nWaktu eksekusi Dask: {dask_time:.4f} detik")

# Perbandingan dengan Pandas
start = time.time()
result_pandas = df_sample[df_sample['sales'] > 1000].groupby('city')['sales'].mean()
pandas_time = time.time() - start

print(f"\nWaktu eksekusi Pandas: {pandas_time:.4f} detik")
print(f"Perbedaan hasil: {abs(result_dask - result_pandas).max():.10f}")

Output:

text

Hasil agregasi Dask:
city
Bandung     2999.427268
Jakarta     3010.059906
Medan       2989.409039
Semarang    2998.801809
Surabaya    3017.552182
Name: sales, dtype: float64

Waktu eksekusi Dask: 0.1280 detik

Waktu eksekusi Pandas: 0.0061 detik
Perbedaan hasil: 0.0000000000

Pada dataset kecil, Pandas lebih cepat karena tidak ada overhead dari task scheduling. Namun perbedaan ini terbalik pada dataset besar — Dask justru mampu memproses data yang Pandas tidak bisa muat di memori. Hasil aggregasi kedua library identik, memastikan konsistensi output.

Groupby dan Agregasi Kompleks

Dask mendukung operasi agregasi yang lebih kompleks menggunakan agg() dengan custom aggregation function.

python— python

# Agregasi multi-kolom dengan Dask
multi_agg = ddf.groupby('city').agg({
    'sales': ['mean', 'std', 'count'],
    'quantity': ['sum', 'mean'],
}).compute()

print("Agregasi multi-kolom:")
print(multi_agg)
print(f"\nTotal baris per kota:")
print(ddf.groupby('city').size().compute())

Output:

text

Agregasi multi-kolom:
                sales                     quantity           
                 mean          std  count      sum       mean
city                                                         
Medan     2536.611773  1414.197255  19981  498957  24.971573
Semarang  2539.875092  1417.945689  20187  503501  24.941844
Bandung   2556.176210  1416.136324  19732  490995  24.883185
Surabaya  2560.041102  1418.610653  20082  502158  25.005378
Jakarta   2559.488795  1411.471024  20018  501563  25.055600

Total baris per kota:
city
Bandung     19732
Jakarta     20018
Medan       19981
Semarang    20187
Surabaya    20082
dtype: int64

Method agg() menerima dictionary yang memetakan kolom ke fungsi agregasi. Pendekatan ini memungkinkan kita menghitung mean, standard deviation, dan count secara simultan dalam satu pass melalui data, lebih efisien dibanding melakukan groupby berulang.

Menulis Hasil ke Format Parquet

Setelah pemrosesan selesai, Dask dapat menulis hasil ke format Parquet yang lebih efisien untuk data besar dibanding CSV. Parquet mendukung compression, column pruning, dan type preservation.

python— python

# Simpan hasil ke Parquet
output_path = '/tmp/blog-sandbox/dask-output'
numeric_cols = ddf[['city', 'sales', 'quantity']]
result = numeric_cols.groupby('city').mean().compute()
result.to_parquet(f'{output_path}-mean.parquet')
print(f"Hasil disimpan ke {output_path}-mean.parquet")

# Verifikasi: baca kembali
result_read = pd.read_parquet(f'{output_path}-mean.parquet')
print("Hasil baca kembali dari Parquet:")
print(result_read)

Output:

text

Hasil disimpan ke /tmp/blog-sandbox/dask-output-mean.parquet
Hasil baca kembali dari Parquet:
                sales   quantity
city                            
Bandung   2556.176210  24.883185
Jakarta   2559.488795  25.055600
Medan     2536.611773  24.971573
Semarang  2539.875092  24.941844
Surabaya  2560.041102  25.005378

Format Parquet menyimpan tipe data dan metadata kolom, menghilangkan kebutuhan inferensi tipe saat membaca ulang. File Parquet juga 50-80% lebih kecil dari CSV yang setara karena compression bawaan.

Best Practices Dask

Beberapa hal yang perlu diperhatikan saat menggunakan Dask di production: atur jumlah partitions agar setiap partition berukuran 100MB-1GB, gunakan format Parquet daripada CSV untuk I/O yang lebih cepat, dan panggil compute() sesekali mungkin — bukan setelah setiap operasi. Hindari operasi yang membutuhkan shuffle besar seperti set_index() pada kolom dengan kardinalitas tinggi, karena operasi ini memerlukan komunikasi antar partitions yang signifikan.

Dask bukan pengganti Pandas untuk semua kasus. Untuk dataset yang muat di memori, Pandas tetap menjadi pilihan terbaik karena overhead Dask tidak memberikan benefit. Dask memberikan value terbesar ketika data berukuran melebihi RAM atau ketika kita perlu memparallelkan computation across multiple cores.

Memahami kapan menggunakan Dask dan kapan tetap dengan Pandas merupakan skill penting bagi Data Engineer dan Data Scientist. Kedua library ini bukan pesaing, melainkan complementer — Pandas untuk data yang muat di memori, Dask untuk skala yang lebih besar. Transisi dari Pandas ke Dask juga relatif mulus karena API yang serupa.

Mau menguasai teknik pengolahan data skala besar dan skill Data Science lainnya? Bergabunglah dengan Data Science Bootcamp di Rumah Coding. Kurikulum berbasis kasus nyata dengan pendampingan mentor praktisi.