Dosya sistemi: pathlib ve shutil

`Path` nesneleri ve `/` işleci, yolun parçaları, `exists`, `iterdir`, `glob` ve `rglob` ile arama, metin ve bayt okuyup yazma, `mkdir` ve `stat`, `shutil` ile kopyalama, taşıma, arşivleme ve güvenli silme, geçici klasörler ve bir klasör raporu projesi.

  • İleri
  • 22 dk
  • 12 soru
  • Ders 32 / 66

Bu derste öğreneceklerin

  • Path ve / ile yollar kurmak, onları name, stem, suffix, parent, parts ile parçalarına ayırmak
  • Klasörleri iterdir, glob, rglob ile dolaşmak, dosyaları exists, is_file, stat ile kontrol etmek
  • Metin ve bayt okuyup yazmak, klasör oluşturmak, shutil ile kopyalamak, taşımak ve arşivlemek
  • Güvenli silme alışkanlıklarıyla geçici bir klasörde klasör raporu betiği yazmak

Murad’ın «Projeler» klasöründe yüzlerce dosya var: fotoğraflar, PDF’ler, eski yedekler. En çok yeri hangi dosyalar kaplıyor? Kaç JPG fotoğraf var ve toplam boyutları ne kadar? Bunu elle saymak saatler sürer, Python ise saniyeler içinde cevap verir. «Dosyalar ve mini proje: not hesaplayıcı» dersinde tek bir dosyayı open() ile açtın, «Otomasyon betikleri» dersinde de pathlib ve shutil modüllerini kısaca gördün. Şimdi onları derinlemesine öğreneceğiz: yolları kurmak ve parçalarına ayırmak, klasörlerde arama yapmak, dosya okuyup yazmak, kopyalamak, taşımak ve güvenle silmek.

Path nesneleri: yolu kurmak ve parçalarına ayırmak

Yol ve Path nesnesiTanım

Yol, bir dosyanın veya klasörün dosya sistemindeki adresidir: reports/2026/sales.csv. Mutlak yol kökten başlar (/home/aysel/... ya da C:\Users\...), göreli yol ise geçerli çalışma klasörüne göre hesaplanır. pathlib.Path yolu düz bir metin olarak değil, metotları olan bir nesne olarak tutar ve ayırıcıyı işletim sistemine göre kendisi seçer: Windows’ta \, Linux ve macOS’ta /.

Yollar / işleciyle birleştirilir: Path('reports') / '2026' / 'sales.csv'. Bu, metinleri + ile yapıştırmaktan daha güvenlidir: ayırıcıyı unutmak ya da fazladan koymak mümkün değildir. Dosya adı, uzantı ve üst klasör özellik olarak alınır; with_suffix ve with_stem ise değiştirilmiş yeni bir yol döndürür, çünkü Path değiştirilemez bir nesnedir. PurePosixPath ve PureWindowsPath diske dokunmadan yalnızca yol hesaplar; başka bir sistemin yollarını denemek için kullanışlıdır:

Python
from pathlib import Path, PurePosixPath, PureWindowsPath

report = Path('reports') / '2026' / 'sales.final.csv'
print(report.name, '|', report.stem, '|', report.suffix, '|', report.suffixes)
print(report.parts)
print(report.parent.as_posix(), '|', report.parent.parent.name)
print(report.with_suffix('.xlsx').name, '|', report.with_stem('sales_v2').name)
print(report.as_posix(), '|', report.is_absolute())

print(PureWindowsPath('C:/Users/Aysel') / 'notes.txt')
print(PurePosixPath('/home/aysel') / 'notes.txt')
print(PurePosixPath('uploads') / '/etc/passwd')
Beklenen çıktı
sales.final.csv | sales.final | .csv | ['.final', '.csv']
('reports', '2026', 'sales.final.csv')
reports/2026 | reports
sales.final.xlsx | sales_v2.csv
reports/2026/sales.final.csv | False
C:\Users\Aysel\notes.txt
/home/aysel/notes.txt
/etc/passwd
Son satır bir tuzaktır: sağ taraf mutlak bir yolsa (/ ile başlıyorsa) / işleci önceki her şeyi atar. Kullanıcıların gönderdiği adları bir yola eklemeden önce kontrol et.
ÖzellikSonuçAnlamı
namesales.final.csvtam ad
stemsales.finalson uzantı olmadan ad
suffix / suffixes.csv / ['.final', '.csv']son uzantı / hepsi
parentreports/2026üst klasör
parts('reports', '2026', 'sales.final.csv')parçaların demeti
with_suffix('.xlsx')reports/2026/sales.final.xlsxuzantısı değiştirilmiş yeni yol
reports/2026/sales.final.csv yolu için

Örnekler: yolun parçaları

Problem

1) Path('backup/archive.tar.gz') için suffix, suffixes ve stem nedir?
2) (Path('docs') / 'cv.pdf').with_name('cv_2026.pdf') yolunun parent değeri nedir?
3) PurePosixPath('media') / '/tmp/x.txt' neye eşittir?

Çözümü gösterÇözümü gizle

Çözüm

1) .gz, ['.tar', '.gz'], archive.tar; stem yalnızca son uzantıyı atar.
2) docs; with_name yalnızca son parçayı değiştirir, klasör aynı kalır.
3) /tmp/x.txt; sağdaki mutlak yol kendinden önceki parçayı (media) atar.

Okumaya devam etmek için ücretsiz kaydol

Dersin geri kalan bölümleri, test ve notlar Educora hesabıyla açılır. Kayıt bir dakika sürer; ilerlemen tüm cihazlarında saklanır.

Kontrol ve arama: exists, iterdir, glob, rglob

Bazı Path metotları diske başvurur. exists() yolun var olup olmadığını, is_file() ve is_dir() ise onun dosya mı, klasör mü olduğunu söyler. iterdir() bir klasörün yalnızca ilk düzeyini döndürür, glob(pattern) o klasörde desene uyan yolları verir, rglob(pattern) ise bütün alt klasörlerde de arar (glob('**/' + pattern) ile aynıdır). Desenlerde * herhangi bir karakter dizisi, ? tek bir karakter, [abc] ise listedeki tek bir karakterdir. Bu metotlar liste değil üreteç döndürür ve sonuçların sırası garanti değildir; bu yüzden onları her zaman sorted() ile sırala.

Python
import tempfile
from pathlib import Path


def rel(paths):
    return sorted(p.relative_to(root).as_posix() for p in paths)


with tempfile.TemporaryDirectory() as tmp:
    root = Path(tmp)
    for name in ['notes.txt', 'photos/baku.jpg', 'photos/2025/shusha.JPG',
                 'photos/2025/plan.txt', 'data/sales.csv', 'data/old/sales_2024.csv']:
        file = root / name
        file.parent.mkdir(parents=True, exist_ok=True)
        file.write_text('demo', encoding='utf-8')

    print(rel(root.iterdir()))
    print(rel(root.glob('*.txt')))
    print(rel(root.glob('photos/*')))
    print(rel(root.rglob('*.csv')))
    print(rel(root.rglob('*.jpg', case_sensitive=True)))
    print(rel(p for p in root.rglob('*') if p.suffix.lower() == '.jpg'))
    print((root / 'data').is_dir(), (root / 'data/sales.csv').is_file(), (root / 'nope.txt').exists())
Beklenen çıktı
['data', 'notes.txt', 'photos']
['notes.txt']
['photos/2025', 'photos/baku.jpg']
['data/old/sales_2024.csv', 'data/sales.csv']
['photos/baku.jpg']
['photos/2025/shusha.JPG', 'photos/baku.jpg']
True True False
tempfile.TemporaryDirectory() geçici bir klasör oluşturur ve with bloğu bitince onu içindekilerle birlikte siler; gerçek dosyalarına dokunmadan deneme yapmak için ideal yerdir. relative_to(root).as_posix() uzun geçici kısmı keser ve yolu / ayırıcısıyla gösterir.

Okuma, yazma ve klasör oluşturma

Küçük dosyalar için tek satır yeterlidir: read_text() ve write_text() metni, read_bytes() ve write_bytes() ise baytları (resimler, arşivler) tek seferde okur ve yazar. Metin için encoding='utf-8' argümanını her zaman yaz: o olmadan Windows eski bir kod sayfası kullanabilir. write_text dosyanın üzerine yazar; sona eklemek ya da büyük bir dosyayı satır satır okumak için path.open() ile sıradan bir with bloğu kullan. mkdir(parents=True, exist_ok=True) eksik bütün üst klasörleri oluşturur ve klasör zaten varsa hata vermez. stat().st_size dosya boyutunu bayt olarak verir, unlink() dosyayı siler, rename() ise adını değiştirip yeni yolu döndürür.

Python
import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as tmp:
    root = Path(tmp)
    notes = root / 'notes' / 'day1.txt'
    notes.parent.mkdir(parents=True, exist_ok=True)
    notes.write_text('Salam, Bakı!', encoding='utf-8')
    text = notes.read_text(encoding='utf-8')
    print(text, len(text), notes.stat().st_size)

    logo = root / 'logo.bin'
    logo.write_bytes(bytes([137, 80, 78, 71]))
    print(logo.read_bytes(), logo.stat().st_size)

    with notes.open('a', encoding='utf-8') as f:
        f.write(' Necəsən?')
    print(notes.read_text(encoding='utf-8'))

    done = notes.rename(notes.with_name('day1_done.txt'))
    print(done.name, notes.exists(), sorted(p.name for p in notes.parent.iterdir()))
    (root / 'missing.txt').unlink(missing_ok=True)
    try:
        (root / 'notes').mkdir()
    except FileExistsError as e:
        print('FileExistsError:', Path(e.filename).name)
Beklenen çıktı
Salam, Bakı! 12 13
b'\x89PNG' 4
Salam, Bakı! Necəsən?
day1_done.txt False ['day1_done.txt']
FileExistsError: notes
'Salam, Bakı!' 12 karakterdir ama dosyada 13 bayt tutar: ı harfi UTF-8’de 2 bayttır (bkz. «Unicode, kodlamalar ve bytes» dersi). rename sonrasında eski notes nesnesi artık var olmayan bir yolu gösterir; yeni yolu dönüş değerinden al.

os.path ile (eski üslup)

import os

folder = os.path.join('data', 'raw')
os.makedirs(folder, exist_ok=True)
path = os.path.join(folder, 'sales.csv')
name, ext = os.path.splitext(os.path.basename(path))
if os.path.exists(path):
    with open(path, encoding='utf-8') as f:
        text = f.read()

pathlib ile

from pathlib import Path

folder = Path('data') / 'raw'
folder.mkdir(parents=True, exist_ok=True)
path = folder / 'sales.csv'
name, ext = path.stem, path.suffix
if path.exists():
    text = path.read_text(encoding='utf-8')
İki sürüm de aynı işi yapar. Eski kodlarda sık sık os.path görürsün, ama yeni kodda pathlib daha kısa ve okunaklıdır; open(), shutil ve diğer fonksiyonlar Path nesnelerini doğrudan kabul eder.

shutil: kopyalama, taşıma, arşivleme, silme

Path tek dosyalarla çalışır; bütün klasörler ise shutil (“shell utilities”) modülünün işidir. Bu modülün fonksiyonları hem metin hem de Path nesnesi kabul eder:

FonksiyonNe yapar
shutil.copy(src, dst)dosyanın içeriğini ve izinlerini kopyalar; dst bir klasörse dosya aynı adla onun içine kopyalanır
shutil.copy2(src, dst)aynısı, ayrıca değiştirilme zamanını da korur; yedekler için en iyisi
shutil.copytree(src, dst, ignore=...)bütün bir klasörü kopyalar; ignore_patterns('*.tmp') gereksiz dosyaları atlar
shutil.move(src, dst)dosya veya klasörü taşır (başka bir diske bile)
shutil.make_archive(base, 'zip', root_dir)bir klasörden ZIP (veya tar) arşivi oluşturur ve arşivin yolunu döndürür
shutil.rmtree(path)klasörü içindeki her şeyle kalıcı olarak siler
Python
import shutil
import tempfile
import zipfile
from pathlib import Path


def files(root):
    return sorted(p.relative_to(root).as_posix() for p in root.rglob('*') if p.is_file())


with tempfile.TemporaryDirectory() as tmp:
    root = Path(tmp)
    src = root / 'project'
    (src / 'docs').mkdir(parents=True)
    (src / 'main.py').write_text('print("hi")', encoding='utf-8')
    (src / 'docs' / 'readme.md').write_text('# Project', encoding='utf-8')

    shutil.copy2(src / 'main.py', src / 'main_backup.py')
    shutil.copytree(src, root / 'copy', ignore=shutil.ignore_patterns('*_backup.py'))
    shutil.move(src / 'docs' / 'readme.md', src / 'README.md')
    print(files(root))

    archive = Path(shutil.make_archive(str(root / 'project'), 'zip', root_dir=src))
    print(archive.name, sorted(zipfile.ZipFile(archive).namelist()))
    shutil.rmtree(root / 'copy')
    print(sorted(p.name for p in root.iterdir()))
Beklenen çıktı
['copy/docs/readme.md', 'copy/main.py', 'project/README.md', 'project/main.py', 'project/main_backup.py']
project.zip ['README.md', 'docs/', 'main.py', 'main_backup.py']
['project', 'project.zip']
copytree, main_backup.py dosyasını atladı; move ise readme.md dosyasını README.md adıyla taşıdı. Arşivde docs/ boş bir klasör olarak kaldı: bir dosya taşınınca klasörü kendiliğinden silinmez.
Python
import shutil
import tempfile
from pathlib import Path


def safe_rmtree(target, root, dry_run=True):
    target, root = Path(target).resolve(), Path(root).resolve()
    if target == root or not target.is_relative_to(root):
        raise ValueError(f'refusing to delete outside {root.name}: {target.name}')
    victims = sorted(p.relative_to(root).as_posix() for p in target.rglob('*'))
    if dry_run:
        print('would delete:', victims)
    else:
        shutil.rmtree(target)
        print('deleted', target.relative_to(root).as_posix())


with tempfile.TemporaryDirectory() as tmp:
    root = Path(tmp) / 'workspace'
    (root / 'cache' / 'img').mkdir(parents=True)
    (root / 'cache' / 'img' / 'a.png').write_bytes(b'png')
    safe_rmtree(root / 'cache', root)
    safe_rmtree(root / 'cache', root, dry_run=False)
    try:
        safe_rmtree(root / '..' / 'secrets', root, dry_run=False)
    except ValueError as e:
        print('ValueError:', e)
Beklenen çıktı
would delete: ['cache/img', 'cache/img/a.png']
deleted cache
ValueError: refusing to delete outside workspace: secrets
resolve(), .. parçalarını açar ve mutlak bir yol döndürür; bu yüzden workspace/../secrets yolunun kökün dışına çıktığı yakalanır. Kökün kendisini silmek de reddedilir.

Mini proje: klasör raporu

Şimdi her şeyi birleştiriyoruz. folder_report(root) fonksiyonu bütün klasörü dolaşır ve şu soruları cevaplar: kaç dosya var ve toplam boyut ne kadar, her uzantı ne kadar yer kaplıyor, en büyük üç dosya hangileri ve hangi klasörler boş. Uzantıyı lower() ile küçük harfe çeviriyoruz ki .JPG ile .jpg aynı gruba düşsün; uzantısı olmayan dosyalar (none) grubuna yazılır. Deneme için geçici bir klasörde belirli boyutlarda dosyalar oluşturuyoruz (b'x' * size).

Python
import tempfile
from collections import defaultdict
from pathlib import Path


def folder_report(root, top=3):
    files = [p for p in root.rglob('*') if p.is_file()]
    stats = defaultdict(lambda: [0, 0])               # suffix -> [count, bytes]
    for p in files:
        s = stats[p.suffix.lower() or '(none)']
        s[0] += 1
        s[1] += p.stat().st_size
    print(f'{len(files)} files, {sum(v[1] for v in stats.values())} bytes')
    for suffix, (count, size) in sorted(stats.items(), key=lambda kv: kv[1][1], reverse=True):
        print(f'  {suffix:7} {count} file(s) {size:7} bytes')
    print('largest:')
    for p in sorted(files, key=lambda p: p.stat().st_size, reverse=True)[:top]:
        print(f'  {p.relative_to(root).as_posix():20} {p.stat().st_size:7}')
    empty = [d.relative_to(root).as_posix() for d in root.rglob('*') if d.is_dir() and not any(d.iterdir())]
    print('empty folders:', sorted(empty))


with tempfile.TemporaryDirectory() as tmp:
    root = Path(tmp)
    sizes = {'photos/baku.jpg': 52_000, 'photos/shusha.JPG': 48_500, 'docs/cv.pdf': 21_300,
             'docs/notes.txt': 1_200, 'music/song.mp3': 64_000, 'README': 300}
    for name, size in sizes.items():
        (root / name).parent.mkdir(parents=True, exist_ok=True)
        (root / name).write_bytes(b'x' * size)
    (root / 'docs' / 'old').mkdir()
    (root / 'tmp').mkdir()
    folder_report(root)
Beklenen çıktı
6 files, 187300 bytes
  .jpg    2 file(s)  100500 bytes
  .mp3    1 file(s)   64000 bytes
  .pdf    1 file(s)   21300 bytes
  .txt    1 file(s)    1200 bytes
  (none)  1 file(s)     300 bytes
largest:
  music/song.mp3         64000
  photos/baku.jpg        52000
  photos/shusha.JPG      48500
empty folders: ['docs/old', 'tmp']
defaultdict(lambda: [0, 0]) her yeni uzantı için bir [sayı, bayt] çifti oluşturur. Boş klasörü not any(d.iterdir()) bulur: any ilk öğeyi görünce durur, bu yüzden büyük klasörlerde de hızlıdır.

Gerçek bir betikte root komut satırından gelir (bkz. «Komut satırı uygulamaları: argparse ve click»), rapor da print yerine günlüğe yazılır («Günlük kaydı: logging modülü»). Çok büyük klasörlerde her dosyanın boyutunu bir kez hesaplayıp bir sözlükte tutmak, stat() çağrısının dosya başına birkaç kez yapılmasını önler.

Alıştırma

tree klasöründeki bütün dosyaları (alt klasörler dahil) uzantıya göre say. Büyük ve küçük harf fark etmesin (.TXT = .txt). Sonucu uzantının alfabetik sırasıyla suffix count satırları olarak yazdır.

Alıştırma · Python
from pathlib import Path

for name in ['a.txt', 'b.TXT', 'img/c.jpg', 'img/d.png', 'img/2026/e.JPG', 'docs/f.pdf']:
    p = Path('tree') / name
    p.parent.mkdir(parents=True, exist_ok=True)
    p.write_text('x', encoding='utf-8')

counts = {}
# go through every file under 'tree' with rglob, count it by its lower-case suffix,
# then print "suffix count" lines in alphabetical order of the suffix
Beklenen çıktı
.jpg 2
.pdf 1
.png 1
.txt 2

Alıştırma

backup(file, backup_dir) fonksiyonunu yaz: backup_dir yoksa onu üst klasörleriyle birlikte oluştursun, dosyayı oraya shutil.copy2 ile <ad>.bak adıyla (report.txt → report.txt.bak) kopyalasın ve yeni yolu döndürsün.

Alıştırma · Python
import shutil
from pathlib import Path

Path('report.txt').write_text('Q3 revenue: 1250 AZN', encoding='utf-8')


def backup(file, backup_dir):
    # create backup_dir (with its parents) if it is missing,
    # copy the file there as <name>.bak and return the new path
    pass


copy = backup(Path('report.txt'), Path('archive') / '2026')
print(copy.as_posix())
print(copy.read_text(encoding='utf-8'))
print(sorted(p.as_posix() for p in Path('archive').rglob('*')))
Beklenen çıktı
archive/2026/report.txt.bak
Q3 revenue: 1250 AZN
['archive/2026', 'archive/2026/report.txt.bak']

Unutma

  • Path yolu bir nesne olarak tutar: / ile birleştir, name, stem, suffix, parent, parts ile parçalarına ayır; with_suffix yeni bir yol döndürür.
  • iterdir() tek düzey, glob() bir desen, rglob() bütün alt klasörler; sonuçları sorted() ile sırala ve harf duyarlılığını açıkça belirle.
  • read_text/write_text (her zaman encoding='utf-8' ile) ve read_bytes/write_bytes; mkdir(parents=True, exist_ok=True); boyut: stat().st_size.
  • shutil: copy2 zamanı da koruyan kopya, copytree, move, make_archive; rmtree kalıcı silme.
  • Denemeleri tempfile.TemporaryDirectory() içinde yap; silmeden önce deneme çalıştırması yap ve yolun kök klasörün içinde olduğunu resolve() + is_relative_to() ile kontrol et.
Bu derste bir hata ya da yanlışlık mı gördün?

Kendini test et

12 soru. Her doğru cevap XP kazandırır.

Soru 1 / 12

Soru 1 / 12. Path('a') / 'b' / 'c.txt' ne oluşturur?