Pandas & NumPy Academy · Pelajaran

Parquet: Penyimpanan Kolumnar Cepat

Tulis Pandas DataFrame ke Parquet dengan to_parquet(), baca kembali lebih cepat daripada CSV, dan gunakan pemangkasan kolom untuk memuat hanya bidang yang diperlukan.

Parquet: Penyimpanan Kolumnar Cepat 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.

Apa Itu Parquet?

Apache Parquet adalah format file biner berbasis kolom yang dirancang untuk beban kerja analitis. Berbeda dengan CSV, yang menyimpan data baris demi baris sebagai teks, Parquet menyimpan setiap kolom dalam blok yang berkesinambungan, mengompresnya secara efisien, dan menyandikan metadata. Hal ini membuat kueri yang hanya membaca beberapa kolom dari tabel lebar menjadi jauh lebih cepat. Parquet merupakan format standar de facto dalam danau data (AWS S3, Google Cloud Storage) dan didukung secara bawaan oleh Pandas, Dask, Spark, dan BigQuery.

Menulis Parquet dengan to_parquet()

Mengonversi DataFrame Pandas menjadi Parquet hanya memerlukan satu pemanggilan metode: df.to_parquet('output.parquet'). Mesin default-nya adalah pyarrow (pasang dengan pip install pyarrow). Parquet mempertahankan tipe data kolom secara persis — tidak ada lagi kolom tanggal yang terbaca kembali sebagai string. Parquet juga mendukung kompresi secara langsung melalui parameter compression; 'snappy' menawarkan baca/tulis cepat dengan kompresi sedang, sedangkan 'gzip' memberikan kompresi lebih tinggi dengan mengorbankan kecepatan.

import pandas as pd
import numpy as np

# Create a sample DataFrame
np.random.seed(0)
df = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=100000, freq='T'),
    'value': np.random.randn(100000),
    'category': np.random.choice(['A', 'B', 'C'], 100000)
})

# Write to Parquet
df.to_parquet('data.parquet', index=False, compression='snappy')
print('Written to data.parquet')

Membaca Parquet dengan read_parquet()

pd.read_parquet('output.parquet') membaca file kembali menjadi DataFrame. Dibandingkan dengan membaca CSV yang setara, pembacaan Parquet biasanya 5–10 kali lebih cepat untuk tabel lebar dengan banyak kolom. Tipe data dipertahankan secara persis — tanggal tetap berupa datetime64, kategori tetap berupa category, dan bilangan bulat tetap berupa int32 atau int64 sesuai penyimpanannya. Tidak diperlukan inferensi tipe data karena metadata disematkan dalam file.

import pandas as pd
import time

# Read Parquet
start = time.time()
df = pd.read_parquet('data.parquet')
print(f'Read Parquet: {time.time()-start:.3f}s')
print(df.dtypes)
print(df.shape)

Pemangkasan Kolom: Membaca Hanya Kolom yang Diperlukan

Keunggulan terbesar penyimpanan berbasis kolom adalah pemangkasan kolom: Anda dapat membaca hanya kolom tertentu tanpa memindai bagian file lainnya. Berikan daftar nama kolom ke parameter columns. Jika tabel dengan 100 kolom memiliki ukuran 100 MB per kolom dan Anda hanya memerlukan 3 kolom, Parquet membaca 3 MB, bukan 10 GB. CSV harus memindai setiap karakter untuk mengekstrak kolom apa pun. Hal ini membuat Parquet ideal untuk tabel lebar dalam alur analitis.

import pandas as pd

# Only load the 2 columns needed for this analysis
df = pd.read_parquet('large_table.parquet',
                     columns=['date', 'revenue'])
print(df.columns.tolist())
print(df.shape)
print(df.memory_usage(deep=True).sum() / 1e6, 'MB loaded')

Pemfilteran Grup Baris (Predicate Pushdown)

Parquet menyimpan statistik (min/max) untuk setiap grup baris (blok baris) di bagian footer file. Ketika Anda menerapkan filter melalui parameter filters, pembaca melewati seluruh grup baris yang tidak mungkin cocok dengan filter — hal ini disebut predicate pushdown. Misalnya, pemfilteran tanggal dalam file Parquet yang diurutkan berdasarkan waktu akan melewati seluruh blok bulan yang berada di luar rentang, sehingga hanya bagian yang relevan yang dibaca. Mesin pyarrow mendukung hal ini secara bawaan.

import pandas as pd

# Filter using predicate pushdown — row groups outside range are skipped
df = pd.read_parquet(
    'time_series.parquet',
    columns=['date', 'value'],
    filters=[('date', '>=', '2024-06-01'),
              ('date', '<', '2024-07-01')]
)
print(f'Loaded {len(df):,} rows (June only)')
print(df.head())

Parquet vs CSV: Perbandingan

Berikut perbandingan praktis Parquet dan CSV untuk dataset yang terdiri dari 10 juta baris dan 20 kolom:

Ukuran file: CSV ~2 GB, Parquet (snappy) ~400 MB
Waktu baca (semua kolom): CSV ~15 detik, Parquet ~2 detik
Waktu baca (3 kolom): CSV ~15 detik (harus memindai semuanya), Parquet ~0,3 detik
Pemertahanan tipe data: CSV kehilangan tipe data, Parquet mempertahankannya
Dapat dibaca manusia: CSV ya, Parquet tidak (biner)

Untuk alur produksi ketika data ditulis sekali dan dibaca berkali-kali, Parquet hampir selalu merupakan pilihan yang lebih baik.

Dataset Parquet yang Dipartisi

Untuk dataset yang sangat besar, Parquet mendukung dataset yang dipartisi: data dibagi menjadi beberapa file yang diatur dalam hierarki direktori berdasarkan nilai kolom. Misalnya, pemartisian berdasarkan tahun dan bulan membuat data/year=2024/month=01/part.parquet. Pembacaan dataset yang dipartisi secara otomatis memfilter direktori yang sesuai dengan kueri. Ini merupakan tata letak standar dalam danau data dan memungkinkan kueri rentang yang efisien pada miliaran baris.

import pandas as pd

# Write a partitioned dataset (requires pyarrow)
df = pd.read_parquet('all_data.parquet')
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month

df.to_parquet(
    'partitioned_data/',
    partition_cols=['year', 'month'],
    index=False
)
# Creates: partitioned_data/year=2024/month=1/part-0.parquet etc.

Membaca Dataset yang Dipartisi

Membaca direktori Parquet yang dipartisi sama seperti membaca satu file — Pandas (melalui pyarrow) secara otomatis menemukan semua file partisi. Nilai kolom partisi disertakan sebagai kolom dalam DataFrame yang dihasilkan. Anda juga dapat menggunakan filters untuk memanfaatkan pemangkasan partisi, yaitu ketika seluruh subpohon direktori dilewati berdasarkan nilai kolom partisi. Hal ini membuat kueri pada dataset terpartisi berukuran 1 TB terasa seperti membaca beberapa MB.

import pandas as pd

# Read the entire partitioned dataset
df_all = pd.read_parquet('partitioned_data/')
print('All years:', df_all['year'].unique())

# Read only 2024 data using partition pruning
df_2024 = pd.read_parquet(
    'partitioned_data/',
    filters=[('year', '==', 2024)]
)
print('2024 rows:', len(df_2024))

Parquet dengan Dask

Dask secara bawaan membaca dan menulis Parquet dengan dd.read_parquet() dan ddf.to_parquet(). Setiap file dalam direktori Parquet yang dipartisi menjadi satu partisi Dask, sehingga pembacaan dapat dilakukan sepenuhnya secara paralel. Dask juga memanfaatkan predicate pushdown ketika filter ditentukan. Menulis hasil Dask yang besar ke dataset Parquet yang dipartisi merupakan cara standar untuk menghasilkan keluaran dalam alur rekayasa data modern.

import dask.dataframe as dd

# Read partitioned Parquet with Dask (each file = one partition)
ddf = dd.read_parquet('partitioned_data/',
                      columns=['date', 'revenue', 'region'],
                      filters=[('year', '==', 2024)])

# Compute aggregation in parallel
result = ddf.groupby('region')['revenue'].sum().compute()
print(result.sort_values(ascending=False))

Opsi Kompresi dan Pengodean

Parquet mendukung berbagai algoritme kompresi dan skema pengodean internal. Snappy (bawaan) memprioritaskan kecepatan dengan kompresi sedang. Gzip menghasilkan berkas sekitar 30% lebih kecil, tetapi lebih lambat saat dibaca atau ditulis. Zstd menyeimbangkan kecepatan dan kompresi dengan lebih baik daripada keduanya. Untuk kolom bilangan bulat, Parquet secara otomatis menerapkan pengodean delta atau pengodean kamus untuk mengurangi ukuran lebih lanjut tanpa konfigurasi tambahan dari Anda.

import pandas as pd
import numpy as np

np.random.seed(0)
df = pd.DataFrame({'id': range(500000), 'val': np.random.randn(500000)})

for comp in ['snappy', 'gzip', 'zstd']:
    fname = f'data_{comp}.parquet'
    df.to_parquet(fname, compression=comp, index=False)
    import os
    size_mb = os.path.getsize(fname) / 1e6
    print(f'{comp}: {size_mb:.2f} MB')

Mengganti CSV dalam Alur Data Anda

Cara paling sederhana untuk mulai menggunakan Parquet adalah menambahkan langkah konversi satu kali di awal proyek: baca CSV Anda sekali, bersihkan dan ubah tipe datanya, lalu simpan sebagai Parquet. Pada proses berikutnya, bacalah berkas Parquet, bukan CSV. Cara ini langsung memberikan manfaat berupa kecepatan dan penghematan penyimpanan dengan perubahan kode yang minimal. Untuk data baru yang masuk sebagai CSV (misalnya ekspor setiap malam), tambahkan langkah konversi ke alur data Anda yang menulis Parquet sebelum analisis apa pun dimulai.

import pandas as pd

# One-time conversion
df = pd.read_csv('raw_data.csv',
                 parse_dates=['date'],
                 dtype={'category': 'category',
                        'amount': 'float32'})
df.to_parquet('clean_data.parquet', index=False)

# All future reads use Parquet
df_fast = pd.read_parquet('clean_data.parquet')
print('Loaded from Parquet:', df_fast.dtypes.to_dict())

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Analisis Data dari pelajaran ini.

Rangkuman Pelajaran

Dalam pelajaran ini, Anda mempelajari bahwa to_parquet() dan read_parquet() menyediakan operasi masukan/keluaran berkas yang lebih cepat, lebih kecil, dan mempertahankan tipe data dibandingkan CSV; pemangkasan kolom dengan parameter columns hanya membaca kolom yang diperlukan sehingga pemindaian seluruh berkas dapat dihindari; serta kumpulan data Parquet yang dipartisi berdasarkan nilai kolom memungkinkan pemangkasan partisi untuk kueri rentang yang efisien pada danau data berukuran besar. Selanjutnya, kita akan menghubungkan Pandas ke basis data relasional menggunakan SQLAlchemy.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Parquet: Penyimpanan Kolumnar Cepat” gratis?

Ya — teks lengkap “Parquet: Penyimpanan Kolumnar Cepat” 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 “Parquet: Penyimpanan Kolumnar Cepat”?

Tulis Pandas DataFrame ke Parquet dengan to_parquet(), baca kembali lebih cepat daripada CSV, dan gunakan pemangkasan kolom untuk memuat hanya bidang yang diperlukan. 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 “Parquet: Penyimpanan Kolumnar Cepat” 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

← Kembali ke Pandas & NumPy Academy