Membaca File Besar dalam Potongan
Proses files yang melebihi RAM dengan membacanya dalam potongan menggunakan chunksize di read_csv dan mengagregasikan hasil secara bertahap.
Membaca File Besar dalam Potongan 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.
Saat Ukuran File Melebihi RAM
Salah satu hambatan umum dalam pipeline data produksi adalah file CSV yang lebih besar daripada RAM yang tersedia. Jika ukuran file 20 GB sedangkan mesin memiliki RAM 16 GB, pd.read_csv('file.csv') akan gagal dengan MemoryError. Solusinya adalah pembacaan berpotongan: memuat file dalam potongan berukuran tetap, memproses setiap potongan, lalu mengakumulasikan hasilnya. Dengan cara ini, Anda dapat menganalisis file berukuran berapa pun tanpa memuat seluruh isinya ke memori.
import pandas as pd
import numpy as np
# Simulate a large CSV by writing one
np.random.seed(0)
sample = pd.DataFrame({
'date': pd.date_range('2023-01-01', periods=100000, freq='h'),
'region': np.random.choice(['North','South','East','West'], 100000),
'sales': np.random.randint(100, 1000, 100000)
})
sample.to_csv('/tmp/large_sales.csv', index=False)
print(f'File size: {pd.io.common.get_handle("/tmp/large_sales.csv", "r").handle.seek(0, 2)/1e6:.1f} MB... (simulated)')
print('Rows:', len(sample))Parameter chunksize dalam read_csv
Teruskan chunksize=n ke pd.read_csv() untuk mengembalikan iterator TextFileReader, bukan DataFrame. Setiap iterasi menghasilkan n baris berikutnya sebagai DataFrame. Dengan demikian, hanya n baris yang berada di memori pada satu waktu. Nilai awal yang baik untuk chunksize adalah 100.000 baris — cukup kecil untuk dimuat ke RAM, tetapi cukup besar agar beban masukan/keluaran tetap terkendali. Sesuaikan nilainya berdasarkan RAM yang tersedia dan jumlah kolom.
import pandas as pd
# Read file in chunks of 25,000 rows
chunk_iter = pd.read_csv('/tmp/large_sales.csv', chunksize=25000)
# Peek at the first chunk
first_chunk = next(chunk_iter)
print('First chunk shape:', first_chunk.shape)
print(first_chunk.head(3))Melakukan Iterasi pada Potongan
Gunakan perulangan for pada iterator potongan untuk memproses setiap potongan. Untuk operasi sederhana seperti menghitung baris, menjumlahkan kolom, atau memfilter, proses setiap potongan secara terpisah lalu akumulasikan hasilnya dalam daftar atau total berjalan. Selalu panggil iterator di dalam pernyataan with atau pastikan Anda membuatnya kembali untuk setiap proses pipeline — iterator hanya dapat digunakan sekali dan tidak dapat dimulai ulang.
import pandas as pd
total_rows = 0
total_sales = 0.0
chunk_count = 0
for chunk in pd.read_csv('/tmp/large_sales.csv', chunksize=25000):
total_rows += len(chunk)
total_sales += chunk['sales'].sum()
chunk_count += 1
print(f'Chunks processed: {chunk_count}')
print(f'Total rows: {total_rows:,}')
print(f'Total sales: {total_sales:,.0f}')
print(f'Avg sales per row: {total_sales/total_rows:.2f}')Memfilter Baris Saat Membaca dalam Potongan
Terapkan filter baris di dalam perulangan untuk membuang data yang tidak diperlukan sebelum data tersebut terakumulasi. Hal ini menjaga penggunaan memori tetap rendah karena hanya baris yang sesuai dengan kriteria Anda yang dipertahankan. Misalnya, untuk mengambil semua baris wilayah 'North' dari file berukuran 10 GB, filter setiap potongan sebelum menambahkannya ke daftar hasil. pd.concat terakhir hanya menangani subset yang telah difilter, sehingga ukurannya jauh lebih kecil.
import pandas as pd
filtered_chunks = []
for chunk in pd.read_csv('/tmp/large_sales.csv', chunksize=25000):
# Keep only North region rows
north = chunk[chunk['region'] == 'North']
if len(north) > 0:
filtered_chunks.append(north)
north_df = pd.concat(filtered_chunks, ignore_index=True)
print(f'North region rows: {len(north_df):,}')
print(f'North total sales: {north_df["sales"].sum():,.0f}')Agregasi GroupBy Bertahap
Agregasi GroupBy pada beberapa potongan lebih rumit daripada penjumlahan sederhana karena satu grup dapat tersebar di beberapa potongan. Polanya adalah: hitung jumlah dan banyaknya data pada tingkat grup untuk setiap potongan, gabungkan hasil parsial tersebut, lalu lakukan groupby terakhir pada hasil parsial yang telah dikumpulkan. Jangan pernah memanggil groupby().mean() pada setiap potongan lalu menghitung rata-rata dari berbagai rata-rata — hasilnya akan salah jika ukuran grup berbeda antar-potongan.
import pandas as pd
partials = []
for chunk in pd.read_csv('/tmp/large_sales.csv', chunksize=25000):
# Compute sum and count per region in this chunk
partial = chunk.groupby('region')['sales'].agg(['sum', 'count'])
partials.append(partial)
# Combine all partial results
combined = pd.concat(partials).groupby(level=0).sum()
combined['mean'] = combined['sum'] / combined['count']
print('Regional aggregation (chunked):')
print(combined.round(2))Menentukan Tipe yang Hemat Memori Saat Memuat Data
Kurangi penggunaan memori selama pemuatan berpotongan dengan menentukan dtypes kolom terlebih dahulu dalam read_csv. Hal ini mencegah Pandas mengalokasikan tipe yang lebih besar untuk setiap potongan lalu membuangnya. Teruskan kamus seperti dtype={'region': 'category', 'sales': 'int32'} ke read_csv(). Jika digabungkan dengan pembacaan berpotongan, cara ini dapat mengurangi penggunaan memori puncak hingga kurang dari 10% dibandingkan pemuatan seluruh file secara naif.
import pandas as pd
specified_dtypes = {
'region': 'category',
'sales': 'int32'
}
total_sales = 0
for chunk in pd.read_csv(
'/tmp/large_sales.csv',
chunksize=25000,
dtype=specified_dtypes,
parse_dates=['date']
):
total_sales += chunk['sales'].sum()
# Only 25k rows * (category + int32 + datetime) in RAM at once
print(f'Total sales (memory-efficient): {total_sales:,.0f}')Menulis Hasil Secara Bertahap
Jika keluaran pemrosesan setiap potongan juga perlu ditulis ke file, tulis setiap potongan yang telah diproses secara langsung, bukan mengakumulasikan semuanya di memori. Gunakan mode='a' (tambahkan) dan header=False (setelah potongan pertama) bersama to_csv(). Dengan cara ini, jejak memori untuk masukan dan keluaran sama-sama dibatasi oleh ukuran potongan, sehingga pipeline dapat memproses file berukuran berapa pun pada mesin dengan memori terbatas.
import pandas as pd
import os
output_path = '/tmp/filtered_output.csv'
# Remove previous output if it exists
if os.path.exists(output_path):
os.remove(output_path)
first_chunk = True
for chunk in pd.read_csv('/tmp/large_sales.csv', chunksize=25000):
# Process: keep only high-value rows
processed = chunk[chunk['sales'] > 800].copy()
# Write: header only on first chunk, append thereafter
processed.to_csv(output_path,
mode='a',
header=first_chunk,
index=False)
first_chunk = False
result = pd.read_csv(output_path)
print(f'High-value rows written: {len(result):,}')
print(f'Average sales (>800): {result["sales"].mean():.1f}')Pengantar Dask sebagai Alternatif Pengganti Langsung
Dask menyediakan API yang serupa dengan Pandas, yang menjalankan operasi secara malas dan paralel pada beberapa potongan secara otomatis. Alih-alih menulis perulangan pembacaan berpotongan secara manual, Anda menulis dask_df = dd.read_csv('file.csv'), lalu menggunakan operasi Pandas yang sama — groupby, filter, dan merge. Panggil .compute() di akhir untuk memulai eksekusi. Dask merupakan solusi paling praktis jika pipeline Anda melibatkan operasi kompleks dalam beberapa tahap yang sulit diterapkan secara manual dengan pembacaan berpotongan.
# pip install dask
# import dask.dataframe as dd
# Read the large CSV as a Dask DataFrame (lazy — no data loaded yet)
# ddf = dd.read_csv('/tmp/large_sales.csv')
# Operations are lazy — no computation happens until .compute()
# result = ddf.groupby('region')['sales'].mean().compute()
# print(result)
# Key Dask advantages:
# - Automatic chunking (no manual chunksize loops)
# - Parallel execution (multi-core)
# - Familiar Pandas API
# - Works with files larger than RAM
print('Dask extends Pandas to datasets larger than RAM with minimal API changes.')Memilih Ukuran Potongan
Ukuran potongan yang ideal menyeimbangkan dua faktor yang berlawanan: terlalu kecil (misalnya 1.000 baris) menyebabkan beban tambahan yang tinggi untuk setiap potongan (penyiapan masukan/keluaran file dan pembuatan DataFrame), sehingga perulangan berlangsung lebih lama. Terlalu besar (misalnya 10 juta baris) menggagalkan tujuan metode ini karena terlalu banyak data dimuat ke RAM sekaligus. Titik awal yang praktis adalah menargetkan potongan berukuran 50–200 MB di memori. Untuk DataFrame dengan 10 kolom yang rata-rata berukuran 8 byte per kolom, 100.000 baris ≈ 8 MB per potongan — nilai bawaan yang aman dan menyisakan banyak ruang cadangan.
import pandas as pd
import timeit
# Benchmark different chunk sizes
for chunksize in [10000, 50000, 100000]:
t = timeit.timeit(
lambda: sum(chunk['sales'].sum()
for chunk in pd.read_csv('/tmp/large_sales.csv', chunksize=chunksize)),
number=3
)
print(f'chunksize={chunksize:>7,}: {t/3:.3f}s per pass')Parquet vs CSV untuk Data Besar
Jika Anda dapat mengendalikan format file, pilih Parquet daripada CSV untuk dataset besar. Parquet adalah format biner berbasis kolom yang: hanya memuat kolom yang diminta (pemangkasan kolom), mengompresi jauh lebih baik daripada CSV, mempertahankan tipe data (tanpa menebak ulang saat memuat), dan membaca data 5–20 kali lebih cepat daripada CSV yang setara. Konversikan CSV besar ke Parquet sekali dengan pd.read_csv('file.csv', chunksize=500000) + to_parquet, lalu gunakan pd.read_parquet(columns=['col1','col2']) untuk semua pembacaan berikutnya.
import pandas as pd
# Convert our CSV to Parquet (do this once)
df = pd.read_csv('/tmp/large_sales.csv', parse_dates=['date'])
df['region'] = df['region'].astype('category')
df['sales'] = df['sales'].astype('int32')
df.to_parquet('/tmp/large_sales.parquet', index=False)
# Now read only the columns needed — much faster than CSV
sales_by_region = pd.read_parquet(
'/tmp/large_sales.parquet',
columns=['region', 'sales']
)
print('Parquet read result:')
print(sales_by_region.groupby('region')['sales'].mean().round(1))
print('\ndtypes preserved:', sales_by_region.dtypes.to_dict())Pola Pipeline Berpotongan Lengkap
Pola lengkap untuk memproses file besar: 1) Tentukan tipe data saat membaca. 2) Filter baris sedini mungkin di dalam perulangan. 3) Hitung agregasi parsial untuk setiap potongan (jumlah + banyaknya data, jangan langsung menghitung rata-rata). 4) Setelah perulangan selesai, gabungkan hasil parsial dan hitung statistik akhir. 5) Tulis keluaran secara bertahap jika hasilnya besar. Pola ini dapat menangani file dengan ukuran berapa pun pada mesin apa pun, asalkan chunksize disesuaikan dengan baik.
Pemeriksaan Singkat
Uji pemahaman Anda tentang pembacaan berpotongan dari pelajaran ini.
Rangkuman Pelajaran
Dalam pelajaran ini Anda mempelajari bahwa: chunksize dalam read_csv mengembalikan iterator yang menghasilkan satu DataFrame untuk setiap potongan, sehingga file yang lebih besar daripada RAM dapat diproses secara bertahap; agregasi parsial (jumlah + banyaknya data) terakumulasi dengan benar di seluruh potongan, sedangkan rata-rata tidak dapat dirata-ratakan secara langsung; dan format Parquet merupakan alternatif jangka panjang terbaik untuk CSV pada dataset besar karena kompresi, kecepatan, dan kemampuannya mempertahankan tipe data. Kursus Pandas Performance Tips ini selesai — Anda siap mengikuti kursus lanjutan B2!
Belajar Python dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Membaca File Besar dalam Potongan” gratis?
Ya — teks lengkap “Membaca File Besar dalam Potongan” 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 “Membaca File Besar dalam Potongan”?
Proses files yang melebihi RAM dengan membacanya dalam potongan menggunakan chunksize di read_csv dan mengagregasikan hasil secara bertahap. 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 “Membaca File Besar dalam Potongan” 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
- Pemrofilan dengan timeit dan memory_profiler
- Menghindari iterrows dan Perulangan Python
- Tipe Data Efisien untuk Mengurangi Memori
- Membaca File Besar dalam Potongan