Dosya İşlemleri ve with Statement

Programlar bellekte çalışır ama veriler kalıcı olmalı. Kullanıcı bilgileri, ayarlar, loglar — bunların hepsi dosyalarda saklanır. Bu derste Python'da dosya okuma, yazma ve modern dosya yolu işlemlerini öğreneceğiz.

open() Fonksiyonu

Python'da dosya işlemlerinin temel taşı open() fonksiyonudur. Bu fonksiyon bir dosyayı açar ve bir dosya nesnesi döndürür.

📂 Dosya Dolabı Analojisi

Dosya işlemlerini bir dosya dolabı gibi düşün:

1. Dolabı aç → open() çağrısı

2. Dosyayı bul ve oku/yaz → read() / write() işlemleri

3. Dolabı kapat → close() çağrısı

Dolabı açık bırakırsan ne olur? Başkaları erişemez, toz girer, belgeler kaybolabilir. Aynı şey dosyalar için de geçerli — açtığın dosyayı mutlaka kapatmalısın.

Temel Kullanım

# Dosya aç
dosya = open("notlar.txt", "r")

# İçeriği oku
icerik = dosya.read()
print(icerik)

# Dosyayı kapat — ÇOK ÖNEMLİ!
dosya.close()

Mode Parametreleri

open() fonksiyonunun ikinci parametresi dosyayı nasıl açacağını belirler:

Binary modlar:

# Metin dosyası yazma
dosya = open("cikti.txt", "w")
dosya.write("Merhaba Dünya!")
dosya.close()

# Binary dosya okuma (örn: resim)
dosya = open("foto.jpg", "rb")
veri = dosya.read()
dosya.close()
print(f"Dosya boyutu: {len(veri)} byte")

Encoding Parametresi

Türkçe karakterler için encoding belirtmek önemli:

# UTF-8 ile aç (Türkçe karakterler sorunsuz)
dosya = open("turkce.txt", "r", encoding="utf-8")
icerik = dosya.read()
dosya.close()

# Windows'ta bazen farklı encoding gerekebilir
dosya = open("eski_dosya.txt", "r", encoding="cp1254")  # Türkçe Windows

⚠️ Dikkat: Encoding belirtmezsen Python sistemin varsayılan encoding'ini kullanır. Linux'ta genellikle UTF-8, Windows'ta farklı olabilir. Her zaman encoding="utf-8" belirtmek iyi bir alışkanlık.

with Statement: Context Manager

open() ve close() ikilisi çalışır ama tehlikelidir. Ya close() çağrısından önce hata oluşursa? Dosya açık kalır!

# TEHLİKELİ — Hata olursa dosya kapanmaz
dosya = open("veri.txt", "r")
icerik = dosya.read()          # Burada hata olursa?
sonuc = isle(icerik)           # Ya burada?
dosya.close()                   # Buraya hiç ulaşamayabilir!

with statement bu sorunu çözer — dosyayı otomatik olarak kapatır:

# GÜVENLİ — with ile dosya otomatik kapanır
with open("veri.txt", "r", encoding="utf-8") as dosya:
    icerik = dosya.read()
    sonuc = isle(icerik)
# Blok bittiğinde dosya otomatik kapanır — hata olsa bile!

with bloğundan çıkıldığında (normal veya hata nedeniyle) dosya her zaman kapatılır. Bu, try-finally ile close() yazmakla aynı şey ama çok daha temiz.

# with aslında şununla eşdeğer:
dosya = open("veri.txt", "r")
try:
    icerik = dosya.read()
finally:
    dosya.close()  # Her durumda kapat

Birden Fazla Dosya

# İki dosyayı aynı anda aç
with open("girdi.txt", "r") as kaynak, \
     open("cikti.txt", "w") as hedef:
    for satir in kaynak:
        hedef.write(satir.upper())

Python 3.10+ ile parantezli yazım da mümkün:

# Python 3.10+
with (
    open("girdi.txt", "r") as kaynak,
    open("cikti.txt", "w") as hedef
):
    for satir in kaynak:
        hedef.write(satir.upper())

Bundan sonra tüm örneklerde with kullanacağız. Her zaman `with` kullan — bu artık kural.

Dosya Okuma Yöntemleri

Python'da dosya okumak için birkaç yöntem var. Her birinin kullanım alanı farklı.

read() — Tamamını Oku

with open("siir.txt", "r", encoding="utf-8") as f:
    icerik = f.read()
    print(icerik)
    print(f"Toplam {len(icerik)} karakter")

read() dosyanın tamamını tek seferde belleğe yükler. Küçük dosyalar için sorun yok ama 1GB'lık bir dosyayı read() ile okursan belleğin patlar.

read(n) ile belirli sayıda karakter da okuyabilirsin:

with open("buyuk_dosya.txt", "r") as f:
    ilk_100 = f.read(100)    # İlk 100 karakter
    sonraki_50 = f.read(50)  # Sonraki 50 karakter

readline() — Tek Satır Oku

with open("liste.txt", "r", encoding="utf-8") as f:
    birinci = f.readline()   # İlk satır
    ikinci = f.readline()    # İkinci satır
    ucuncu = f.readline()    # Üçüncü satır
    
    print(birinci.strip())   # strip() satır sonu karakterini temizler
    print(ikinci.strip())

readline() her çağrıda bir sonraki satırı okur. Dosya sonuna geldiğinde boş string "" döner.

readlines() — Tüm Satırları Liste Olarak

with open("ogrenciler.txt", "r", encoding="utf-8") as f:
    satirlar = f.readlines()  # Her satır bir liste elemanı

print(f"Toplam {len(satirlar)} satır")
for i, satir in enumerate(satirlar, 1):
    print(f"{i}: {satir.strip()}")

readlines() tüm satırları bir listeye yükler. Yine küçük dosyalar için uygun.

Satır Satır Iteration — En İyi Yöntem

with open("log.txt", "r", encoding="utf-8") as f:
    for satir in f:
        if "ERROR" in satir:
            print(satir.strip())

Dosya nesnesinin kendisi bir iterator. for döngüsüyle satır satır okursun ve her seferinde sadece bir satır bellekte tutulur. Bu yöntem gigabyte'larca büyük dosyalar için bile çalışır.

# Büyük dosyada kelime sayma — bellek dostu
kelime_sayisi = 0
with open("roman.txt", "r", encoding="utf-8") as f:
    for satir in f:
        kelime_sayisi += len(satir.split())

print(f"Toplam {kelime_sayisi} kelime")

💡 İpucu: Genel kural: Dosyanın tamamına ihtiyacın varsa read(), satırların listesine ihtiyacın varsa readlines(), satır satır işleyeceksen for satir in dosya: kullan. Büyük dosyalarda her zaman satır satır iteration tercih et.

Dosya Yazma Yöntemleri

write() — Tek Seferde Yaz

with open("cikti.txt", "w", encoding="utf-8") as f:
    f.write("Birinci satır\n")
    f.write("İkinci satır\n")
    f.write("Üçüncü satır\n")

write() otomatik olarak satır sonu eklemez — \n karakterini kendin yazmalısın. Fonksiyon yazılan karakter sayısını döndürür.

with open("log.txt", "w", encoding="utf-8") as f:
    yazilan = f.write("Merhaba Dünya!")
    print(f"{yazilan} karakter yazıldı")  # 14 karakter yazıldı

writelines() — Liste Olarak Yaz

satirlar = [
    "Ali Veli\n",
    "Ayşe Fatma\n",
    "Mehmet Can\n"
]

with open("isimler.txt", "w", encoding="utf-8") as f:
    f.writelines(satirlar)

writelines() de satır sonu eklemez — listedeki her stringin sonunda \n olmalı.

print() ile Dosyaya Yazma

with open("rapor.txt", "w", encoding="utf-8") as f:
    print("Günlük Rapor", file=f)
    print("=" * 30, file=f)
    print(f"Tarih: 2024-01-15", file=f)
    print(f"Toplam satış: 1500 TL", file=f)

print() fonksiyonunun file parametresi ile dosyaya yazabilirsin. print() otomatik satır sonu ekler — write()'dan farkı bu.

Ekleme Modu (append)

# Her çalıştırmada dosyaya satır ekle
import datetime

with open("gunluk.txt", "a", encoding="utf-8") as f:
    zaman = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    f.write(f"[{zaman}] Uygulama çalıştırıldı\n")

"a" (append) modu dosyanın sonuna ekler — mevcut içeriğe dokunmaz. "w" modu ise dosyayı sıfırlar ve sıfırdan yazar.

Dosya Pointer: seek() ve tell()

Dosyayı okurken Python bir pointer (imleç) tutar. Bu pointer okunan her karakterden sonra ilerler.

with open("veri.txt", "r") as f:
    print(f.tell())       # 0 — başlangıçta
    
    f.read(5)             # 5 karakter oku
    print(f.tell())       # 5 — 5. karakterde
    
    f.read(10)            # 10 karakter daha oku
    print(f.tell())       # 15 — 15. karakterde
    
    f.seek(0)             # Başa dön
    print(f.tell())       # 0 — tekrar başlangıçta
    
    icerik = f.read()     # Tekrar tamamını oku

seek() Parametreleri

f.seek(0)       # Dosyanın başına git
f.seek(10)      # 10. byte'a git
f.seek(0, 2)    # Dosyanın sonuna git (whence=2)

seek(offset, whence):

• whence=0 (varsayılan): Dosya başından itibaren

• whence=1: Mevcut konumdan itibaren (binary modda)

• whence=2: Dosya sonundan itibaren (binary modda)

Pratik: Dosyanın Son Satırlarını Okuma

def son_satirlar(dosya_yolu, n=5):
    """Dosyanın son n satırını döndürür."""
    with open(dosya_yolu, "rb") as f:
        # Dosya sonuna git
        f.seek(0, 2)
        dosya_boyutu = f.tell()
        
        satirlar = []
        blok = 1024
        okunan = 0
        
        while len(satirlar) <= n and okunan < dosya_boyutu:
            okunan = min(okunan + blok, dosya_boyutu)
            f.seek(-okunan, 2)
            veri = f.read(okunan)
            satirlar = veri.split(b"\n")
        
        # Son n satırı döndür
        return [s.decode("utf-8") for s in satirlar[-n:]]

for satir in son_satirlar("buyuk_log.txt", 3):
    print(satir)

Bu teknik büyük log dosyalarının sonunu okumak için mükemmel — tüm dosyayı belleğe yüklemeden sadece son kısmı okur.

Büyük Dosya Okuma: Bellek Dostu Yöntemler

Gigabyte'larca büyük dosyalarla çalışırken bellek yönetimi kritik önem taşır.

Yöntem 1: Satır Satır Iteration

# 10GB dosya bile bu şekilde okunabilir
hata_sayisi = 0
with open("sunucu.log", "r", encoding="utf-8") as f:
    for satir_no, satir in enumerate(f, 1):
        if "ERROR" in satir:
            hata_sayisi += 1
            print(f"Satır {satir_no}: {satir.strip()}")

print(f"Toplam {hata_sayisi} hata bulundu")

Yöntem 2: Chunk (Parça) Okuma

def dosya_hash_hesapla(dosya_yolu, blok_boyutu=8192):
    """Büyük dosyanın MD5 hash'ini hesaplar."""
    import hashlib
    md5 = hashlib.md5()
    
    with open(dosya_yolu, "rb") as f:
        while True:
            blok = f.read(blok_boyutu)
            if not blok:
                break
            md5.update(blok)
    
    return md5.hexdigest()

# 5GB dosya bile sorunsuz çalışır
print(dosya_hash_hesapla("buyuk_dosya.zip"))

Yöntem 3: Generator ile Okuma

def csv_satirlari_oku(dosya_yolu, ayirici=","):
    """CSV dosyasını satır satır generator olarak okur."""
    with open(dosya_yolu, "r", encoding="utf-8") as f:
        basliklar = f.readline().strip().split(ayirici)
        for satir in f:
            degerler = satir.strip().split(ayirici)
            yield dict(zip(basliklar, degerler))

# Bellek dostu — tüm dosya belleğe yüklenmez
for kayit in csv_satirlari_oku("veriler.csv"):
    if int(kayit.get("yas", 0)) > 30:
        print(kayit["ad"])

pathlib Modülü: Modern Dosya Yolu İşlemleri

pathlib Python 3.4'te eklendi ve dosya yolu işlemlerini nesne yönelimli bir şekilde yapmana olanak tanır. Eski os.path modülüne göre çok daha okunabilir ve güçlüdür.

Temel Kullanım

from pathlib import Path

# Yol oluşturma
proje = Path("/home/kullanici/projeler/uygulama")
dosya = Path("belgeler/rapor.txt")
ev = Path.home()
cwd = Path.cwd()

print(f"Ev dizini: {ev}")
print(f"Çalışma dizini: {cwd}")

Yol Birleştirme: / Operatörü

pathlib'in en güzel özelliği / operatörüyle yol birleştirme:

from pathlib import Path

proje = Path("/home/kullanici/proje")

# / operatörü ile birleştir
kaynak = proje / "src" / "main.py"
print(kaynak)  # /home/kullanici/proje/src/main.py

test = proje / "tests" / "test_main.py"
print(test)    # /home/kullanici/proje/tests/test_main.py

# String birleştirmeden çok daha okunabilir!
# Eski yöntem: os.path.join("/home/kullanici/proje", "src", "main.py")

Yol Bileşenlerine Erişim

from pathlib import Path

dosya = Path("/home/kullanici/belgeler/rapor.pdf")

print(dosya.name)       # rapor.pdf (dosya adı)
print(dosya.stem)       # rapor (uzantısız ad)
print(dosya.suffix)     # .pdf (uzantı)
print(dosya.parent)     # /home/kullanici/belgeler (üst dizin)
print(dosya.parents[0]) # /home/kullanici/belgeler
print(dosya.parents[1]) # /home/kullanici
print(dosya.parts)      # ('/', 'home', 'kullanici', 'belgeler', 'rapor.pdf')

Dosya Uzantısını Değiştirme

from pathlib import Path

kaynak = Path("resim.jpg")
yedek = kaynak.with_suffix(".bak")      # resim.bak
png = kaynak.with_suffix(".png")         # resim.png
yeni = kaynak.with_stem("yeni_resim")    # yeni_resim.jpg (Python 3.9+)

os.path vs pathlib Karşılaştırma

import os
from pathlib import Path

# Eski yöntem — os.path
eski_yol = os.path.join(os.path.expanduser("~"), "belgeler", "rapor.txt")
if os.path.exists(eski_yol) and os.path.isfile(eski_yol):
    boyut = os.path.getsize(eski_yol)

# Yeni yöntem — pathlib
yeni_yol = Path.home() / "belgeler" / "rapor.txt"
if yeni_yol.exists() and yeni_yol.is_file():
    boyut = yeni_yol.stat().st_size

pathlib çok daha okunabilir. Yeni projelerde her zaman pathlib tercih et.

Dosya ve Dizin İşlemleri

pathlib ile dosya ve dizin oluşturma, silme, listeleme işlemleri:

Dosya/Dizin Kontrolü

from pathlib import Path

yol = Path("proje/veri")

print(yol.exists())     # Var mı?
print(yol.is_file())    # Dosya mı?
print(yol.is_dir())     # Dizin mi?
print(yol.is_symlink()) # Sembolik link mi?

Dizin Oluşturma

from pathlib import Path

# Tek dizin oluştur
Path("yeni_klasor").mkdir(exist_ok=True)

# İç içe dizinler oluştur
Path("proje/src/utils").mkdir(parents=True, exist_ok=True)

exist_ok=True dizin zaten varsa hata vermez. parents=True üst dizinleri de oluşturur.

Dizin İçeriğini Listeleme

from pathlib import Path

proje = Path(".")

# Tüm dosya ve dizinleri listele
for oge in proje.iterdir():
    tur = "📁" if oge.is_dir() else "📄"
    print(f"{tur} {oge.name}")

# Sadece Python dosyaları
python_dosyalari = list(proje.glob("*.py"))
print(f"{len(python_dosyalari)} Python dosyası bulundu")

# Alt dizinler dahil tüm Python dosyaları
tum_py = list(proje.rglob("*.py"))
print(f"Toplam {len(tum_py)} Python dosyası (alt dizinler dahil)")

glob ile Pattern Eşleme

from pathlib import Path

proje = Path("/home/kullanici/proje")

# Tüm .txt dosyaları
for txt in proje.glob("*.txt"):
    print(txt.name)

# Alt dizinlerdeki tüm .py dosyaları
for py in proje.rglob("*.py"):
    print(py)

# Belirli pattern
for dosya in proje.glob("test_*.py"):
    print(f"Test dosyası: {dosya.name}")

# Birden fazla uzantı
for dosya in proje.glob("*.[jJ][sS][oO][nN]"):
    print(f"JSON: {dosya.name}")

Dosya Okuma/Yazma (pathlib ile)

from pathlib import Path

dosya = Path("notlar.txt")

# Yazma
dosya.write_text("Merhaba Dünya!\nİkinci satır.", encoding="utf-8")

# Okuma
icerik = dosya.read_text(encoding="utf-8")
print(icerik)

# Binary okuma/yazma
resim = Path("foto.jpg")
veri = resim.read_bytes()
yedek = Path("foto_yedek.jpg")
yedek.write_bytes(veri)

read_text() ve write_text() küçük dosyalar için çok pratik — with open() yazmana gerek kalmaz.

Dosya Silme ve Taşıma

from pathlib import Path
import shutil

# Dosya silme
dosya = Path("gereksiz.txt")
dosya.unlink(missing_ok=True)  # Dosya yoksa hata vermez

# Boş dizin silme
dizin = Path("bos_klasor")
dizin.rmdir()  # Sadece boş dizin silinir

# Dolu dizin silme — shutil gerekli
shutil.rmtree("dolu_klasor")

# Dosya taşıma/yeniden adlandırma
kaynak = Path("eski_ad.txt")
hedef = Path("yeni_ad.txt")
kaynak.rename(hedef)

# Dosya kopyalama — shutil
shutil.copy2("kaynak.txt", "hedef.txt")  # Metadata da kopyalanır
shutil.copytree("kaynak_dizin", "hedef_dizin")  # Tüm dizin kopyalanır

⚠️ Dikkat: shutil.rmtree() bir dizini ve tüm içeriğini geri dönüşümsüz siler. Çöp kutusuna gitmez! Bu komutu kullanmadan önce yolu iki kez kontrol et.

Pratik Örnekler

1. Dosya Kopyalama

from pathlib import Path

def dosya_kopyala(kaynak_yol, hedef_yol, buffer_boyutu=8192):
    """Dosyayı parça parça kopyalar (büyük dosyalar için uygun)."""
    kaynak = Path(kaynak_yol)
    hedef = Path(hedef_yol)
    
    if not kaynak.exists():
        raise FileNotFoundError(f"Kaynak dosya bulunamadı: {kaynak}")
    
    if hedef.exists():
        raise FileExistsError(f"Hedef dosya zaten var: {hedef}")
    
    # Hedef dizini oluştur
    hedef.parent.mkdir(parents=True, exist_ok=True)
    
    kopyalanan = 0
    with open(kaynak, "rb") as src, open(hedef, "wb") as dst:
        while True:
            parca = src.read(buffer_boyutu)
            if not parca:
                break
            dst.write(parca)
            kopyalanan += len(parca)
    
    print(f"Kopyalandı: {kopyalanan:,} byte")
    return kopyalanan

dosya_kopyala("buyuk_dosya.zip", "yedek/buyuk_dosya.zip")

2. Satır Sayma ve İstatistik

from pathlib import Path

def dosya_istatistik(dosya_yolu):
    """Dosya hakkında detaylı istatistik verir."""
    yol = Path(dosya_yolu)
    
    if not yol.is_file():
        print(f"Dosya bulunamadı: {yol}")
        return
    
    satir_sayisi = 0
    kelime_sayisi = 0
    karakter_sayisi = 0
    bos_satir = 0
    
    with open(yol, "r", encoding="utf-8") as f:
        for satir in f:
            satir_sayisi += 1
            if satir.strip() == "":
                bos_satir += 1
            kelime_sayisi += len(satir.split())
            karakter_sayisi += len(satir)
    
    boyut = yol.stat().st_size
    
    print(f"📄 Dosya: {yol.name}")
    print(f"📏 Boyut: {boyut:,} byte")
    print(f"📝 Satır: {satir_sayisi:,}")
    print(f"   Boş satır: {bos_satir:,}")
    print(f"📖 Kelime: {kelime_sayisi:,}")
    print(f"🔤 Karakter: {karakter_sayisi:,}")

dosya_istatistik("ornek.py")

3. Log Dosyası Analizi

from pathlib import Path
from collections import Counter

def log_analiz(log_yolu):
    """Log dosyasını analiz eder."""
    yol = Path(log_yolu)
    seviyeler = Counter()
    hatalar = []
    
    with open(yol, "r", encoding="utf-8") as f:
        for satir_no, satir in enumerate(f, 1):
            satir = satir.strip()
            
            # Log seviyesini bul
            for seviye in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
                if seviye in satir:
                    seviyeler[seviye] += 1
                    if seviye in ("ERROR", "CRITICAL"):
                        hatalar.append((satir_no, satir))
                    break
    
    print("📊 Log Analizi")
    print("=" * 40)
    for seviye, sayi in seviyeler.most_common():
        print(f"  {seviye}: {sayi}")
    
    if hatalar:
        print(f"\n🔴 Son 5 Hata:")
        for no, mesaj in hatalar[-5:]:
            print(f"  Satır {no}: {mesaj[:80]}")

log_analiz("uygulama.log")

4. Dizin Boyutu Hesaplama

from pathlib import Path

def dizin_boyutu(dizin_yolu):
    """Bir dizinin toplam boyutunu hesaplar."""
    yol = Path(dizin_yolu)
    
    if not yol.is_dir():
        print(f"Dizin bulunamadı: {yol}")
        return 0
    
    toplam = 0
    dosya_sayisi = 0
    
    for dosya in yol.rglob("*"):
        if dosya.is_file():
            toplam += dosya.stat().st_size
            dosya_sayisi += 1
    
    # İnsan okunur format
    birimler = ["B", "KB", "MB", "GB"]
    boyut = toplam
    birim_idx = 0
    while boyut >= 1024 and birim_idx < len(birimler) - 1:
        boyut /= 1024
        birim_idx += 1
    
    print(f"📁 {yol.name}: {boyut:.1f} {birimler[birim_idx]} "
          f"({dosya_sayisi} dosya)")
    return toplam

dizin_boyutu(".")

Geçici Dosyalar: tempfile

Bazen geçici dosyalara ihtiyacın olur — işlem bittiğinde silinmesi gereken dosyalar:

import tempfile
from pathlib import Path

# Geçici dosya oluştur — with bloğu bitince otomatik silinir
with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", 
                                  delete=True, encoding="utf-8") as tmp:
    tmp.write("Geçici veri\n")
    tmp.flush()  # Buffer'ı diske yaz
    print(f"Geçici dosya: {tmp.name}")
    # Dosya ile işlem yap...
# Blok bitince dosya otomatik silinir

# Geçici dizin
with tempfile.TemporaryDirectory() as tmp_dir:
    tmp_dosya = Path(tmp_dir) / "veri.txt"
    tmp_dosya.write_text("Test verisi")
    print(f"Geçici dizin: {tmp_dir}")
# Dizin ve içeriği otomatik silinir

💡 İpucu: Geçici dosyalar test yazarken, ara hesaplamalar yaparken ve güvenli dosya yazma pattern'lerinde (yaz-taşı) çok işe yarar. tempfile modülü platformdan bağımsız çalışır — Windows, Linux, macOS fark etmez.

Özet

Bu derste Python'da dosya işlemlerinin temellerini öğrendik:

• open() fonksiyonu dosyaları açar. Mode parametresi (r, w, a, rb, wb) dosyanın nasıl açılacağını belirler. Encoding parametresini (utf-8) her zaman belirt.

• with statement dosyaları otomatik kapatır — hata olsa bile. with open(...) as f: kullanmak altın kural. Asla open() / close() ikilisini elle yönetme.

• Okuma yöntemleri: read() tamamını, readline() tek satırı, readlines() tüm satırları listeye yükler. Büyük dosyalar için for satir in dosya: ile satır satır iteration kullan.

• pathlib modülü modern dosya yolu işlemleri için standart. / operatörü ile yol birleştirme, .name, .suffix, .parent gibi özelliklerle yol bileşenlerine erişim sağlar. os.path yerine pathlib tercih et.

• Dosya/dizin kontrolü: exists(), is_file(), is_dir() ile dosya durumunu kontrol et. glob() ve rglob() ile pattern eşleme yap.

• Büyük dosyalar için satır satır iteration veya chunk okuma kullan. Tüm dosyayı belleğe yüklemek gigabyte'larca dosyalarda bellek sorunlarına yol açar.