Büyük Dosyaları Parçalı Okuma
RAM'i aşan dosyaları read_csv içinde chunksize kullanarak parçalar hâlinde okuyun ve sonuçları artımlı olarak toplulaştırın.
Büyük Dosyaları Parçalı Okuma, CoddyKit'te ücretsiz bir Pandas & NumPy Academy dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Pandas & NumPy Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Pandas & NumPy Academy kursu toplamda 4 dersten oluşur.
Dosyalar RAM'i Aştığında
Üretim veri işlem hatlarında yaygın bir darboğaz, kullanılabilir RAM'den daha büyük bir CSV dosyasıdır. Bir dosya 20 GB ve makinede 16 GB RAM varsa pd.read_csv('file.csv') çağrısı MemoryError hatasıyla sonuçlanır. Çözüm parçalı okumadır: dosyayı sabit boyutlu parçalara yüklemek, her parçayı işlemek ve sonuçları biriktirmek. Bu yöntem, dosyaların tamamını belleğe yüklemeden istenen büyüklükteki dosyaları analiz etmenizi sağlar.
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))read_csv İçindeki chunksize Parametresi
Bir DataFrame yerine TextFileReader yineleyicisi döndürmek için pd.read_csv() çağrısına chunksize=n geçirin. Her yineleme, sonraki n satırı bir DataFrame olarak üretir. Böylece aynı anda bellekte yalnızca n satır bulunur. chunksize için iyi bir başlangıç değeri 100.000 satırdır; bu değer RAM'e sığacak kadar küçük, G/Ç ek yükünü yönetilebilir tutacak kadar da büyüktür. Değeri kullanılabilir RAM'inize ve sütun sayınıza göre ayarlayın.
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))Parçalar Üzerinde Yineleme
Her parçayı işlemek için parça yineleyicisi üzerinde bir for döngüsü kullanın. Satırları sayma, bir sütunu toplama veya filtreleme gibi basit işlemlerde her parçayı bağımsız olarak işleyin ve sonuçları bir listede ya da çalışan toplamda biriktirin. Yineleyiciyi her zaman bir with ifadesi içinde çağırın veya her işlem hattı çalıştırmasında yeniden oluşturduğunuzdan emin olun; yineleyiciler bir kez tüketilir ve yeniden başlatılamaz.
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}')Parçalı Okuma Sırasında Satırları Filtreleme
İstenmeyen verileri birikmeden önce atmak için satır filtrelerini döngünün içinde uygulayın. Bu, yalnızca ölçütlerinize uyan satırları tutarak bellek kullanımını düşük tutar. Örneğin, 10 GB'lık bir dosyadan 'North' bölgesindeki tüm satırları çıkarmak için sonuç listenize eklemeden önce her parçayı filtreleyin. Son pd.concat çağrısı yalnızca çok daha küçük olan filtrelenmiş alt kümeyi işler.
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}')Artımlı GroupBy Toplaması
Parçalar arasındaki GroupBy toplamaları, gruplar birden fazla parçaya yayılabileceğinden basit toplamlardan daha karmaşıktır. İzlenecek yöntem şudur: her parça için grup düzeyinde toplamları ve sayıları hesaplayın, bu kısmi sonuçları birleştirin ve birikmiş kısmi sonuçlar üzerinde son bir groupby işlemi gerçekleştirin. Her parça için groupby().mean() çağırıp ardından ortalamaların ortalamasını almayın; grupların boyutları parçalar arasında farklı olduğunda bu yanlış sonuç verir.
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))Yükleme Sırasında Bellek Verimli Tür Belirtme
Sütun dtypes değerlerini read_csv içinde önceden belirterek parçalı yükleme sırasında bellek kullanımını azaltın. Bu, Pandas'ın her parça için geniş türler ayırıp ardından bunları atmasını önler. read_csv() çağrısına dtype={'region': 'category', 'sales': 'int32'} benzeri bir sözlük geçirin. Parçalı okumayla birlikte kullanıldığında bu yaklaşım, tepe bellek kullanımını naif bir tam dosya yüklemesinin %10'undan daha aza indirebilir.
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}')Sonuçları Artımlı Olarak Yazma
Her parçanın işlenmesiyle oluşan çıktının bir dosyaya yazılması gerekiyorsa, her şeyi bellekte biriktirmek yerine işlenen her parçayı oluştuğu anda yazın. to_csv() ile mode='a' (sona ekleme) ve ilk parçadan sonra header=False kullanın. Böylece hem girdi hem de çıktı için bellek kullanımı parça boyutuyla sınırlı kalır ve işlem hattı, belleği kısıtlı bir makinede istenen büyüklükteki dosyaları işleyebilir.
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}')Doğrudan Kullanılabilen Alternatif Olarak Dask'a Giriş
Dask, işlemleri tembel olarak ve parçalar arasında paralel biçimde otomatik çalıştıran, Pandas benzeri bir API sunar. Elle parçalama döngüsü yazmak yerine dask_df = dd.read_csv('file.csv') yazabilir, ardından aynı Pandas işlemlerini (groupby, filtreleme, birleştirme) kullanabilirsiniz. Çalıştırmayı tetiklemek için sonunda .compute() çağırın. İşlem hattınızda elle parçalamayla uygulanması zor olan karmaşık, çok adımlı işlemler varsa Dask en pratik çözümdür.
# 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.')Parça Boyutunu Seçme
İdeal parça boyutu, birbiriyle yarışan iki etken arasında denge kurar: çok küçük parçalar (örneğin 1.000 satır) parça başına yüksek ek yüke (dosya G/Ç kurulumu, DataFrame oluşturma) neden olur ve döngü daha uzun sürer. Çok büyük parçalar (örneğin 10 milyon satır) ise aynı anda RAM'e çok fazla veri yükleyerek amaca ters düşer. Uygulanabilir bir başlangıç noktası olarak bellekte 50–200 MB boyutunda parçalar hedefleyin. Her biri ortalama 8 bayt olan 10 sütunlu bir DataFrame için 100.000 satır parça başına yaklaşık 8 MB demektir; bu, bol miktarda güvenlik payı bırakan güvenli bir varsayılandır.
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')Büyük Veriler İçin Parquet ve CSV Karşılaştırması
Dosya biçimini siz belirliyorsanız büyük veri kümeleri için CSV yerine Parquet kullanmayı tercih edin. Parquet; yalnızca istenen sütunları yükleyen (sütun budama), CSV'den çok daha iyi sıkıştırılan, veri türlerini koruyan (yükleme sırasında türleri yeniden çıkarmaz) ve eşdeğer bir CSV'den 5–20 kat daha hızlı okunan sütunsal bir ikili biçimdir. Büyük bir CSV'yi pd.read_csv('file.csv', chunksize=500000) + to_parquet ile bir kez Parquet'e dönüştürün, ardından sonraki tüm okumalar için pd.read_parquet(columns=['col1','col2']) kullanın.
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())Tam Parçalı İşlem Hattı Deseni
Büyük dosyaları işlemek için eksiksiz bir desen şöyledir: 1) Okuma sırasında veri türlerini belirtin. 2) Satırları döngünün içinde mümkün olduğunca erken filtreleyin. 3) Her parça için kısmi toplamları hesaplayın (toplam + sayı; doğrudan ortalama almayın). 4) Döngüden sonra kısmi sonuçları birleştirin ve son istatistikleri hesaplayın. 5) Sonuçlar büyükse çıktıyı artımlı olarak yazın. Bu desen, chunksize değerini uygun şekilde ayarlayarak her makinede her boyuttaki dosyayı işler.
Hızlı Kontrol
Bu derste öğrendikleriniz doğrultusunda parçalı okuma anlayışınızı sınayın.
Ders Özeti
Bu derste şunları öğrendiniz: read_csv içinde chunksize, her parça için bir DataFrame üreten ve RAM'den büyük dosyaların artımlı olarak işlenmesini sağlayan bir yineleyici döndürür; kısmi toplamalar (toplam + sayı), parçalar arasında doğru biçimde birikirken ortalamaların doğrudan ortalaması alınamaz; ayrıca Parquet biçimi, sıkıştırma, hız ve veri türlerini koruma özellikleri sayesinde büyük veri kümeleri için CSV'nin en iyi uzun vadeli alternatifidir. Pandas Performans İpuçları kursu böylece tamamlandı — artık ileri düzey B2 kurslarına hazırsınız!
Yapay zeka eğitmeniyle Python öğren — ücretsiz
Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.
- Kurslar
- 30
- Dersler
- 120
Sıkça Sorulan Sorular
“Büyük Dosyaları Parçalı Okuma” dersi ücretsiz mi?
Evet — “Büyük Dosyaları Parçalı Okuma” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Pandas & NumPy Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Pandas & NumPy Academy kursu toplamda 4 dersten oluşur.
“Büyük Dosyaları Parçalı Okuma” dersinde ne öğreneceğim?
RAM'i aşan dosyaları read_csv içinde chunksize kullanarak parçalar hâlinde okuyun ve sonuçları artımlı olarak toplulaştırın. Pandas & NumPy Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.
Pandas & NumPy Academy öğrenmeye başlamak için deneyim gerekli mi?
Önceden deneyim gerekmez. CoddyKit'te Pandas & NumPy Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.
“Büyük Dosyaları Parçalı Okuma” dersi ne kadar sürer?
Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.
Bu Pandas & NumPy Academy dersinde kod yazıp çalıştırabilir miyim?
Evet. Her Pandas & NumPy Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.
Bu kursun tüm dersleri
- timeit ve memory_profiler ile Profilleme
- iterrows ve Python Döngülerinden Kaçınma
- Bellek Azaltma için Verimli Veri Türleri
- Büyük Dosyaları Parçalı Okuma