کار با فایل ها در پایتون

سال‌ها پیش، در یک پروژه‌ی پردازش داده، برنامه‌ای نوشته بودم که گزارش‌های روزانه را از ده‌ها فایل متنی می‌خواند و در دیتابیس ذخیره می‌کرد. همه‌چیز روی سیستم من درست کار می‌کرد؛ ولی به‌محض استقرار روی سرور مشتری، برنامه با خطای UnicodeDecodeError سقوط کرد. چند ساعت دیباگ کردم تا فهمیدم تفاوت در انکودینگ پیش‌فرض سیستم عامل بود: روی مک من UTF-8 بود و روی سرور لینوکسی، بسته به تنظیمات locale، چیز دیگری. آن تجربه به من یاد داد که کار با فایل‌ها در پایتون، فقط open و read نیست؛ یک مجموعه‌ی دقیق از تصمیم‌هاست که اگر از روز اول درست گرفته نشوند، در محیط تولید به فاجعه تبدیل می‌شوند. در این مقاله، همان مسیری را می‌روم که در پروژه‌های واقعی طی کرده‌ام: از حالت‌های باز کردن فایل تا pathlib، انکودینگ، فایل‌های حجیم و مدیریت خطا.

چرا کار با فایل، مهارتی حیاتی است؟

اگر با مفاهیم پایه‌ی پایتون آشنا نیستید، اول آموزش پایتون از صفر را بخوانید. اما فرض کنیم پایتون را می‌شناسید و می‌خواهید با فایل کار کنید. مسئله این است که تقریباً هر برنامه‌ی واقعی، در نقطه‌ای با فایل سر و کار دارد: خواندن تنظیمات، ذخیره‌ی لاگ، پردازش داده‌ی CSV، تولید گزارش PDF، یا حتی بارگذاری مدل یادگیری ماشین از فایل.

در تجربه‌ی من، خطاهای مربوط به فایل، سه ویژگی ناخوشایند دارند که آن‌ها را از سایر خطاها متمایز می‌کند:

وابسته به محیط: کدی که روی سیستم شما کار می‌کند، روی سرور به دلیل تفاوت مسیر یا مجوز، ممکن است شکست بخورد.
وابسته به انکودینگ: متن فارسی، به‌طور خاص، در برابر انکودینگ نادرست آسیب‌پذیر است.
مخرب: اشتباه در نوشتن فایل، می‌تواند داده‌ی قبلی را از بین ببرد — برخلاف خواندن، که فقط خطا می‌دهد.

به همین سه دلیل، کار با فایل را جدی‌تر از بسیاری از مباحث دیگر پایتون می‌گیرم. اگر با مفهوم خطا در پایتون راحت نیستید، مدیریت خطا در پایتون پیش‌نیاز خوبی است — چون بیشتر مباحث این مقاله، حول محور مدیریت خطاهای فایل می‌چرخد.

هر برنامه‌ای که با فایل کار می‌کند، در واقع با دنیای واقعی حرف می‌زند؛ و دنیای واقعی، هیچ‌وقت به این سادگی که در آموزشگاه‌ها نشان می‌دهند نیست.

حالت‌های باز کردن فایل

تابع open() در پایتون، فایل را با یکی از چند حالت مشخص باز می‌کند. انتخاب حالت درست، قبل از هر چیز مهم است:

حالت	معنی	هشدار
`r`	خواندن (پیش‌فرض)	اگر فایل وجود نداشته باشد، خطا
`w`	نوشتن	محتوای قبلی را پاک می‌کند
`a`	افزودن به انتها	محتوای قبلی حفظ می‌شود
`x`	نوشتن، فقط اگر فایل وجود ندارد	اگر فایل باشد، خطا
`b`	حالت باینری	به همراه یکی از حالت‌های دیگر
`+`	خواندن و نوشتن همزمان	کمتر استفاده می‌شود

حالت w، خطرناک‌ترین حالت است. اگر فایل موجود را با w باز کنید، تمام محتوای قبلی از بین می‌رود، حتی اگر بعداً چیزی در آن ننویسید. در پروژه‌های واقعی، بارها دیده‌ام که اشتباه در انتخاب w به‌جای a، داده‌ی روزهای گذشته‌ی یک لاگ را نابود کرده است. قاعده‌ی ساده‌ی من: اگر مطمئن نیستید که می‌خواهید محتوای قبلی را جایگزین کنید، از a استفاده کنید.

حالت x کم‌استفاده است ولی کاربرد مهمی دارد: اگر می‌خواهید مطمئن شوید که فایل وجود ندارد و از روی آن بسازید (بدون ریسک پاک‌کردن)، x انتخاب درست است. اگر فایل موجود باشد، خطای FileExistsError می‌گیرید که خودش نوعی محافظت است.

با statement: بهترین دوست شما

در آموزشگاه‌ها اغلب روش قدیمی را یاد می‌دهند:

# روش قدیمی: خطرناک
f = open("data.txt", "r")
content = f.read()
f.close()  # اگر خطا رخ دهد، این خط اجرا نمی‌شود

مشکل این روش، مشخص است: اگر بین open و close خطایی رخ دهد، فایل بسته نمی‌شود و در حافظه باقی می‌ماند. در پروژه‌ی بزرگ، این نوع نشتی فایل، می‌تواند در نهایت به خطای «Too many open files» منجر شود.

راه درست، استفاده از with است که فایل را به‌طور خودکار در پایان بلوک می‌بندد، حتی اگر خطایی رخ دهد:

with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()
# فایل به‌طور خودکار بسته شده است

از زمانی که با with آشنا شدم، دیگر هیچ‌وقت از روش قدیمی استفاده نکرده‌ام. حتی برای اسکریپت‌های کوچک. دلیلش این است که رویکرد دفاعی، از همان ابتدا باید عادت شود — وگرنه در پروژه‌ی بزرگ، جایی که فراموش کردن close به فاجعه تبدیل می‌شود، به یاد نمی‌آید.

with فقط یک ترفند سینتکسی نیست؛ یک تعهد است که هر منبعی که باز می‌کنید، در پایان آزاد خواهد شد — این عادت، در کل مسیر حرفه‌ای شما ارزش دارد.

خواندن فایل: چهار روش

پایتون چهار راه اصلی برای خواندن فایل دارد که هر کدام، برای موقعیت متفاوتی مناسب است:

۱) `read()`: خواندن کل فایل

with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

مناسب برای فایل‌های کوچک. اگر فایل شما چند مگابایت است، این روش را انتخاب کنید. اگر بزرگ‌تر است، به‌سراغ روش‌های پایین بروید.

۲) `readline()`: خواندن خط‌به‌خط

with open("data.txt", "r", encoding="utf-8") as f:
    line = f.readline()
    while line:
        process(line)
        line = f.readline()

۳) `readlines()`: خواندن همه‌ی خطوط در یک لیست

with open("data.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()

۴) پیمایش مستقیم شیء فایل: بهترین روش برای فایل‌های بزرگ

with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        process(line)

روش چهارم، که کمترین استفاده را در آموزش‌ها دارد، در عمل بهترین است: چون شیء فایل در پایتون خودش یک iterator است و هر خط را یکی‌یکی بارگذاری می‌کند، نه این‌که کل فایل را در حافظه بیاورد. اگر می‌خواهید یک فایل چند گیگابایتی را پردازش کنید، تنها راه معقول همین است. تجربه‌ی من در پروژه‌های پردازش لاگ: تفاوت مصرف حافظه بین readlines() و پیمایش مستقیم، در یک فایل ۵ گیگابایتی، بین «کرش» و «چند مگابایت» تفاوت دارد.

نوشتن در فایل

نوشتن، ساده‌تر از خواندن به نظر می‌رسد ولی چند نکته‌ی مهم دارد:

# نوشتن متن
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello\n")
    f.write("World\n")

# افزودن به انتها
with open("log.txt", "a", encoding="utf-8") as f:
    f.write("New entry\n")

نکته‌ی مهمی که در پروژه‌های واقعی بارها دیده‌ام: write() در پایان به‌طور خودکار خط جدید اضافه نمی‌کند. اگر \n نگذارید، همه‌ی خطوط در یک خط طولانی به‌هم می‌چسبند. این یک اشتباه ساده است ولی تا وقتی که در یک ابزار متنی فایل را باز نکنید، متوجهش نمی‌شوید.

نکته‌ی دوم: writelines() که اسمش گمراه‌کننده است، خط جدید اضافه نمی‌کند. اگر لیست رشته‌ای به آن بدهید، همه‌ی آن‌ها را بدون جداکننده پشت‌هم می‌چسباند:

lines = ["line1\n", "line2\n", "line3\n"]
with open("output.txt", "w", encoding="utf-8") as f:
    f.writelines(lines)

یعنی writelines فقط راحتی نوشتن حلقه را حذف می‌کند، نه مسئولیت اضافه‌کردن \n. اگر آن را فراموش کنید، خروجی شما یک خط به‌هم‌چسبیده می‌شود.

انکودینگ و درد اختصاصی متن فارسی

این بخش، مهم‌ترین بخش این مقاله برای مخاطب فارسی‌زبان است. اگر همه‌ی چیزهای دیگر را از این مقاله به‌خاطر نسپارید، همین یک نکته را جدی بگیرید: همیشه، بی‌استثنا، encoding="utf-8" را در open() مشخص کنید.

در پایتون ۳، انکودینگ پیش‌فرض open() بر اساس سیستم‌عامل تعیین می‌شود: در لینوکس و مک، معمولاً UTF-8 است؛ در ویندوز، معمولاً cp1252 یا در نسخه‌های قدیمی‌تر، windows-1256. یعنی همان کدی که روی مک شما کار می‌کند، روی ویندوز مشتری به خطا می‌خورد یا متن فارسی را به‌صورت کاراکترهای عجیب نمایش می‌دهد.

# خطرناک: وابسته به سیستم عامل
with open("data.txt", "r") as f:
    content = f.read()

# درست: همیشه UTF-8
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

سه چیز که در پروژه‌های واقعی به‌کارم آمده:

همیشه UTF-8: برای فایل‌های متنی، بدون استثنا. حتی اگر روی مک کار می‌کنید.
مدیریت خطای انکودینگ: اگر فایلی با انکودینگ ناشناخته دارید، می‌توانید با errors="replace" یا errors="ignore" کار کنید، ولی این کارها داده‌ی اصلی را تغییر می‌دهند. گزینه‌ی بهتر، تشخیص انکودینگ با کتابخانه‌ی chardet است.
خروجی برای Excel: اگر فایل CSV را برای باز کردن در Excel می‌سازید، از utf-8-sig استفاده کنید — نسخه‌ای از UTF-8 که یک BOM در ابتدای فایل می‌گذارد و Excel ویندوز را از سردرگمی نجات می‌دهد.

import chardet

with open("unknown.txt", "rb") as f:
    raw = f.read()
    detected = chardet.detect(raw)
    encoding = detected["encoding"]

with open("unknown.txt", "r", encoding=encoding) as f:
    content = f.read()

اگر با خطای UnicodeDecodeError روبرو شده‌اید، مسیر تشخیص و رفع را در رفع خطای UnicodeDecodeError در پایتون توضیح داده‌ام. تجربه‌ی من: نود درصد خطاهای انکودینگ، با مشخص کردن صریح encoding="utf-8" حل می‌شوند.

فایل‌های باینری: تصویر، PDF و دیگران

برای کار با فایل‌های غیرمتنی (تصویر، PDF، آرشیو)، از حالت rb و wb استفاده می‌کنید:

# خواندن تصویر
with open("image.png", "rb") as f:
    data = f.read()

# نوشتن تصویر
with open("output.png", "wb") as f:
    f.write(data)

در حالت باینری، هیچ انکودینگی اعمال نمی‌شود و داده‌ی خام خوانده یا نوشته می‌شود. بیشترین کاربرد این حالت در پروژه‌های واقعی، کپی‌کردن فایل، آپلود/دانلود، و پردازش تصاویر است:

import shutil

# کپی ساده
shutil.copy("source.png", "destination.png")

# کپی با metadata
shutil.copy2("source.png", "destination.png")

نکته‌ی مهمی که در پروژه‌های واقعی به‌کارم آمده: برای کپی‌کردن فایل، از shutil استفاده کنید نه از خواندن و نوشتن دستی. shutil سریع‌تر است، metadata را حفظ می‌کند، و مدیریت خطاهای پیچیده را در خود دارد.

pathlib در برابر os.path

در پایتون قدیمی، مسیرها را با ماژول os.path می‌ساختیم. مثلاً os.path.join("folder", "file.txt"). از پایتون ۳.۴، ماژول pathlib معرفی شد که راه شیءگرا و خواناتری ارائه می‌دهد:

from pathlib import Path

# مسیر جاری
base = Path.cwd()

# ساخت مسیر (به‌طور خودکار جداکننده‌ی درست را می‌گذارد)
config = base / "config" / "settings.json"

# بررسی وجود
if config.exists():
    print(config.read_text(encoding="utf-8"))

# پیمایش پوشه
for path in base.glob("*.txt"):
    print(path.name)

مزیت‌های pathlib که در پروژه‌های واقعی محسوس است:

جداسازی خودکار: روی ویندوز از \ استفاده می‌کند و روی لینوکس از /. دیگر نیازی نیست نگران این باشید.
خواندن و نوشتن ساده: path.read_text() و path.write_text() نیازی به with و open را حذف می‌کنند.
عملیات پوشه: پیمایش، جستجو، فیلتر کردن — همه با متدهای شیء مسیر انجام می‌شود.
خوانایی بالاتر: Path("folder") / "file.txt" بسیار خواناتر از os.path.join("folder", "file.txt") است.

اگر با PHP آشنا هستید، توابع فایل در PHP معادل نزدیک pathlib را ندارند و بیشتر شبیه os.path هستند — توابع وردپرس برای کار با فایل‌ها را می‌توانید مرور کنید تا تفاوت را ببینید. تجربه‌ی من: از زمانی که با pathlib آشنا شدم، در هیچ پروژه‌ی جدیدی از os.path استفاده نکرده‌ام. مگر در موارد خاصی که با کتابخانه‌ای قدیمی مجبور به استفاده از آن باشم.

مسیر فایل، فقط یک رشته‌ی متنی نیست؛ یک موجودیت با معنای متفاوت روی هر سیستم عامل است. رفتار شیءگرا با آن، نیمی از خطاهای مربوط به مسیر را حذف می‌کند.

فایل‌های JSON و CSV

دو فرمت فایل که در پروژه‌های واقعی بارها استفاده می‌کنم، JSON و CSV هستند.

JSON

import json

# خواندن
with open("data.json", "r", encoding="utf-8") as f:
    data = json.load(f)

# نوشتن
with open("output.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

نکته‌ی مهم در json.dump: ensure_ascii=False را حتماً اضافه کنید. پیش‌فرض این است که همه‌ی کاراکترهای غیر ASCII به \uXXXX تبدیل شوند — یعنی متن فارسی شما به شکلی غیرقابل‌خوان در فایل ذخیره می‌شود. اگر با مفهوم JSON راحت نیستید، JSON چیست و چطور داده‌ها را ساختاردهی می‌کند پایه را توضیح می‌دهد و کار با JSON در پروژه‌های واقعی نکات پیشرفته را می‌گوید.

CSV

import csv

# خواندن
with open("data.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        process(row)

# نوشتن
with open("output.csv", "w", encoding="utf-8-sig", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "email"])
    writer.writeheader()
    writer.writerow({"name": "Ali", "email": "ali@example.com"})

دو نکته‌ی حیاتی در CSV که تجربه‌ی من روی آن‌ها تأکید دارد:

newline="" در open: اگر این پارامتر را نگذارید، در ویندوز خطوط اضافه بین ردیف‌ها ظاهر می‌شود. این باگ کوچک، ساعت‌ها وقت می‌گیرد.
utf-8-sig برای Excel: همان‌طور که گفتم، این انکودینگ یک BOM در ابتدای فایل می‌گذارد تا Excel ویندوز متن فارسی را درست بخواند.

برای تحلیل داده‌های حجیم‌تر، کتابخانه pandas در پایتون ابزار بهتری است؛ ولی برای فرمت‌های ساده، همان json و csv کتابخانه‌ی استاندارد پایتون کافی است.

کار با فایل‌های بزرگ

وقتی فایل از چند صد مگابایت عبور می‌کند، روش‌های معمولی خواندن جواب نمی‌دهند. سه الگو که در پروژه‌های واقعی به‌کارم آمده:

۱) پیمایش خط‌به‌خط

with open("big.txt", "r", encoding="utf-8") as f:
    for line in f:
        process(line)

۲) خواندن در تکه‌های مشخص

CHUNK_SIZE = 1024 * 1024  # ۱ مگابایت

with open("big.bin", "rb") as f:
    while chunk := f.read(CHUNK_SIZE):
        process(chunk)

این الگو با اپراتور := (Walrus operator) در پایتون ۳.۸ به بعد، خواناتر هم شده است.

۳) پردازش موازی

اگر پردازش هر خط مستقل است و CPU گلوگاه، می‌توانید از multiprocessing استفاده کنید. ولی تجربه‌ی من می‌گوید در ۸۰٪ موارد، پردازش سری پایتونی به‌مراتب سریع‌تر از ایجاد پیچیدگی موازی است — به‌خصوص اگر گلوگاه I/O باشد.

کار با فایل‌های بزرگ، جایی است که تفاوت بین کد آماتور و حرفه‌ای به‌وضوح آشکار می‌شود؛ کد آماتور فایل را کامل می‌خواند، کد حرفه‌ای می‌داند که هر خطی، فقط وقتی لازم است بارگذاری شود.

مدیریت خطا در کار با فایل

هر عملیات فایل، می‌تواند شکست بخورد. این خطاها را باید از قبل پیش‌بینی کنید:

خطا	معنی	راه‌حل
`FileNotFoundError`	فایل وجود ندارد	بررسی با `path.exists()`
`PermissionError`	مجوز کافی نیست	بررسی مجوز یا مسیر جایگزین
`IsADirectoryError`	مسیر، پوشه است نه فایل	بررسی نوع مسیر
`UnicodeDecodeError`	انکودینگ اشتباه	تعیین صریح `encoding`
`OSError`	خطاهای دیگر سیستم	بررسی محیط و منابع

الگوی درست مدیریت، همیشه به این شکل است:

from pathlib import Path

path = Path("data.txt")

try:
    content = path.read_text(encoding="utf-8")
except FileNotFoundError:
    log_error(f"File not found: {path}")
    content = None
except PermissionError:
    log_error(f"Permission denied: {path}")
    content = None
except UnicodeDecodeError as e:
    log_error(f"Encoding error: {e}")
    content = None

اگر با خطاهای خاصی روبرو شده‌اید، این مقالات تشخیص دقیق را نشان می‌دهند: رفع خطای FileNotFoundError، رفع خطای PermissionError و رفع خطای OSError. اصول کلی مدیریت خطا را در مدیریت خطا در پایتون با جزئیات بیشتری توضیح داده‌ام.

اشتباهاتی که در پروژه‌های واقعی دیده‌ام

در بازبینی پروژه‌های پایتونی، این اشتباهات را زیاد دیده‌ام و هر کدام، یک درس عملی است:

فراموش کردن encoding="utf-8": شایع‌ترین اشتباه. کدی که روی مک شما کار می‌کند، روی ویندوز مشتری سقوط می‌کند.
استفاده از w به‌جای a: نابودی داده‌ی قبلی. اگر مطمئن نیستید، a انتخاب امن‌تری است.
نبود with: نشتی منابع که در پروژه‌های طولانی‌مدت به کرش منجر می‌شود.
خواندن کل فایل حجیم: خطای حافظه در فایل‌های چند گیگابایتی. باید پیمایش خط‌به‌خط یا تکه‌تکه کرد.
نبود newline="" در CSV: ردیف‌های خالی بین خطوط، مخصوصاً در ویندوز.
نادیده گرفتن خطای I/O: اگر try except ندارید، هر مشکل دیسک یا شبکه، برنامه را متوقف می‌کند.
هارد‌کد کردن مسیرها: مسیر C:\Users\Ali\data.txt روی سرور لینوکسی کار نمی‌کند. همیشه از Path و مسیرهای نسبی استفاده کنید.
نبود cleanup: اگر فایل‌های موقت می‌سازید، باید در پایان پاک شوند. tempfile و TemporaryDirectory این کار را خودکار انجام می‌دهند.

یک توصیه‌ی عملی از تجربه: قبل از استقرار اسکریپت روی سرور، حتماً یک بار آن را با یک فایل نمونه‌ی واقعی از محیط تولید تست کنید. اگر داده‌ی تستی شما همه ASCII است، هیچ‌وقت مشکل انکودینگ را کشف نمی‌کنید.

سخن آخر

کار با فایل در پایتون، اولین جایی است که برنامه‌ی شما از مرزهای ذهن خارج می‌شود و با دنیای واقعی حرف می‌زند. سه نکته‌ی مهم که در این مقاله به آن‌ها رسیدیم: اول، همیشه از with استفاده کنید، حتی برای اسکریپت‌های کوچک — این عادت، در پروژه‌های بزرگ ارزشش را نشان می‌دهد؛ دوم، همیشه encoding="utf-8" را در open() مشخص کنید — این یک خط، بیشتر خطاهای فایل را از شما دور می‌کند؛ سوم، انتخاب حالت درست (خواندن، نوشتن، افزودن) و ابزار مناسب (pathlib، json، csv) تفاوت بین کد شکننده و کد پایدار است.

اگر امروز می‌خواهید شروع کنید، سه کار کوچک پیشنهاد می‌کنم: یک فایل متنی با متن فارسی بسازید و با encoding="utf-8" بخوانید و بنویسید، همان را با pathlib بازنویسی کنید، و یک فایل CSV از داده‌ی واقعی با utf-8-sig بنویسید و در Excel باز کنید. همین سه تمرین کوچک، ۹۰٪ مسائل مربوط به فایل در پروژه‌های واقعی را پوشش می‌دهد. اگر تجربه‌ای از کار با فایل در پروژه‌های خودتان دارید — مخصوصاً اگر با چالش انکودینگ یا فایل‌های حجیم روبرو شده‌اید — در دیدگاه‌ها بنویسید؛ همین نکته‌های میدانی، برای خواننده‌ی بعدی از هر مستند رسمی ارزشمندتر است. 📁