Pandas & NumPy Academy · Pelajaran

CSV Streaming dengan chunksize

Baca CSV besar dalam potongan berukuran tetap dengan pd.read_csv(chunksize=), proses setiap potongan, lalu gabungkan atau akumulasikan hasilnya.

CSV Streaming dengan chunksize adalah pelajaran Pandas & NumPy Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Masalah pada File CSV Berukuran Besar

Saat file CSV lebih besar daripada RAM yang tersedia — misalnya, file log berukuran 50 GB pada mesin dengan memori 16 GB — pemanggilan pd.read_csv('file.csv') gagal dengan MemoryError atau menyebabkan sistem terlalu sering menggunakan memori virtual, sehingga menjadi sangat lambat dan tidak dapat digunakan. Solusinya adalah pembacaan secara bertahap: alih-alih memuat seluruh file sekaligus, Anda memprosesnya dalam bagian-bagian berukuran tetap dan mengumpulkan hasil tanpa pernah menyimpan semuanya di memori secara bersamaan.

Parameter chunksize dalam read_csv

Memberikan chunksize=N kepada pd.read_csv() akan mengembalikan iterator TextFileReader, bukan DataFrame. Setiap iterasi menghasilkan DataFrame dengan paling banyak N baris. File dibaca secara malas — tidak ada data yang dimuat sampai Anda meminta bagian berikutnya. Iterator ini dapat digunakan dalam perulangan for atau diteruskan ke pd.concat(). Pilih chunksize yang cukup besar untuk I/O yang efisien, misalnya 10.000–100.000 baris, tetapi cukup kecil agar dapat dimuat dengan nyaman di memori.

import pandas as pd

# Returns a TextFileReader iterator, NOT a DataFrame
chunks = pd.read_csv('sales_data.csv', chunksize=10000)
print(type(chunks))  # <class 'pandas.io.parsers.readers.TextFileReader'>

for chunk in chunks:
    print(f'Chunk shape: {chunk.shape}')
    # process each chunk independently
    break   # just show the first chunk here

Memproses Setiap Bagian Secara Independen

Pola yang paling umum adalah melakukan transformasi atau penyaringan pada setiap bagian, mengumpulkan hasilnya dalam sebuah daftar, lalu menggabungkannya. Misalnya, Anda dapat menyaring baris yang cocok dengan suatu kondisi, menghitung statistik per bagian, atau memilih hanya kolom yang diperlukan. Dengan bekerja pada subset, hanya bagian saat ini yang menempati memori, sementara bagian file lainnya tidak disentuh. Setelah perulangan selesai, satu pd.concat(results) menyusun DataFrame akhir.

import pandas as pd

results = []
for chunk in pd.read_csv('orders.csv', chunksize=50000):
    # Keep only high-value orders
    filtered = chunk[chunk['amount'] > 1000]
    results.append(filtered)

# Combine all filtered chunks
high_value = pd.concat(results, ignore_index=True)
print('High-value orders:', len(high_value))

Mengumpulkan Agregat di Seluruh Bagian

Terkadang Anda tidak perlu menyimpan baris apa pun — Anda hanya memerlukan agregat berjalan. Lacak jumlah, banyaknya data, atau min/maks berjalan di seluruh bagian tanpa membuat daftar DataFrames. Ini adalah pola yang paling hemat memori karena penggunaan memori tetap konstan, terlepas dari ukuran file. Pada akhirnya, hitung statistik akhir dari akumulator Anda.

import pandas as pd

total_revenue = 0.0
total_rows = 0

for chunk in pd.read_csv('sales.csv', chunksize=100000):
    total_revenue += chunk['revenue'].sum()
    total_rows += len(chunk)

print(f'Processed {total_rows:,} rows')
print(f'Total revenue: ${total_revenue:,.2f}')

Menentukan dtype untuk Mempercepat Pembacaan Bertahap

Secara bawaan, Pandas menyimpulkan tipe data kolom dari data, yang mengharuskan setiap bagian dipindai dua kali, sekali untuk menyimpulkan tipe dan sekali untuk menguraikannya. Menyediakan argumen dtype menghindari beban ini dan juga mencegah ketidakkonsistenan tipe data antarbagiannya. Misalnya, kolom yang sebagian besar berisi bilangan bulat tetapi memiliki satu sel kosong dapat disimpulkan sebagai float64 pada satu bagian dan object pada bagian lain. Menentukan tipe data secara eksplisit memastikan pembacaan yang konsisten dan lebih cepat di semua bagian.

import pandas as pd

dtype_map = {
    'order_id': 'int32',
    'customer_id': 'int32',
    'amount': 'float32',
    'category': 'category'
}

for chunk in pd.read_csv('orders.csv',
                         chunksize=50000,
                         dtype=dtype_map,
                         parse_dates=['order_date']):
    print(chunk.dtypes)
    break

Memilih Hanya Kolom yang Diperlukan

Gunakan parameter usecols untuk memuat hanya kolom yang diperlukan oleh analisis Anda. Jika sebuah CSV memiliki 50 kolom tetapi agregasi Anda hanya menggunakan 3 kolom, tidak ada alasan untuk menguraikan 47 kolom lainnya. Menggabungkan usecols dengan chunksize secara drastis mengurangi waktu I/O dan penggunaan memori. Ini adalah salah satu pengoptimalan paling sederhana dan paling berdampak untuk pemrosesan CSV berukuran besar.

import pandas as pd

# Only read the three columns we actually need
for chunk in pd.read_csv(
    'large_transactions.csv',
    chunksize=100000,
    usecols=['date', 'amount', 'region']
):
    print(chunk.columns.tolist())
    print(chunk.memory_usage(deep=True).sum() / 1e6, 'MB per chunk')
    break

Agregasi GroupBy dalam Beberapa Bagian

Melakukan agregasi groupby di seluruh bagian memerlukan pengumpulan hasil parsial. Hitung groupby dalam setiap bagian, lalu gabungkan hasilnya menggunakan groupby kedua pada hasil parsial yang telah digabungkan. Misalnya, untuk mendapatkan total penjualan berdasarkan wilayah dari file berukuran 10 GB, kumpulkan jumlah wilayah per bagian dalam sebuah daftar, lalu gabungkan dan lakukan groupby lagi. Pola agregasi dua tahap ini terkadang disebut pendekatan map-reduce.

import pandas as pd

partials = []
for chunk in pd.read_csv('sales.csv',
                         chunksize=100000,
                         usecols=['region', 'revenue']):
    partial = chunk.groupby('region')['revenue'].sum()
    partials.append(partial)

# Combine partial sums
final = pd.concat(partials).groupby(level=0).sum()
print('Revenue by region:')
print(final.sort_values(ascending=False))

Menangani Kesalahan Penguraian di Seluruh Bagian

File CSV berukuran besar dari sumber eksternal sering memiliki baris yang formatnya tidak valid — koma tambahan, pengodean yang salah, atau baris yang terpotong. Gunakan on_bad_lines='skip' (Pandas 1.3+) atau error_bad_lines=False (Pandas versi lama) untuk melewati baris bermasalah tanpa pesan, dan gunakan encoding='latin-1' jika penguraian UTF-8 gagal. Lacak bagian mana yang menghasilkan kesalahan dengan try-except di sekitar pemrosesan setiap bagian untuk membangun pipeline tangguh yang tidak berhenti hanya karena satu baris bermasalah dalam file berisi 10 juta baris.

import pandas as pd

bad_chunks = []
all_chunks = []

for i, chunk in enumerate(pd.read_csv(
    'raw_data.csv',
    chunksize=50000,
    on_bad_lines='skip',
    encoding='utf-8',
    encoding_errors='replace'
)):
    try:
        # Your transformation here
        all_chunks.append(chunk)
    except Exception as e:
        bad_chunks.append((i, str(e)))
        print(f'Chunk {i} error: {e}')

print(f'Processed {len(all_chunks)} chunks, {len(bad_chunks)} errors')

Menulis Keluaran Secara Bertahap ke File

Saat keluaran yang telah diproses juga berukuran besar, tulis hasilnya secara bertahap, bukan mengumpulkan semuanya di memori lalu menulisnya pada akhir proses. Buka file CSV dan tambahkan setiap bagian yang telah diproses menggunakan mode='a' dan header=False untuk bagian-bagian berikutnya. Dengan demikian, penggunaan memori pipeline keluaran tetap konstan dan Anda dapat memeriksa hasil sementara sebelum seluruh proses selesai.

import pandas as pd

first_chunk = True
for chunk in pd.read_csv('input.csv', chunksize=100000):
    # Transform
    processed = chunk[chunk['status'] == 'active'].copy()
    processed['revenue_usd'] = processed['revenue'] * 1.10

    # Write incrementally
    mode = 'w' if first_chunk else 'a'
    processed.to_csv('output.csv',
                     mode=mode,
                     header=first_chunk,
                     index=False)
    first_chunk = False

print('Done writing output.csv')

Memperkirakan Ukuran Bagian yang Optimal

Memilih chunksize merupakan sebuah keseimbangan: ukuran terlalu kecil berarti banyak iterasi perulangan Python dan beban tambahan yang besar; ukuran terlalu besar berarti bagian-bagian tersebut tidak muat di RAM. Pendekatan praktisnya adalah memuat satu bagian, mengukur memorinya dengan chunk.memory_usage(deep=True).sum(), lalu mengatur chunksize agar setiap bagian menggunakan sekitar 10–20% RAM yang tersedia. psutil.virtual_memory().available milik Python memberikan RAM yang tersedia saat runtime, sehingga perhitungan chunksize dapat disesuaikan secara adaptif.

import pandas as pd

# Sample 1000 rows to estimate per-row memory
sample = pd.read_csv('big_file.csv', nrows=1000)
bytes_per_row = sample.memory_usage(deep=True).sum() / 1000
print(f'Bytes per row: {bytes_per_row:.0f}')

# Target: use at most 500 MB per chunk
target_bytes = 500 * 1024 * 1024
optimal_chunksize = int(target_bytes / bytes_per_row)
print(f'Recommended chunksize: {optimal_chunksize:,}')

Menggabungkan Hasil Bertahap Secara Efisien

Saat mengumpulkan banyak DataFrame bagian dalam sebuah daftar lalu menggabungkannya, perlu diingat bahwa pemanggilan pd.concat pada ratusan kerangka kecil berjalan lambat karena alokasi memori yang berulang. Pola yang lebih baik adalah melakukan agregasi dalam setiap bagian dan hanya menyimpan hasil agregasi yang kecil, bukan bagian lengkapnya. Jika Anda benar-benar memerlukan semua baris, menulis ke file Parquet secara bertahap menggunakan pyarrow lebih cepat daripada memanggil pd.concat di akhir.

import pandas as pd

# Efficient: aggregate first, small list of scalars
running_total = 0
running_count = 0

for chunk in pd.read_csv('sales.csv', chunksize=100000):
    running_total += chunk['amount'].sum()
    running_count += chunk['amount'].count()

print(f'Mean amount: {running_total / running_count:.2f}')

# Avoid: accumulating full chunk DataFrames
# results = []
# for chunk in reader:
#     results.append(chunk)   # memory grows to full file size
# df = pd.concat(results)     # slow for hundreds of chunks

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Analisis Data dari pelajaran ini.

Ringkasan Pelajaran

Dalam pelajaran ini, Anda mempelajari: chunksize dalam pd.read_csv mengembalikan iterator DataFrames yang memungkinkan pemrosesan file besar secara hemat memori, argumen usecols dan dtype mengurangi penggunaan memori per bagian dan mempercepat penguraian, serta akumulator berjalan (sum, count, parsial) mencegah pembuatan daftar yang berisi semua bagian. Selanjutnya, kita akan membahas pola agregasi bertahap di seluruh bagian secara lebih mendalam.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “CSV Streaming dengan chunksize” gratis?

Ya — teks lengkap “CSV Streaming dengan chunksize” 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 “CSV Streaming dengan chunksize”?

Baca CSV besar dalam potongan berukuran tetap dengan pd.read_csv(chunksize=), proses setiap potongan, lalu gabungkan atau akumulasikan hasilnya. 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 1 dari 4.

Berapa lama pelajaran “CSV Streaming dengan chunksize” 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