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:
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/ ile başlıyorsa) / işleci önceki her şeyi atar. Kullanıcıların gönderdiği adları bir yola eklemeden önce kontrol et.| Özellik | Sonuç | Anlamı |
|---|---|---|
name | sales.final.csv | tam ad |
stem | sales.final | son uzantı olmadan ad |
suffix / suffixes | .csv / ['.final', '.csv'] | son uzantı / hepsi |
parent | reports/2026 | üst klasör |
parts | ('reports', '2026', 'sales.final.csv') | parçaların demeti |
with_suffix('.xlsx') | reports/2026/sales.final.xlsx | uzantı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
.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.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.
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.
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')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:
| Fonksiyon | Ne 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 |
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.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).
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.
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 suffixBeklenen çı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.
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
Pathyolu bir nesne olarak tutar:/ile birleştir,name,stem,suffix,parent,partsile parçalarına ayır;with_suffixyeni 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 zamanencoding='utf-8'ile) veread_bytes/write_bytes;mkdir(parents=True, exist_ok=True); boyut:stat().st_size.shutil:copy2zamanı da koruyan kopya,copytree,move,make_archive;rmtreekalı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ğunuresolve()+is_relative_to()ile kontrol et.