File I - O — open modes (r, w, a, rb), read, readline, readlines, write

1.3.3 · Coding › Python Intermediate

File I/O ko "modes" ki zaroorat kyun padti hai?

Tumhara program RAM mein rehta hai (fast, temporary). File disk par rehti hai (slow, permanent). Dono ke beech data move karne ke liye OS ko tumhara intent pehle hi jaanna chahiye, kyunki woh intent decide karta hai:

KYA — kya file pehle se exist karni chahiye, ya nai banani hai?
KYA — kya purana content destroy (truncate) ho ya rakha jaaye?
KAHAN — cursor start par baithega ya end par?
KAISE — kya hum human-readable text move kar rahe hain (UTF-8 jaisi encoding se decode karke) ya raw bytes?

"Mode" ek chhota sa code hota hai jo yeh sab ek saath answer karta hai.

Mode table (yeh 80/20 core yaad kar lo)

Mode	Reads?	Writes?	File exist karni chahiye?	Truncates?	Cursor start	Returns
`r`	✅	❌	✅ (warna error)	❌	start	`str`
`w`	❌	✅	nahi (create karta hai)	✅ wipes!	start	`str`
`a`	❌	✅	nahi (create karta hai)	❌	end	`str`
`rb`	✅	❌	✅	❌	start	`bytes`
`r+`	✅	✅	✅	❌	start	`str`
`wb`	❌	✅	nahi	✅	start	`bytes`

Figure — File I - O — open modes (r, w, a, rb), read, readline, readlines, write

Read kaise karein: teen methods, ek cursor

File object per ek hi cursor hota hai. Har read use aage badhata hai. Yeh ek hi fact hai jo neeche ke saare surprising behaviour ko explain karta hai.

Worked example — usi file ko 3 tarike se padhna

Maano notes.txt mein yeh hai:

apple
banana
cherry

with open("notes.txt", "r", encoding="utf-8") as f:
    whole = f.read()        # 'apple\nbanana\ncherry\n'

Yeh step kyun? read() sab kuch ek saath kheeench leta hai; cursor ab end-of-file (EOF) par hai. Doosra read() '' return karega.

with open("notes.txt") as f:
    first = f.readline()    # 'apple\n'
    second = f.readline()   # 'banana\n'

Yeh step kyun? Har readline() \n par ruk jaata hai aur cursor uske theek baad chhod deta hai, isliye agli call wahin se continue hoti hai jahan pichli ruki thi — cursor yaad rakhta hai.

with open("notes.txt") as f:
    lines = f.readlines()   # ['apple\n', 'banana\n', 'cherry\n']
    clean = [ln.rstrip("\n") for ln in lines]  # ['apple','banana','cherry']

Yeh step kyun? readlines() \n ko rakhta hai; hum use rstrip se strip karte hain kyunki humein usually text chahiye hota hai, line break nahi.

Write kaise karein: `write` aur `writelines`

Worked example — write vs append

with open("log.txt", "w", encoding="utf-8") as f:   # log.txt ko WIPE karta hai
    f.write("start\n")
    f.write("step1\n")
# file ab: 'start\nstep1\n'
 
with open("log.txt", "a", encoding="utf-8") as f:   # rakho, cursor END par
    f.write("step2\n")
# file ab: 'start\nstep1\nstep2\n'

Yeh step kyun? w se doosri baar open karne par start/step1 delete ho jaata. a preserve karta hai aur add karta hai — yahi dono mein poora fark hai.

Binary kaise alag hota hai

with open("pic.png", "rb") as f:
    header = f.read(8)      # b'\x89PNG\r\n\x1a\n'  -> ek bytes object

Yeh step kyun? PNG text nahi hai; use UTF-8 se decode karna crash kar dega. rb tumhe raw bytes deta hai jinhe tum inspect kar sakte ho (pehle 8 bytes PNG ka magic number hain).

Common mistakes (Steel-man + fix)

Recall Feynman: 12-saal ke bacche ko samjhao

File shelf par rakhi ek notebook ki tarah hai. open() matlab tum wahan jaate ho aur bolte ho kya karna hai: r = "main sirf padhunga," w = "saare pages nikaalo aur nayi likho," a = "aakhri page par jaao aur likhte raho." Tumhari ungli cursor hai — jab bhi ek line padho, ungli neechey khisak jaati hai, toh agla read wahin se shuru hota hai. read() poori notebook ek saath padhta hai; readline() ek line padhta hai aur ruk jaata hai; readlines() har line ka photocopy list mein karta hai. Aur with ek achha dost hai jo notebook band kar deta hai jab tum kaam khatam kar lo.

Active recall

Mode r kya require karta hai aur kya karta hai?

File pehle se exist karni chahiye; read-only kholta hai cursor start par; agar missing ho toh error.

Mode w existing contents ke saath kya karta hai?

Open hote hi file ko empty kar deta hai (data chala jaata hai), phir start se likhta hai; agar file nahi hai toh banata hai.

Mode a cursor ke saath kya karta hai?

Writing ke liye cursor ko END par rakhke kholta hai; existing data preserve rehta hai, naya data append hota hai; file nahi hai toh banata hai.

rb aur r mein kya fark hai?

rb binary hai: bytes read karta hai (str nahi), koi decoding aur koi newline translation nahi hoti.

f.read() kya return karta hai aur cursor baad mein kahan hota hai?

Poori remaining file ek string ke roop mein; cursor EOF par reh jaata hai (agla read '' deta hai).

f.readline() kya return karta hai?

Agle \n tak aur use include karke ek line; cursor use cross karke aage badhata hai.

f.readlines() kya return karta hai?

Saari remaining lines ki ek list of strings, har ek apna trailing \n rakhti hai.

Kya f.write(s) newline add karta hai?

Nahi — s ko jaise hai waise likhta hai aur likhe gaye characters ki count return karta hai.

f.readlines() ki jagah for line in f: kyun prefer karein?

Yeh lazily padhta hai, ek waqt mein ek line, isliye poori file memory mein kabhi nahi laata.

EOF tak pahunchne ke baad file dobara padhne ke liye bina reopen kiye kya karo?

f.seek(0) call karo taaki cursor wapas start par aa jaaye.

with open(...) as f: kyun use karein?

Yeh file ko auto-close aur flush karta hai chahe exception aaye, lost writes aur leaked handles se bachata hai.

r+ jaisi modes mein + ka matlab kya hai?

Padhne aur likhne dono ke liye open karo.

Connections

Context Managers (with statement) — kyun with close() guarantee karta hai.
Strings and Encoding (UTF-8) — text mode tumhare liye kya decode karta hai.
Bytes vs str — b mode ke peeche type ka fark.
Exceptions try-except — r se aane wala FileNotFoundError handle karna.
os and pathlib — safe file paths banana.
Generators and Lazy Iteration — kyun for line in f: memory-cheap hai.