Python Pathlib: 현대적인 파일 경로 처리 가이드

# os.path 접근법
import os
import glob
 
data_dir = os.path.join(os.path.expanduser('~'), 'projects', 'data')
csv_files = glob.glob(os.path.join(data_dir, '**', '*.csv'), recursive=True)
if csv_files:
    with open(csv_files[0], 'r') as f:
        content = f.read()

# pathlib 접근법
from pathlib import Path
 
data_dir = Path.home() / 'projects' / 'data'
csv_files = list(data_dir.rglob('*.csv'))
if csv_files:
    content = csv_files[0].read_text()

from pathlib import Path
 
# 문자열에서
p = Path('/home/user/documents/report.csv')
 
# 여러 세그먼트에서 (자동으로 결합됨)
p = Path('home', 'user', 'documents', 'report.csv')
 
# 현재 작업 디렉토리
cwd = Path.cwd()
print(cwd)  # 예: /home/user/projects/myapp
 
# 사용자 홈 디렉토리
home = Path.home()
print(home)  # 예: /home/user
 
# 상대 경로
p = Path('data/output/results.csv')
 
# 기존 경로에서
base = Path('/home/user')
full = Path(base, 'documents', 'file.txt')
print(full)  # /home/user/documents/file.txt

from pathlib import Path
 
# 자연스럽게 경로 구축
project = Path.home() / 'projects' / 'analysis'
data_file = project / 'data' / 'sales_2026.csv'
print(data_file)  # /home/user/projects/analysis/data/sales_2026.csv
 
# Path 객체와 문자열 혼합
base = Path('/var/log')
app_log = base / 'myapp' / 'error.log'
print(app_log)  # /var/log/myapp/error.log
 
# 변수와 결합
filename = 'report.pdf'
output = Path('output') / filename
print(output)  # output/report.pdf

from pathlib import Path
 
# Path('data') / 'raw' / 'file.csv'와 동일
p = Path('data').joinpath('raw', 'file.csv')
print(p)  # data/raw/file.csv

from pathlib import Path
 
p = Path('/home/user/projects/analysis/data/sales_report.final.csv')
 
print(p.name)       # sales_report.final.csv  (확장자 포함 파일명)
print(p.stem)       # sales_report.final      (마지막 확장자 제외 파일명)
print(p.suffix)     # .csv                    (마지막 확장자)
print(p.suffixes)   # ['.final', '.csv']      (모든 확장자)
print(p.parent)     # /home/user/projects/analysis/data
print(p.anchor)     # /                       (Unix의 루트, Windows의 C:\)
print(p.parts)      # ('/', 'home', 'user', 'projects', 'analysis', 'data', 'sales_report.final.csv')

from pathlib import Path
 
p = Path('/home/user/projects/analysis/data/output.csv')
 
print(p.parent)            # /home/user/projects/analysis/data
print(p.parent.parent)     # /home/user/projects/analysis
print(p.parent.parent.parent)  # /home/user/projects
 
# .parents는 모든 조상에 대한 인덱스 접근을 제공합니다
print(p.parents[0])  # /home/user/projects/analysis/data
print(p.parents[1])  # /home/user/projects/analysis
print(p.parents[2])  # /home/user/projects
print(p.parents[3])  # /home/user

from pathlib import Path
 
p = Path('/data/reports/sales_q1.csv')
 
# 파일명 전체 변경
print(p.with_name('revenue_q1.csv'))    # /data/reports/revenue_q1.csv
 
# stem만 변경 (Python 3.9+)
print(p.with_stem('sales_q2'))          # /data/reports/sales_q2.csv
 
# 확장자만 변경
print(p.with_suffix('.parquet'))        # /data/reports/sales_q1.parquet
 
# 확장자 제거
print(p.with_suffix(''))                # /data/reports/sales_q1
 
# 확장자 추가
backup = p.with_suffix(p.suffix + '.bak')
print(backup)                           # /data/reports/sales_q1.csv.bak

from pathlib import Path
 
file_path = Path('example.txt')
 
# 파일에 텍스트 쓰기 (없으면 생성, 있으면 덮어쓰기)
file_path.write_text('Hello, pathlib!\nSecond line.')
 
# 파일에서 텍스트 읽기
content = file_path.read_text()
print(content)
# Hello, pathlib!
# Second line.
 
# 바이트 쓰기
binary_path = Path('data.bin')
binary_path.write_bytes(b'\x00\x01\x02\x03')
 
# 바이트 읽기
raw = binary_path.read_bytes()
print(raw)  # b'\x00\x01\x02\x03'

from pathlib import Path
 
# UTF-8 텍스트 쓰기
Path('greeting.txt').write_text('こんにちは世界', encoding='utf-8')
 
# 인코딩과 함께 읽기
text = Path('greeting.txt').read_text(encoding='utf-8')
print(text)  # こんにちは世界

from pathlib import Path
 
log_file = Path('application.log')
 
# 한 줄씩 쓰기
with log_file.open('w') as f:
    for i in range(1000):
        f.write(f'Event {i}: processed\n')
 
# 한 줄씩 읽기 (큰 파일에 메모리 효율적)
with log_file.open('r') as f:
    for line in f:
        if 'error' in line.lower():
            print(line.strip())

from pathlib import Path
 
# 단일 디렉토리 생성
Path('output').mkdir()
 
# 상위 디렉토리와 함께 생성 (os.makedirs와 유사)
Path('data/raw/2026/february').mkdir(parents=True, exist_ok=True)
 
# parents=True는 누락된 모든 상위 디렉토리를 생성합니다
# exist_ok=True는 디렉토리가 이미 존재할 때 오류를 방지합니다

from pathlib import Path
 
project = Path('.')
 
# 모든 항목 나열 (파일과 디렉토리)
for entry in project.iterdir():
    print(entry.name, '(dir)' if entry.is_dir() else '(file)')
 
# 파일만 필터링
files = [f for f in project.iterdir() if f.is_file()]
print(f"Found {len(files)} files")
 
# 디렉토리만 필터링
dirs = [d for d in project.iterdir() if d.is_dir()]
print(f"Found {len(dirs)} directories")
 
# 이름으로 정렬
for entry in sorted(project.iterdir()):
    print(entry.name)

from pathlib import Path
 
# 파일 삭제
Path('temp_output.csv').unlink()
 
# 파일이 존재할 때만 삭제 (Python 3.8+)
Path('temp_output.csv').unlink(missing_ok=True)
 
# 빈 디렉토리 삭제
Path('empty_dir').rmdir()

from pathlib import Path
import shutil
 
target = Path('data/old_output')
if target.exists():
    shutil.rmtree(target)

from pathlib import Path
 
project = Path('/home/user/project')
 
# 디렉토리의 모든 Python 파일 찾기
for py_file in project.glob('*.py'):
    print(py_file.name)
 
# 모든 CSV 파일 찾기
csv_files = list(project.glob('*.csv'))
print(f"Found {len(csv_files)} CSV files")
 
# 패턴과 일치하는 파일 찾기
reports = list(project.glob('report_*.xlsx'))

from pathlib import Path
 
project = Path('/home/user/project')
 
# 모든 하위 디렉토리의 모든 Python 파일 찾기
all_py = list(project.rglob('*.py'))
print(f"Found {len(all_py)} Python files across all directories")
 
# 재귀적으로 모든 Jupyter 노트북 찾기
notebooks = list(project.rglob('*.ipynb'))
for nb in notebooks:
    print(f"  {nb.relative_to(project)}")
 
# 모든 이미지 파일 찾기
images = list(project.rglob('*.png')) + list(project.rglob('*.jpg'))
 
# 모든 파일 찾기 (필터 없음)
all_files = [f for f in project.rglob('*') if f.is_file()]

from pathlib import Path
 
data = Path('data')
 
# 단일 문자 와일드카드
data.glob('file_?.csv')        # file_1.csv, file_a.csv
 
# 문자 범위
data.glob('report_202[456].csv')  # report_2024.csv, report_2025.csv, report_2026.csv
 
# 모든 하위 디렉토리 레벨
data.glob('**/output/*.csv')   # data/raw/output/result.csv, data/processed/output/result.csv
 
# 여러 확장자 (두 개의 glob 결합)
from itertools import chain
all_data = chain(data.rglob('*.csv'), data.rglob('*.parquet'))

from pathlib import Path
 
p = Path('/home/user/projects/data.csv')
 
# 경로가 존재합니까?
print(p.exists())       # True 또는 False
 
# 파일입니까?
print(p.is_file())      # 존재하고 일반 파일이면 True
 
# 디렉토리입니까?
print(p.is_dir())       # 존재하고 디렉토리면 True
 
# 심볼릭 링크입니까?
print(p.is_symlink())   # 존재하고 심볼릭 링크면 True
 
# 절대 경로입니까?
print(p.is_absolute())  # True (/home/...이 루트로 시작)
print(Path('data.csv').is_absolute())  # False (상대 경로)

from pathlib import Path
 
config = Path('config.yaml')
if config.is_file():
    settings = config.read_text()
else:
    print("Config file not found, using defaults")

from pathlib import Path
 
# 절대 경로로 해석 (심볼릭 링크도 해석)
p = Path('data/../data/./output.csv')
print(p.resolve())  # /home/user/project/data/output.csv
 
# 심볼릭 링크를 해석하지 않고 절대 경로 얻기
print(p.absolute())  # /home/user/project/data/../data/./output.csv
 
# 사용자 홈 디렉토리 확장
p = Path('~/Documents/report.csv')
print(p.expanduser())  # /home/user/Documents/report.csv

from pathlib import Path
 
full_path = Path('/home/user/projects/analysis/data/output.csv')
base = Path('/home/user/projects')
 
# base에서 full_path까지의 상대 경로 얻기
relative = full_path.relative_to(base)
print(relative)  # analysis/data/output.csv
 
# 경로가 base에 대해 상대적이지 않으면 ValueError 발생
try:
    Path('/var/log/app.log').relative_to(base)
except ValueError as e:
    print(e)  # '/var/log/app.log' is not relative to '/home/user/projects'
 
# Python 3.12+: is_relative_to() 확인
print(full_path.is_relative_to(base))   # True
print(Path('/var/log').is_relative_to(base))  # False

from pathlib import Path
from datetime import datetime
 
p = Path('data.csv')
 
# 파일 상태 얻기
stat = p.stat()
print(f"Size: {stat.st_size} bytes")
print(f"Modified: {datetime.fromtimestamp(stat.st_mtime)}")
print(f"Created: {datetime.fromtimestamp(stat.st_ctime)}")
 
# 편의 기능: stat를 통해 크기 직접 얻기
size_mb = p.stat().st_size / (1024 * 1024)
print(f"Size: {size_mb:.2f} MB")
 
# 두 경로가 동일한 파일을 가리키는지 확인
p1 = Path('/home/user/data.csv')
p2 = Path.home() / 'data.csv'
print(p1.samefile(p2))  # True (동일한 파일로 해석되면)

from pathlib import Path
 
# 파일 이름 변경 (새 Path 반환)
old = Path('report_draft.csv')
new = old.rename('report_final.csv')
print(new)  # report_final.csv
 
# 다른 디렉토리로 이동
source = Path('output/temp_results.csv')
dest = source.rename(Path('archive') / source.name)
 
# 파일 교체 (대상이 존재하면 덮어쓰기)
Path('new_data.csv').replace('data.csv')

from pathlib import Path
import tempfile
 
# Path로 임시 디렉토리 생성
with tempfile.TemporaryDirectory() as tmp_dir:
    tmp_path = Path(tmp_dir)
 
    # pathlib을 사용해 임시 파일 쓰기
    data_file = tmp_path / 'intermediate_results.csv'
    data_file.write_text('col1,col2\n1,2\n3,4\n')
 
    config_file = tmp_path / 'run_config.json'
    config_file.write_text('{"epochs": 100, "lr": 0.001}')
 
    # 생성한 것들 나열
    for f in tmp_path.iterdir():
        print(f"{f.name}: {f.stat().st_size} bytes")
 
    # 파일 처리...
    print(data_file.read_text())
 
# 여기서 디렉토리와 모든 파일이 자동으로 삭제됨

from pathlib import Path
import tempfile
 
# 이름이 있는 임시 파일 생성
tmp = tempfile.NamedTemporaryFile(suffix='.csv', delete=False)
tmp_path = Path(tmp.name)
tmp.close()
 
# pathlib을 사용해 쓰기
tmp_path.write_text('id,value\n1,100\n2,200\n')
print(f"Temp file at: {tmp_path}")
 
# 완료 후 정리
tmp_path.unlink()

from pathlib import Path
 
def setup_experiment(experiment_name):
    """표준 실험 디렉토리 구조 생성."""
    base = Path('experiments') / experiment_name
 
    dirs = ['data/raw', 'data/processed', 'models', 'results/figures', 'results/tables', 'logs']
 
    for d in dirs:
        (base / d).mkdir(parents=True, exist_ok=True)
 
    # 설정 파일 생성
    config = base / 'config.json'
    if not config.exists():
        config.write_text('{"learning_rate": 0.001, "epochs": 50}')
 
    print(f"Experiment directory ready: {base.resolve()}")
    return base
 
project = setup_experiment('sales_forecast_v2')

from pathlib import Path
import pandas as pd
 
data_dir = Path('data/raw')
 
# 모든 CSV 파일을 단일 DataFrame으로 읽기
dfs = []
for csv_file in sorted(data_dir.glob('*.csv')):
    print(f"Loading {csv_file.name}...")
    df = pd.read_csv(csv_file)
    df['source_file'] = csv_file.stem  # 소스 파일명 추가
    dfs.append(df)
 
combined = pd.concat(dfs, ignore_index=True)
print(f"Loaded {len(combined)} rows from {len(dfs)} files")
 
# 처리된 디렉토리에 저장
output_path = Path('data/processed') / 'combined_sales.parquet'
output_path.parent.mkdir(parents=True, exist_ok=True)
combined.to_parquet(output_path)

from pathlib import Path
from datetime import datetime
import json
 
def save_results(metrics, experiment_dir):
    """타임스탬프와 함께 실험 메트릭 저장."""
    results_dir = Path(experiment_dir) / 'results'
    results_dir.mkdir(parents=True, exist_ok=True)
 
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    output_file = results_dir / f'metrics_{timestamp}.json'
 
    output_file.write_text(json.dumps(metrics, indent=2))
    print(f"Results saved to {output_file}")
    return output_file
 
# 사용법
metrics = {'accuracy': 0.94, 'f1_score': 0.91, 'loss': 0.187}
save_results(metrics, 'experiments/sales_forecast_v2')

from pathlib import Path
 
# 노트북 위치에서 항상 절대 경로로 해석
NOTEBOOK_DIR = Path.cwd()
PROJECT_ROOT = NOTEBOOK_DIR.parent  # 노트북이 notebooks/에 있을 경우
DATA_DIR = PROJECT_ROOT / 'data'
OUTPUT_DIR = PROJECT_ROOT / 'output'
 
# 이제 모든 경로가 절대적이고 신뢰할 수 있음
train_data = DATA_DIR / 'train.csv'
print(f"Loading: {train_data}")
assert train_data.exists(), f"Missing: {train_data}"

from pathlib import Path
import tempfile
 
def safe_write(target_path, content):
    """손상을 방지하기 위해 원자적으로 파일에 내용 쓰기."""
    target = Path(target_path)
    target.parent.mkdir(parents=True, exist_ok=True)
 
    # 동일한 디렉토리에 임시 파일로 쓰기
    tmp = tempfile.NamedTemporaryFile(
        mode='w', dir=target.parent, suffix='.tmp', delete=False
    )
    tmp_path = Path(tmp.name)
    try:
        tmp.write(content)
        tmp.close()
        tmp_path.replace(target)  # 대부분의 파일 시스템에서 원자적
    except Exception:
        tmp_path.unlink(missing_ok=True)
        raise
 
safe_write('config/settings.json', '{"debug": true}')

from pathlib import Path
 
photos_dir = Path('photos')
 
# 모든 .jpeg 파일을 .jpg로 이름 변경
for f in photos_dir.glob('*.jpeg'):
    f.rename(f.with_suffix('.jpg'))
 
# 모든 파일에 접두사 추가
for i, f in enumerate(sorted(photos_dir.glob('*.jpg')), start=1):
    new_name = f.parent / f'photo_{i:04d}{f.suffix}'
    f.rename(new_name)

from pathlib import Path
from collections import defaultdict
 
def find_potential_duplicates(directory):
    """동일한 크기의 파일 찾기 (잠재적 중복)."""
    size_map = defaultdict(list)
 
    for f in Path(directory).rglob('*'):
        if f.is_file():
            size_map[f.stat().st_size].append(f)
 
    # 두 개 이상의 파일이 있는 그룹만 반환
    return {size: files for size, files in size_map.items() if len(files) > 1}
 
dupes = find_potential_duplicates('data')
for size, files in dupes.items():
    print(f"\n{size} bytes:")
    for f in files:
        print(f"  {f}")

from pathlib import Path
 
def tree(directory, prefix='', max_depth=3, _depth=0):
    """디렉토리의 트리 구조 출력."""
    if _depth >= max_depth:
        return
 
    path = Path(directory)
    entries = sorted(path.iterdir(), key=lambda e: (e.is_file(), e.name))
 
    for i, entry in enumerate(entries):
        is_last = (i == len(entries) - 1)
        connector = '└── ' if is_last else '├── '
        print(f'{prefix}{connector}{entry.name}')
 
        if entry.is_dir():
            extension = '    ' if is_last else '│   '
            tree(entry, prefix + extension, max_depth, _depth + 1)
 
tree('my_project', max_depth=3)

├── data
│   ├── processed
│   │   └── combined.csv
│   └── raw
│       ├── sales_2025.csv
│       └── sales_2026.csv
├── notebooks
│   └── analysis.ipynb
├── output
│   └── figures
└── requirements.txt

from pathlib import Path
 
p = Path('data/output.csv')
 
# 잘못됨: 문자열과 Path 비교
if p == 'data/output.csv':  # 작동할 수 있지만 취약함
    print("Match")
 
# 올바름: Path와 Path 비교, 또는 str() 사용
if p == Path('data/output.csv'):
    print("Match")
 
# 올바름: 필요시 문자열로 변환
if str(p) == 'data/output.csv':
    print("Match")

from pathlib import Path
 
# 잘못됨: 'data'가 없으면 FileNotFoundError 발생
# Path('data/raw/2026').mkdir()
 
# 올바름: 누락된 모든 상위 생성
Path('data/raw/2026').mkdir(parents=True, exist_ok=True)

from pathlib import Path
 
base = Path('/home/user')
 
# 잘못됨: 문자열 연결은 pathlib을 망칩니다
# bad = base + '/data/file.csv'  # TypeError
 
# 올바름: / 연산자 사용
good = base / 'data' / 'file.csv'

from pathlib import Path
 
p = Path('data/output.csv')
 
# 대부분의 라이브러리는 Path를 직접 수용
import pandas as pd
df = pd.read_csv(p)  # 잘 작동함
 
# 문자열이 필요한 이전 라이브러리의 경우
import some_legacy_lib
some_legacy_lib.process(str(p))  # str()으로 변환
 
# os.fspath()도 작동 (Python 3.6+)
import os
some_legacy_lib.process(os.fspath(p))

from pathlib import Path
 
# 잘못됨: 하드코딩된 절대 경로
# data_path = Path('/home/alice/project/data/sales.csv')
 
# 올바름: 상대적 또는 동적 구성 요소에서 구축
data_path = Path.cwd() / 'data' / 'sales.csv'
 
# 올바름: 홈 디렉토리에서 구축
config_path = Path.home() / '.config' / 'myapp' / 'settings.json'
 
# 올바름: 환경 변수에서 구축
import os
data_root = Path(os.getenv('DATA_DIR', 'data'))
data_path = data_root / 'sales.csv'