Jika kamu sudah terbiasa menganalisis data dengan Pandas, kamu mungkin pernah merasakan proses yang mulai melambat saat berurusan dengan jutaan baris data. Di sinilah Polars hadir: sebuah library DataFrame modern yang ditulis dalam bahasa Rust, dirancang untuk kinerja luar biasa berkat paralelisme multi-core dan penggunaan memori yang jauh lebih hemat. Dalam tutorial ini, kamu akan belajar Polars dari nol — mulai dari instalasi, manipulasi data, agregasi, join, sampai lazy evaluation yang menjadi senjata rahasianya.

Apa Itu Polars dan Kenapa Begitu Cepat?

Polars adalah library DataFrame untuk Python (dan Rust) yang pertama kali dirilis oleh Ritchie Vink pada 2020. Tidak seperti Pandas yang dibangun di atas NumPy dan umumnya berjalan single-thread, Polars dibangun di atas format kolumnar Apache Arrow dan mengeksekusi operasi secara paralel di seluruh core CPU. Hasilnya, operasi seperti filter, groupby, dan join bisa berjalan puluhan kali lebih cepat pada data berukuran besar dengan konsumsi RAM yang lebih rendah.

Keunggulan utama Polars bisa dirangkum menjadi tiga hal. Pertama, cepat — berkat format Arrow dan paralelisme multi-core. Kedua, hemat memori — berkat evaluasi lazy yang hanya memproses data yang benar-benar dibutuhkan. Ketiga, API yang ekspresif — rantai metode yang konsisten, deklaratif, dan mudah dibaca.

Kabar baiknya: konsep dasar Polars sangat mirip dengan Pandas. Jika kamu sudah menguasai dasar-dasar Pandas, transisimu ke Polars akan terasa mulus.

Instalasi dan Persiapan

Polars dapat diinstal lewat pip. Pastikan kamu memakai Python 3.9 atau lebih baru. Jika kamu menggunakan uv sebagai package manager, prosesnya bahkan lebih cepat.

bash
pip install polars

# atau jika kamu memakai uv
uv add polars

Setelah terinstal, pastikan semuanya berjalan dengan memeriksa versinya:

python
import polars as pl

print(pl.__version__)

Membuat DataFrame Pertama

Struktur data utama di Polars adalah DataFrame (tabel) dan Series (kolom). Mari kita buat DataFrame sederhana berisi data penjualan toko online yang akan kita pakai sepanjang tutorial ini.

python
import polars as pl

data = {
    "produk": ["Laptop", "Mouse", "Keyboard", "Monitor", "Headset"],
    "kategori": ["Elektronik", "Aksesoris", "Aksesoris", "Elektronik", "Aksesoris"],
    "harga": [15_000_000, 250_000, 800_000, 2_500_000, 600_000],
    "terjual": [12, 180, 95, 40, 150],
}

df = pl.DataFrame(data)
print(df)

Perhatikan bahwa output Polars tidak menampilkan kolom indeks di sisi kiri seperti Pandas. Polars memang tidak memiliki konsep indeks baris — ini salah satu alasan ia lebih sederhana sekaligus lebih cepat, karena setiap baris diperlakukan independen dan bisa diproses secara paralel.

Membaca dan Menulis Data

Polars mendukung pembacaan berbagai format file dengan sangat cepat, termasuk CSV, Parquet, JSON, dan Arrow. Untuk membaca CSV, gunakan read_csv:

python
df = pl.read_csv("penjualan.csv")
print(df.head())

Untuk file berukuran sangat besar, gunakan scan_csv atau scan_parquet yang mengembalikan LazyFrame — data tidak langsung dimuat ke memori, melainkan direncanakan dulu agar bisa dioptimalkan (kita bahas lebih detail di bagian lazy evaluation). Menulis data juga semudah memanggil satu metode:

python
# Menulis ke Parquet (format columnar yang sangat efisien)
df.write_parquet("penjualan.parquet")

# Menulis ke JSON
df.write_json("penjualan.json")

# Menulis ke CSV
df.write_csv("penjualan.csv")

Parquet adalah format biner columnar yang menjadi standar de facto di dunia big data. Dibandingkan CSV, Parquet jauh lebih hemat ruang penyimpanan dan lebih cepat dibaca, terutama untuk dataset dengan banyak kolom numerik.

Selain file, Polars juga bisa membaca langsung dari database relasional lewat read_database dengan connection string. Kalau kamu masih baru dengan konsep database, tutorial SQLite dengan Python kami adalah titik awal yang bagus.

Memilih dan Memfilter Data

Dua operasi yang paling sering kamu lakukan adalah select (memilih kolom) dan filter (memilih baris). Keduanya menerima ekspresi Polars yang diawali dengan pl.col("nama_kolom").

python
hasil = df.select(
    pl.col("produk"),
    pl.col("harga"),
    (pl.col("harga") * pl.col("terjual")).alias("total_pendapatan"),
)
print(hasil)

Untuk memfilter baris berdasarkan suatu kondisi, gunakan filter:

python
mahal = df.filter(pl.col("harga") > 1_000_000)
print(mahal)

# Kombinasi kondisi dengan & (dan) atau | (atau)
aksesoris_laris = df.filter(
    (pl.col("kategori") == "Aksesoris") & (pl.col("terjual") > 100)
)
print(aksesoris_laris)

Hati-hati: untuk menggabungkan beberapa kondisi, gunakan operator & (dan) atau | (atau), bukan kata kunci and/or seperti di Pandas. Setiap kondisi juga harus dibungkus tanda kurung.

Menambah dan Mentransformasi Kolom

Gunakan with_columns untuk menambah atau memodifikasi kolom. Ini setara dengan penugasan kolom baru di Pandas, tetapi jauh lebih ekspresif karena kamu bisa merantai banyak ekspresi sekaligus dalam satu panggilan.

python
df_baru = df.with_columns(
    (pl.col("harga") * pl.col("terjual")).alias("total_pendapatan"),
    pl.col("produk").str.to_uppercase().alias("produk_upper"),
    (pl.col("harga") / 1_000_000).round(2).alias("harga_juta"),
)
print(df_baru)

Namespace str menyediakan banyak metode manipulasi string seperti contains, replace, dan extract. Karena ekspresi bisa dirantai, kamu dapat menulis transformasi kompleks dengan kode yang tetap ringkas.

Agregasi dan GroupBy

Salah satu kekuatan terbesar Polars adalah agregasi yang sangat cepat. Untuk mengelompokkan data berdasarkan kategori lalu menghitung statistiknya, gunakan group_by diikuti agg:

python
ringkasan = df.group_by("kategori").agg(
    pl.col("terjual").sum().alias("total_terjual"),
    pl.col("harga").mean().alias("rata_rata_harga"),
    pl.len().alias("jumlah_produk"),
)
print(ringkasan)

Kode di atas mengelompokkan lima produk ke dalam dua kategori, lalu menghitung total penjualan, rata-rata harga, dan jumlah produk untuk setiap kategori. Beragam fungsi agregasi tersedia: sum, mean, min, max, median, std, hingga n_unique.

Menggabungkan Data dengan Join

Seperti di SQL, Polars menyediakan join untuk menggabungkan dua DataFrame berdasarkan kolom kunci. Misalnya, kita punya data stok gudang yang terpisah:

python
stok = pl.DataFrame({
    "produk": ["Laptop", "Mouse", "Keyboard", "Monitor", "Headset", "Speaker"],
    "stok_gudang": [5, 200, 80, 15, 120, 60],
})

gabungan = df.join(stok, on="produk", how="left")
print(gabungan)

Parameter how menentukan jenis join: inner (default), left, outer, cross, serta semi/anti. Pada contoh di atas, how="left" mempertahankan seluruh lima baris dari DataFrame kiri (df) lalu menambahkan kolom stok_gudang untuk produk yang cocok. Baris "Speaker" yang hanya ada di data stok ikut terbuang, karena left join hanya menyimpan baris dari sisi kiri.

Lazy Evaluation: Senjata Rahasia Polars

Fitur yang paling membedakan Polars dari Pandas adalah lazy evaluation. Dengan memanggil lazy(), kamu tidak langsung mengeksekusi operasi — Polars hanya membangun query plan (rencana eksekusi). Rencana itu lalu dioptimalkan (misalnya hanya membaca kolom yang dibutuhkan, atau memindahkan filter agar dieksekusi sebelum join) sebelum akhirnya dijalankan sekaligus lewat collect().

python
lazy_query = (
    df.lazy()
    .filter(pl.col("terjual") > 50)
    .group_by("kategori")
    .agg(pl.col("harga").sum().alias("total_harga"))
)

# Lihat rencana eksekusi yang sudah dioptimalkan
print(lazy_query.explain())

# Eksekusi seluruh rencana sekaligus
hasil = lazy_query.collect()
print(hasil)

Untuk dataset besar, biasakan membaca file dengan scan_csv atau scan_parquet lalu merantai operasi lazy. Polars akan otomatis melakukan predicate pushdown dan projection pushdown, sehingga hanya data yang benar-benar diperlukan yang dibaca dari disk — ini kunci mengapa Polars bisa memproses data yang lebih besar dari RAM.

Migrasi dari Pandas dan Integrasi

Polars terintegrasi mulus dengan ekosistem Python. Kamu bisa mengonversi DataFrame Pandas ke Polars dan sebaliknya hanya dengan satu baris kode:

python
import pandas as pd

# Pandas -> Polars
df_pandas = pd.DataFrame(data)
df_polars = pl.from_pandas(df_pandas)

# Polars -> Pandas
kembali_ke_pandas = df.to_pandas()

Hasil akhir dari Polars juga mudah divisualisasikan. Cukup konversi ke Pandas lalu plot, atau gunakan library plotting yang mendukung Arrow secara native. Untuk panduan lengkapnya, baca tutorial Matplotlib kami.

FAQ: Pertanyaan Umum tentang Polars

Apakah Polars bisa sepenuhnya menggantikan Pandas?

Untuk sebagian besar pekerjaan analisis data, ya. Namun Pandas masih memiliki ekosistem yang jauh lebih luas — banyak library pihak ketiga yang bergantung padanya — sehingga beberapa kasus niche tetap lebih praktis diselesaikan dengan Pandas. Strategi yang sehat adalah memakai Polars untuk data besar dan operasi berat, lalu mengonversi ke Pandas bila perlu.

Kapan sebaiknya saya tetap memakai Pandas?

Jika datamu kecil (di bawah ratusan ribu baris), perbedaan kecepatan tidak terlalu terasa, dan ekosistem Pandas yang luas bisa jadi lebih nyaman. Polars paling terasa manfaatnya saat data mencapai jutaan baris ke atas, atau saat kamu perlu memproses file besar dengan memori terbatas.

Seberapa besar data yang bisa ditangani Polars?

Polars dirancang untuk menangani data yang lebih besar dari RAM berkat evaluasi lazy dan fitur streaming-nya. Dalam praktik, Polars bisa memproses puluhan hingga ratusan juta baris di laptop biasa, asalkan kamu memakai scan_csv/scan_parquet dan operasi lazy.

Kesimpulan

Polars adalah pilihan tepat ketika Pandas mulai terasa lambat. Dengan API yang ekspresif, evaluasi lazy, dan kinerja multi-core, Polars memungkinkanmu menganalisis jutaan hingga ratusan juta baris data tanpa harus pindah ke infrastruktur big data. Mulailah dari operasi dasar di atas, lalu eksplorasi fitur lanjutan seperti pivot, window functions, dan streaming seiring kebutuhanmu bertambah.

Selamat mencoba, dan semoga proses analisis datamu kini jauh lebih cepat! Jika kamu ingin memperdalam keterampilan Python lainnya, jelajahi artikel-artikel terbaru di BengkelKode.