Python File Handling

Why File Handling Matters — Programs That Remember 📒File Handling क्यों ज़रूरी है — याद रखने वाले Programs 📒为什么文件处理很重要 — 会记忆的程序 📒

In Python, a text file is a sequence of characters stored on disk. Files come in two kinds — text (readable characters: source code, CSV, logs, JSON, HTML) and binary (images, executables, PDFs). This tutorial focuses on text files, which cover most everyday scripting.

Python में text file disk पर रखे अक्षरों का एक क्रम है। Files दो तरह की होती हैं — text (पढ़े जा सकने वाले अक्षर: source code, CSV, logs, JSON, HTML) और binary (images, executables, PDFs)। यह tutorial text files पर केंद्रित है, जो रोज़ के ज़्यादातर scripting काम में आती हैं।

在 Python 中，文本文件 是存储在磁盘上的一串字符。文件分两类 — 文本（可读字符：源代码、CSV、日志、JSON、HTML）和 二进制（图片、可执行文件、PDF）。本教程专注于文本文件，它们覆盖了日常脚本中的大部分需求。

The open() Function — Your Gateway to Every File 🚪open() Function — हर File का दरवाज़ा 🚪open() 函数 — 通往每个文件的大门 🚪

Every file job starts with the built-in open() function. It takes a path and a mode, and gives back a file object you can read from or write to.

हर file का काम built-in open() function से शुरू होता है। यह एक path और एक mode लेता है, और एक file object लौटाता है जिससे आप पढ़ या लिख सकते हैं।

每个文件操作都从内置函数 open() 开始。它接收一个路径和一个模式，返回一个可以读写的 文件对象。

# Basic syntax (we will improve it in Section 04)
f = open("notes.txt", "r", encoding="utf-8")
content = f.read()
f.close()
print(content)

File Modes — Read, Write, Append (and the Ones That Bite) 🎛️File Modes — पढ़ना, लिखना, जोड़ना (और जो काट लेते हैं) 🎛️文件模式 — 读、写、追加（以及会咬人的那些）🎛️

The second argument to open() is the mode. Pick the wrong one and you either can't do what you want — or worse, you silently destroy an existing file.

open() का दूसरा argument mode है। ग़लत चुनें तो या तो आप वह नहीं कर पाते जो चाहते हैं — या उससे बुरा, चुपचाप किसी मौजूदा file को नष्ट कर देते हैं।

open() 的第二个参数是 模式。选错了，要么做不了你想做的事 — 要么更糟，悄无声息地毁掉一个已有文件。

Try It — Mode Explorerकरके देखें — Mode Explorer动手试试 — 模式探索器

Pick a mode, choose what notes.txt looks like before you start, and pick what to do. Watch the file on disk (each box is one character, ↵ is a newline) and the orange cursor — the place where the next read or write happens.

एक mode चुनें, चुनें कि शुरू में notes.txt कैसी है, और चुनें क्या करना है। Disk पर file देखें (हर डिब्बा एक अक्षर है, ↵ एक newline है) और नारंगी cursor — वह जगह जहाँ अगला read या write होगा।

选择一个模式，选择开始前 notes.txt 的样子，再选择要做的操作。观察磁盘上的文件（每个方框是一个字符，↵ 是换行）和橙色的 光标 — 下一次读或写发生的位置。

Text Mode vs Binary ModeText Mode बनाम Binary Mode文本模式与二进制模式

Add "b" to a mode (like "rb", "wb") and you are in binary mode: you read and write raw bytes instead of decoded strings, with no encoding and no newline changes. Use binary for images, PDFs and archives. For anything people read, stay in text mode.

Mode में "b" जोड़ें (जैसे "rb", "wb") तो आप binary mode में हैं: आप decode हुए strings की जगह कच्चे bytes पढ़ते-लिखते हैं, बिना encoding और बिना newline बदलाव के। Images, PDFs और archives के लिए binary इस्तेमाल करें। जो कुछ इंसान पढ़ते हैं, उसके लिए text mode में रहें।

在模式后加上 "b"（如 "rb"、"wb"）就进入二进制模式：读写的是原始 bytes 而不是解码后的字符串，没有编码，也不转换换行。图片、PDF 和压缩包用二进制模式。凡是给人读的内容，都用文本模式。

# Binary mode: bytes in, bytes out — no encoding, no newline changes
with open("data.bin", "wb") as f:
    f.write(bytes([72, 105, 0, 255]))

with open("data.bin", "rb") as f:
    raw = f.read()

print(raw, type(raw).__name__, len(raw))
print(list(raw))

The with Statement — The Right Way to Open Files 🛡️with Statement — Files खोलने का सही तरीका 🛡️with 语句 — 打开文件的正确方式 🛡️

Calling close() yourself is fragile. If an error happens between open and close, the close() line never runs: the file stays open, your writes wait in memory, and on Windows the file stays locked. The with statement (a context manager) closes the file the moment the block ends — even if an error is raised.

close() ख़ुद बुलाना नाज़ुक है। अगर open और close के बीच error आ जाए, तो close() वाली line कभी नहीं चलती: file खुली रहती है, आपके writes memory में इंतज़ार करते हैं, और Windows पर file locked रहती है। with statement (एक context manager) block ख़त्म होते ही file बंद कर देता है — error आने पर भी।

自己调用 close() 很脆弱。如果在 open 和 close 之间发生错误，close() 那一行就永远不会执行：文件保持打开，你写的内容还在内存里等待，在 Windows 上文件还会被锁住。with 语句（一种 上下文管理器）在块结束的那一刻就关闭文件 — 即使抛出了错误。

# The old, error-prone pattern - avoid
f = open("notes.txt", "r", encoding="utf-8")
data = f.read()
f.close()                        # skipped if read() raises

# The correct pattern - use this everywhere
with open("notes.txt", "r", encoding="utf-8") as f:
    data = f.read()
# f is guaranteed closed here, even if read() raised
print(f.closed)
print(data)

Where Do Your Writes Go? The Bufferआपके Writes कहाँ जाते हैं? Buffer你写的内容去哪了？缓冲区

write() does not go straight to the disk. Python collects small writes in a buffer in memory and sends them in one go — much faster. The buffer is emptied to disk ("flushed") when it fills up, when you call flush(), or when the file is closed. This real program proves it:

write() सीधे disk पर नहीं जाता। Python छोटे writes को memory के एक buffer में जमा करता है और एक साथ भेजता है — बहुत तेज़। Buffer disk पर तब ख़ाली ("flush") होता है जब वह भर जाए, जब आप flush() बुलाएँ, या जब file बंद हो। यह असली program इसे साबित करता है:

write() 并不会直接写到磁盘。Python 把小的写入收集在内存中的 缓冲区 里，再一次性写出 — 快得多。缓冲区在写满时、你调用 flush() 时、或文件关闭时才会写到磁盘（"刷新"）。下面这个真实程序证明了这一点：

# Writes go to a BUFFER in memory first, not straight to the disk
f = open("report.txt", "w", encoding="utf-8")
f.write("line 1\n")

with open("report.txt", encoding="utf-8") as reader:
    print("before close:", repr(reader.read()))   # another reader sees nothing yet

f.close()                                          # close() flushes the buffer

with open("report.txt", encoding="utf-8") as reader:
    print("after close: ", repr(reader.read()))

Try It — Buffer Visualizerकरके देखें — Buffer Visualizer动手试试 — 缓冲区可视化

Step through five short programs and watch three places: the buffer in memory, the file on the disk, and what another program sees when it reads the file. Every outcome here was checked with real Python.

पाँच छोटे programs कदम-दर-कदम चलाएँ और तीन जगहें देखें: memory का buffer, disk पर file, और file पढ़ने पर दूसरे program को क्या दिखता है। यहाँ का हर नतीजा असली Python से जाँचा गया है।

一步步执行五个小程序，观察三个地方：内存中的 缓冲区、磁盘 上的文件，以及 另一个程序 读取文件时看到的内容。这里的每个结果都用真实 Python 验证过。

Reading Files — Four Techniques 📖Files पढ़ना — चार तरीके 📖读取文件 — 四种方法 📖

Python gives you four ways to read a text file. They differ in how much they load at once — which matters a lot when the file is big.

Python text file पढ़ने के चार तरीके देता है। फ़र्क़ इसमें है कि वे एक बार में कितना लोड करते हैं — जो बड़ी file के लिए बहुत मायने रखता है।

Python 提供四种读取文本文件的方法。它们的区别在于一次加载 多少 内容 — 文件很大时这一点非常重要。

# Assume notes.txt contains:
#   Buy milk
#   Finish tutorial
#   Call mom

# 1) read() - everything as one string
with open("notes.txt", encoding="utf-8") as f:
    text = f.read()
    print(repr(text))

# 2) readline() - one line, keeps \n
with open("notes.txt", encoding="utf-8") as f:
    first = f.readline()
    print(repr(first))

# 3) readlines() - list of lines
with open("notes.txt", encoding="utf-8") as f:
    lines = f.readlines()
    print(lines)

# 4) Iterate the file - best for large files
with open("notes.txt", encoding="utf-8") as f:
    for i, line in enumerate(f, 1):
        print(f"{i}: {line.rstrip()}")

Try It — Read Cursor Labकरके देखें — Read Cursor Lab动手试试 — 读取光标实验室

A file object remembers where it stopped, like a bookmark. Edit the file text, then press the buttons in any order. Watch the orange cursor move and the real return values appear in the console.

File object याद रखता है कि वह कहाँ रुका, एक bookmark की तरह। File का text बदलें, फिर किसी भी क्रम में buttons दबाएँ। नारंगी cursor को चलते और console में असली return values आते देखें।

文件对象会像书签一样 记住它停在哪里。修改文件文本，然后按任意顺序点击按钮。观察橙色光标的移动，以及控制台中出现的真实返回值。

Here is the most common surprise, in real code: reading twice gives an empty string the second time, until you rewind with seek(0).

यह सबसे आम हैरानी है, असली code में: दो बार पढ़ने पर दूसरी बार ख़ाली string मिलती है, जब तक आप seek(0) से पीछे न जाएँ।

这是最常见的意外，用真实代码演示：连读两次，第二次得到空字符串，直到你用 seek(0) 倒回开头。

with open("notes.txt", encoding="utf-8") as f:
    first = f.read()
    second = f.read()            # the cursor is already at the end
    print(len(first), repr(second), f.tell())
    f.seek(0)                    # rewind to the start
    print(repr(f.readline()))

Writing Files — write() and writelines() ✍️Files लिखना — write() और writelines() ✍️写入文件 — write() 和 writelines() ✍️

Open with "w" to create or replace a file. write() takes one string and returns how many characters it wrote. Neither method adds newlines for you — that is the job of print(), not of files.

File बनाने या बदलने के लिए "w" से खोलें। write() एक string लेता है और बताता है कि कितने अक्षर लिखे। दोनों में से कोई method आपके लिए newline नहीं जोड़ता — यह print() का काम है, files का नहीं।

用 "w" 打开以创建或替换文件。write() 接收一个字符串，返回写入的字符数。两个方法都不会替你加换行 — 那是 print() 的工作，不是文件的。

# write() - one string at a time. Add \n yourself.
with open("todo.txt", "w", encoding="utf-8") as f:
    f.write("Buy milk\n")
    f.write("Finish tutorial\n")
    n = f.write("Call mom\n")
print("write() returned", n, "(characters written)")

# writelines() - takes an iterable. Still no auto-newlines!
with open("todo2.txt", "w", encoding="utf-8") as f:
    f.writelines(["Buy milk", "Finish tutorial", "Call mom"])

# Idiomatic pattern - join then write once
with open("todo3.txt", "w", encoding="utf-8") as f:
    f.write("\n".join(["Buy milk", "Finish tutorial", "Call mom"]) + "\n")

for name in ["todo.txt", "todo2.txt", "todo3.txt"]:
    with open(name, encoding="utf-8") as f:
        print(name, repr(f.read()))

Proof: Mode "w" Wipes Firstसबूत: Mode "w" पहले मिटाता है证明：模式 "w" 会先清空

# Before: todo.txt has 100 important lines
with open("todo.txt", "w", encoding="utf-8") as f:
    f.writelines(f"task {i}\n" for i in range(1, 101))

with open("todo.txt", encoding="utf-8") as f:
    print("lines before:", len(f.readlines()))

# Opening with "w" empties the file at once
with open("todo.txt", "w", encoding="utf-8") as f:
    f.write("just this one line\n")

with open("todo.txt", encoding="utf-8") as f:
    print("lines after: ", len(f.readlines()))   # the other 99 are gone

Appending — Add Without Destroying ➕Append करना — बिना मिटाए जोड़ें ➕追加 — 添加而不破坏 ➕

Mode "a" creates the file if needed and puts every write at the end. Old content is never touched. That makes it perfect for logs, audit trails and anything that grows over time.

Mode "a" ज़रूरत हो तो file बनाता है और हर write को अंत में रखता है। पुराने content को कभी नहीं छूता। इसलिए यह logs, audit trails और समय के साथ बढ़ने वाली हर चीज़ के लिए बढ़िया है।

模式 "a" 在需要时创建文件，并把每次写入放在 末尾。旧内容永远不会被碰。所以它非常适合日志、审计记录以及任何随时间增长的内容。

import datetime

def log_event(message):
    now = datetime.datetime.now().isoformat(timespec="seconds")
    with open("app.log", "a", encoding="utf-8") as f:
        f.write(f"[{now}] {message}\n")

log_event("server started")
log_event("user aarav signed in")
log_event("processed 42 requests")

# Read it back
with open("app.log", encoding="utf-8") as f:
    print(f.read(), end="")

Encodings — Why Your Text Turns Into Garbage 🔤Encodings — आपका Text कचरा क्यों बन जाता है 🔤编码 — 你的文本为什么变成乱码 🔤

# Write with an explicit encoding...
names = ["Sofía", "Zoë", "Björn", "王小明"]
with open("names.txt", "w", encoding="utf-8") as f:
    f.write("\n".join(names) + "\n")

# ...and read with the same one
with open("names.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())

# Read the SAME bytes with the wrong encoding: garbled text ("mojibake")
with open("names.txt", encoding="cp1252", errors="replace") as f:
    print(f.readline().rstrip())

# Without errors=, the wrong encoding can crash
try:
    with open("names.txt", encoding="ascii") as f:
        f.read()
except UnicodeDecodeError as e:
    print("UnicodeDecodeError:", e)

Try It — Encoding Labकरके देखें — Encoding Lab动手试试 — 编码实验室

Type any text. Choose the encoding used to write the file and the one used to read it back. Each box is one byte. Try the chips below for the classic disasters.

कोई भी text लिखें। File लिखने की encoding और वापस पढ़ने की encoding चुनें। हर डिब्बा एक byte है। मशहूर गड़बड़ियाँ देखने के लिए नीचे के chips आज़माएँ।

输入任意文本。选择 写入 文件时用的编码和 读回 时用的编码。每个方框是一个字节。试试下面的按钮，看看经典的翻车现场。

Working with Paths — pathlib 🗺️Paths के साथ काम — pathlib 🗺️处理路径 — pathlib 🗺️

Gluing paths together with + breaks the moment your code runs on another operating system (Windows uses \, Linux and macOS use /). The pathlib module gives you Path objects that join with / and work everywhere. They also have handy shortcuts for small files.

Paths को + से जोड़ना उसी पल टूट जाता है जब आपका code दूसरे operating system पर चलता है (Windows \ इस्तेमाल करता है, Linux और macOS /)। pathlib module आपको Path objects देता है जो / से जुड़ते हैं और हर जगह चलते हैं। छोटी files के लिए इनमें आसान shortcuts भी हैं।

用 + 拼接路径，一旦代码在别的操作系统上运行就会出错（Windows 用 \，Linux 和 macOS 用 /）。pathlib 模块提供 Path 对象，用 / 拼接，到处都能用。它们还为小文件提供了方便的快捷方法。

from pathlib import Path

# Build paths without worrying about \ vs /
data_dir = Path("data")
notes = data_dir / "notes.txt"
print(notes)                     # data/notes.txt (data\notes.txt on Windows)

print("exists?  ", notes.exists())
data_dir.mkdir(exist_ok=True)    # create the folder if needed

# Path has shortcuts for small files
notes.write_text("a new note\n", encoding="utf-8")
print("exists?  ", notes.exists(), "| is file?", notes.is_file())
print("suffix:  ", notes.suffix)
print("stem:    ", notes.stem)
print("parent:  ", notes.parent)

# pathlib plays nicely with open()
with open(notes, encoding="utf-8") as f:
    print(repr(f.read()))
print(repr(notes.read_text(encoding="utf-8")))

Try It — Path Explorerकरके देखें — Path Explorer动手试试 — 路径探索器

Type any path and see how pathlib splits it up. The table shows the exact values Python gives (using POSIX rules, as on Linux and macOS). Try the tricky ones: hidden files, double extensions, messy slashes.

कोई भी path लिखें और देखें कि pathlib उसे कैसे बाँटता है। Table वही values दिखाती है जो Python देता है (POSIX नियमों से, जैसे Linux और macOS पर)। मुश्किल वाले आज़माएँ: hidden files, दोहरे extensions, बिखरे slashes।

输入任意路径，看看 pathlib 如何拆分它。表格显示的是 Python 给出的确切值（按 POSIX 规则，与 Linux 和 macOS 相同）。试试那些棘手的：隐藏文件、双重扩展名、混乱的斜杠。

Handling File Errors Gracefully 🧯File Errors को सलीके से संभालना 🧯优雅地处理文件错误 🧯

Files live outside your program, so things go wrong that your code cannot prevent: a file was deleted, a folder has the wrong permissions, someone saved the data in another encoding. Catch the specific errors you can handle, and let the rest surface.

Files आपके program के बाहर रहती हैं, इसलिए ऐसी गड़बड़ियाँ होती हैं जिन्हें आपका code रोक नहीं सकता: file delete हो गई, folder की permissions ग़लत हैं, किसी ने data दूसरी encoding में save किया। वे ख़ास errors पकड़ें जिन्हें आप संभाल सकते हैं, और बाक़ी को सामने आने दें।

文件存在于程序之外，所以总会发生代码无法阻止的问题：文件被删了，文件夹权限不对，有人用别的编码保存了数据。只捕获你能处理的 具体 错误，其余的让它们暴露出来。

def load_config(path):
    try:
        with open(path, encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        print(f"Config not found at {path}, using defaults")
        return ""
    except PermissionError:
        print(f"No permission to read {path}")
        raise
    except UnicodeDecodeError as e:
        print(f"Encoding problem in {path}: {e}")
        raise

config = load_config("settings.ini")
print(repr(config))

These are the real messages Python prints for each problem — worth recognising on sight:

ये असली संदेश हैं जो Python हर समस्या पर दिखाता है — इन्हें देखते ही पहचानना अच्छा है:

以下是 Python 针对每个问题打印的真实信息 — 值得一眼认出它们：

import os
os.makedirs("logs", exist_ok=True)
with open("bad.txt", "wb") as f:
    f.write(b"caf\xe9")              # "café" saved in cp1252, not UTF-8

tests = [
    lambda: open("missing.txt", encoding="utf-8"),
    lambda: open("notes.txt", "x", encoding="utf-8"),
    lambda: open("logs", encoding="utf-8"),
    lambda: open("bad.txt", encoding="utf-8").read(),
]
for t in tests:
    try:
        t()
    except OSError as e:
        print(type(e).__name__, "->", e)
    except UnicodeDecodeError as e:
        print(type(e).__name__, "->", e)

Common Pitfalls — and How to Dodge Them 🕳️आम गड्ढे — और उनसे कैसे बचें 🕳️常见陷阱 — 以及如何避开 🕳️

Putting It All Together — A Word-Frequency Report 🧩सब कुछ एक साथ — शब्द-गिनती की Report 🧩综合运用 — 词频报告 🧩

This small program uses everything from the tutorial: it reads an article line by line, writes a fresh report with "w", appends a line to an audit log with "a", handles a missing file, and uses pathlib to show the log.

यह छोटा program tutorial की हर चीज़ इस्तेमाल करता है: यह एक article को line-by-line पढ़ता है, "w" से नई report लिखता है, "a" से audit log में एक line जोड़ता है, मौजूद न होने वाली file संभालता है, और log दिखाने के लिए pathlib इस्तेमाल करता है।

这个小程序用到了本教程的所有内容：逐行 读取 一篇文章，用 "w" 写入 一份新报告，用 "a" 向审计日志 追加 一行，处理文件不存在的情况，并用 pathlib 显示日志。

import string
from collections import Counter
from pathlib import Path

def count_words(source_path, report_path, top_n=10):
    counter = Counter()
    translator = str.maketrans("", "", string.punctuation)

    # READ - line by line, so file size does not matter
    try:
        with open(source_path, encoding="utf-8") as f:
            for line in f:
                cleaned = line.lower().translate(translator)
                counter.update(cleaned.split())
    except FileNotFoundError:
        print(f"Source file not found: {source_path}")
        return

    top = counter.most_common(top_n)

    # WRITE - overwrite the report file each run
    with open(report_path, "w", encoding="utf-8") as f:
        f.write(f"Top {top_n} words in {source_path}\n")
        f.write("=" * 40 + "\n")
        for rank, (word, count) in enumerate(top, 1):
            f.write(f"{rank:2d}. {word:15s} {count}\n")

    # APPEND - log this run to an audit file
    with open("runs.log", "a", encoding="utf-8") as f:
        total = sum(counter.values())
        f.write(f"Processed {source_path}: {total} words, {len(counter)} unique\n")

    # Show summary to caller
    print(f"Report written to {report_path}")
    for rank, (word, count) in enumerate(top, 1):
        print(f"  {rank:2d}. {word:15s} {count}")


count_words("article.txt", "report.txt", top_n=5)
print(Path("runs.log").read_text(encoding="utf-8"), end="")

Golden Rules and Quick Quiz 🏆सुनहरे नियम और छोटा Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 7 Questionsछोटा Quiz — 7 सवाल小测验 — 7 道题