पायथन में फ़ाइल प्रबंधन: ऐसा डेटा सहेजें जो टिके

फ़ाइल क्यों? टेक्स्ट, बाइनरी और CSV फ़ाइलें

वेरिएबल का डेटा RAM में रहता है और प्रोग्राम ख़त्म होते ही मिट जाता है। फ़ाइल डेटा को डिस्क पर स्थायी रूप से रखती है।

• टेक्स्ट फ़ाइल (.txt): पढ़ने योग्य अक्षर। हर पंक्ति EOL (end of line) अक्षर \n पर ख़त्म होती है। नोटपैड में खुलती है।
• बाइनरी फ़ाइल (.dat, .bin): मेमोरी जैसे कच्चे बाइट। नोटपैड में पढ़ी नहीं जाती। तेज़, और pickle से पायथन ऑब्जेक्ट रख सकती है। EOL का कोई बदलाव नहीं।
• CSV फ़ाइल (.csv, comma-separated values): टेक्स्ट फ़ाइल जिसमें हर पंक्ति तालिका की एक पंक्ति है और मान अल्पविराम से अलग हैं, जैसे 1,Asha,92। स्प्रेडशीट में खुलती है।

Absolute और relative पाथ

पाथ पायथन को बताता है कि फ़ाइल कहाँ है।

• Absolute पाथ: ड्राइव की जड़ (root) से पूरा पता, जैसे C:\\School\\CS\\marks.txt या /home/asha/cs/marks.txt।
• Relative पाथ: वर्तमान कार्य फ़ोल्डर (जहाँ प्रोग्राम चल रहा है) से पता। marks.txt = "इसी फ़ोल्डर में"; data/marks.txt = "data उप-फ़ोल्डर में"; ../marks.txt = "एक फ़ोल्डर ऊपर"।

Windows पाथ में r'C:\School\marks.txt' (raw string) लिखें या दोहरे बैकस्लैश, क्योंकि पाथ के अंदर \n या \t विशेष अक्षर बन जाते हैं।

फ़ाइल खोलना-बंद करना: ओपन मोड और with

f = open('marks.txt', 'r') एक फ़ाइल ऑब्जेक्ट (फ़ाइल हैंडल) देता है। काम के बाद f.close() ज़रूर करें; बंद करने से बफ़र में रुका डेटा भी सहेजा जाता है।

बाइनरी के लिए b जोड़ें: rb, wb, ab, rb+, wb+, ab+।

with स्टेटमेंट

with open('marks.txt', 'r') as f:
    data = f.read()
# यहाँ फ़ाइल अपने-आप बंद

with खंड ख़त्म होते ही फ़ाइल बंद कर देता है, अपवाद आने पर भी।

टेक्स्ट फ़ाइल में लिखना: write और writelines

• f.write(s) एक स्ट्रिंग लिखता है और लिखे अक्षरों की संख्या लौटाता है। यह newline नहीं जोड़ता; '\n' ख़ुद लिखें।
• f.writelines(L) लिस्ट की हर स्ट्रिंग एक के बाद एक लिखता है, यह भी newline नहीं जोड़ता।

with open('poem.txt', 'w') as f:
    f.write('Roses are red\n')
    f.writelines(['Sky is blue\n', 'Python is fun\n'])

बिना मिटाए जोड़ना हो तो 'a' मोड लें।

टेक्स्ट फ़ाइल पढ़ना: read, readline, readlines

• f.read() बची पूरी फ़ाइल एक स्ट्रिंग में। f.read(n) अधिकतम n अक्षर।
• f.readline() एक पंक्ति, उसके \n सहित। फ़ाइल के अंत पर '' देता है।
• f.readlines() सारी पंक्तियाँ स्ट्रिंग की लिस्ट में।
• पंक्ति-दर-पंक्ति लूप: for line in f:

# 'T' से शुरू होने वाली पंक्तियाँ गिनो
c = 0
with open('poem.txt') as f:
    for line in f:
        if line.startswith('T'):
            c += 1
print(c)

अंत का newline हटाने को line.strip(), शब्दों में तोड़ने को line.split()।

seek() और tell(): फ़ाइल पॉइंटर खिसकाना

फ़ाइल पॉइंटर वह जगह (शुरू से बाइटों में) है जहाँ अगला पढ़ना या लिखना होगा।

• f.tell() अभी की जगह बताता है।
• f.seek(offset, whence) उसे खिसकाता है। whence 0 = शुरू से (डिफ़ॉल्ट), 1 = अभी की जगह से, 2 = अंत से। टेक्स्ट मोड में शून्य से अलग offset के साथ केवल whence = 0 सुरक्षित है; बाइनरी में तीनों चलते हैं।

with open('poem.txt') as f:
    print(f.read(5))   # 'Roses'
    print(f.tell())    # 5
    f.seek(0)
    print(f.read(3))   # 'Ros'

pickle से बाइनरी फ़ाइल: dump और load

Pickling (सीरियलाइज़ेशन) पायथन ऑब्जेक्ट को बाइटों की धारा में बदलना है। Unpickling बाइटों को वापस ऑब्जेक्ट बनाना।

import pickle
rec = {'roll': 1, 'name': 'Asha', 'marks': 92}
with open('stu.dat', 'wb') as f:
    pickle.dump(rec, f)

with open('stu.dat', 'rb') as f:
    r = pickle.load(f)
print(r['name'])   # Asha

हर dump एक ऑब्जेक्ट लिखता है। सब पढ़ने के लिए EOFError आने तक लूप में load:

with open('stu.dat', 'rb') as f:
    try:
        while True:
            print(pickle.load(f))
    except EOFError:
        pass

बाइनरी फ़ाइल में खोज, जोड़ना और बदलना

जोड़ना (append)

'ab' में खोलें और नया रिकॉर्ड pickle.dump करें। पुराने रिकॉर्ड बने रहते हैं।

खोज (search)

'rb' में खोलें, एक-एक रिकॉर्ड load करें और फ़ील्ड जाँचें: if r['roll'] == 5: print(r); found = True। लूप के बाद found अब भी False हो तो 'नहीं मिला' छापें।

बदलना (update)

तरीका 1 (आसान): सारे रिकॉर्ड लिस्ट में लोड करें, मेल खाता बदलें, फिर फ़ाइल 'wb' में खोलकर सब दोबारा dump करें।

recs = []
with open('stu.dat', 'rb') as f:
    try:
        while True:
            recs.append(pickle.load(f))
    except EOFError:
        pass
for r in recs:
    if r['roll'] == 2:
        r['marks'] = 80
with open('stu.dat', 'wb') as f:
    for r in recs:
        pickle.dump(r, f)

तरीका 2 (उसी जगह): 'rb+' में खोलें, हर load से पहले pos = f.tell() नोट करें, और मेल मिलने पर f.seek(pos) करके बदला रिकॉर्ड dump करें (जब नए रिकॉर्ड का बाइट आकार वही हो)।

CSV फ़ाइलें: csv.writer और csv.reader

import csv
with open('class.csv', 'w', newline='') as f:
    w = csv.writer(f)
    w.writerow(['Roll', 'Name', 'Marks'])
    w.writerows([[1, 'Asha', 92], [2, 'Ravi', 75]])

with open('class.csv', 'r') as f:
    for row in csv.reader(f):
        print(row)       # ['1', 'Asha', '92'] …

• csv.writer(f) writer ऑब्जेक्ट बनाता है। writerow(list) एक पंक्ति; writerows(list_of_lists) कई पंक्तियाँ।
• newline='' से Windows पर पंक्तियों के बीच ख़ाली लाइन नहीं आती।
• csv.reader(f) हर पंक्ति स्ट्रिंग की लिस्ट बनाकर देता है; संख्या के लिए int() करें।
• delimiter=';' से विभाजक बदल सकते हैं।

करके देखें: छोटी डायरी

ऐसा प्रोग्राम लिखिए जो एक पंक्ति पूछे और उसे 'a' मोड से diary.txt में जोड़े। तीन बार चलाइए। अब एक बार 'w' मोड में खोलकर एक पंक्ति लिखिए। हर बार के बाद diary.txt नोटपैड में खोलिए। आप ख़ुद देखेंगे कि 'w' ने सब मिटा दिया। फिर 3D के आख़िरी कदम में अनुमान लगाइए कि seek और read(n) क्या देंगे।

मुख्य सूत्र और परिभाषाएँ

• open(path, mode) · मोड: r, w, a, r+, w+, a+ (बाइनरी के लिए + b)
• with open(...) as f: → फ़ाइल अपने-आप बंद
• read(n), readline(), readlines() · write(s), writelines(list)
• tell() → जगह · seek(offset, whence) whence 0 शुरू, 1 अभी, 2 अंत
• pickle.dump(obj, f) / obj = pickle.load(f) · EOFError तक लूप
• csv.writer(f).writerow(row) / writerows(rows) · csv.reader(f) → स्ट्रिंग की लिस्टें

हल किए गए उदाहरण

आम गलतियाँ

• डेटा जोड़ने के लिए पुरानी फ़ाइल 'w' में खोलना; सब मिट जाता है। 'a' लें।
• भूल जाना कि write() और writelines() अपने-आप '\n' नहीं जोड़ते।
• pickle को टेक्स्ट मोड फ़ाइल के साथ चलाना; pickle को 'wb', 'rb' या 'ab' चाहिए।
• csv.reader से संख्याएँ मिलने की उम्मीद; वह स्ट्रिंग देता है, int() या float() से बदलें।