$\hspace{5.5cm}$ तालिका 2.1 फ़ाइल खोलने के मोड

निम्नलिखित उदाहरण पर विचार करें।

myObject=open(“myfi le.txt”, “a+”)

उपरोक्त कथन में, फ़ाइल myfile.txt को ऐपेंड और पढ़ने के मोड में खोला गया है। फ़ाइल ऑब्जेक्ट फ़ाइल के अंत में होगा। इसका अर्थ है कि हम फ़ाइल के अंत में डेटा लिख सकते हैं और साथ ही साथ फ़ाइल से डेटा पढ़ भी सकते हैं myObject नामक फ़ाइल ऑब्जेक्ट का उपयोग करके।

2.3.2 फ़ाइल बंद करना

एक बार जब हम किसी फ़ाइल पर पढ़ने/लिखने के संचालन समाप्त कर लेते हैं, तो फ़ाइल को बंद करना एक अच्छा अभ्यास है। Python ऐसा करने के लिए close() विधि प्रदान करता है। फ़ाइल बंद करते समय, सिस्टम उसे आवंटित मेमोरी को मुक्त कर देता है। close() का सिंटैक्स है:

file_object.close()

यहाँ, file_object वह वस्तु है जो फ़ाइल खोलते समय लौटाई गई थी।

Python यह सुनिश्चित करता है कि कोई भी अलिखित या असहेजा डेटा फ़ाइल बंद होने से पहले फ्लश (लिखित) हो जाता है। इसलिए, हमेशा सलाह दी जाती है कि काम समाप्त होने पर फ़ाइल को बंद कर दें। साथ ही, यदि फ़ाइल वस्तु को किसी अन्य फ़ाइल पर पुनः नियुक्त किया जाता है, तो पिछली फ़ाइल स्वचालित रूप से बंद हो जाती है।

2.3.3 with खंड का उपयोग कर फ़ाइल खोलना

Python में हम with खंड का उपयोग करके भी फ़ाइल खोल सकते हैं। with खंड का सिंटैक्स है:

with open(file_name, access_mode) as file_object:

with खंड का उपयोग करने का लाभ यह है कि इस खंड द्वारा खोली गई कोई भी फ़ाइल स्वचालित रूप से बंद हो जाती है, जैसे ही नियंत्रण with खंड से बाहर आता है। यदि उपयोगकर्ता स्पष्ट रूप से फ़ाइल बंद करना भूल जाता है या कोई अपवाद आता है, तो फ़ाइल स्वचालित रूप से बंद हो जाती है। साथ ही, यह एक सरल सिंटैक्स प्रदान करता है।

with open(“myfile.txt”,“r+”) as myObject:
$\quad$ content = myObject.read()

यहाँ हमें close() कथन का उपयोग करके फ़ाइल को स्पष्ट रूप से बंद करने की आवश्यकता नहीं है। Python फ़ाइल को स्वचालित रूप से बंद कर देगा।

2.4 टेक्स्ट फ़ाइल में लिखना

फ़ाइल में लिखने के लिए हमें पहले उसे write या append मोड में खोलना होता है। यदि हम किसी मौजूदा फ़ाइल को write मोड में खोलते हैं, तो पिछला डेटा मिट जाएगा और फ़ाइल ऑब्जेक्ट फ़ाइल की शुरुआत में पोजीशन हो जाएगा। दूसरी ओर, append मोड में नया डेटा पिछले डेटा के अंत में जुड़ जाएगा क्योंकि फ़ाइल ऑब्जेक्ट फ़ाइल के अंत में होता है। फ़ाइल खोलने के बाद, हम निम्नलिखित विधियों का उपयोग करके फ़ाइल में डेटा लिख सकते हैं।

• write() - एकल स्ट्रिंग लिखने के लिए
• writelines() - स्ट्रिंग्स की एक अनुक्रम लिखने के लिए

सोचिए और विचार कीजिए

क्या एक नई बनाई गई फ़ाइल के लिए write() और append() विधियों के बीच कोई अंतर है?

2.4.1 write() विधि

write() विधि एक स्ट्रिंग को तर्क के रूप में लेती है और उसे टेक्स्ट फ़ाइल में लिखती है। यह write() विधि के एकल निष्पादन पर लिखे गए वर्णों की संख्या लौटाती है। साथ ही, हर वाक्य के अंत में लाइन के अंत को दर्शाने के लिए न्यूलाइन कैरेक्टर $(\backslash n)$ जोड़ना आवश्यक है।

निम्नलिखित कोड को देखें:

>>> myobject=open(“myfi le.txt”,‘w’)
>>> myobject.write(“Hey I have started
#using fi les in Python\n”)
41
>>> myobject.close()

निष्पादन पर, write() फ़ाइल पर लिखे गए वर्णों की संख्या लौटाती है। इसलिए, 41, जो तर्क के रूप में पास की गई स्ट्रिंग की लंबाई है, प्रदर्शित होता है।

नोट: ’ \n ’ को एकल वर्ण माना जाता है

यदि टेक्स्ट फ़ाइल में संख्यात्मक डेटा लिखना है, तो फ़ाइल में लिखने से पहले डेटा को स्ट्रिंग में बदलना होगा। उदाहरण के लिए:

_»> myobject=open(“myfi le.txt”,‘w’) \

marks=58
#संख्या 58 को स्ट्रिंग में बदलने के लिए
#str() का उपयोग किया गया है
myobject.write(str(marks))
2
myobject.close()_

write() वास्तव में डेटा को एक बफ़र पर लिखता है। जब close() मेथड निष्पादित होता है, तो इस बफ़र की सामग्री को स्थायी भंडारण पर स्थित फ़ाइल में स्थानांतरित कर दिया जाता है।

हम बफ़र को साफ़ करने और बफ़र की सामग्री को फ़ाइल में लिखने के लिए flush() मेथड का भी उपयोग कर सकते हैं। इस तरह प्रोग्रामर आवश्यकतानुसार जब चाहें तब जबरदस्ती फ़ाइल में लिख सकते हैं।

2.4.2 writelines() मेथड

यह मेथड एक फ़ाइल में कई स्ट्रिंग लिखने के लिए उपयोग किया जाता है। हमें writelines() मेथड को स्ट्रिंग युक्त सूची, टपल आदि जैसे iterable ऑब्जेक्ट पास करने होते हैं। write() के विपरीत, writelines() मेथड फ़ाइल में लिखे गए वर्णों की संख्या नहीं लौटाता है। निम्नलिखित कोड writelines() के उपयोग को समझाता है।

गतिविधि 2.3

उपरोक्त कोड को writelines() को write() से बदलकर चलाएं और देखें कि क्या होता है।

_»> myobject=open(“myfi le.txt”,‘w’) \

lines = [“Hello everyone\n”, “Writing
$\quad$ #बहु-पंक्ति स्ट्रिंग्स\n”, “This is the
$\quad$ #तीसरी पंक्ति”]
myobject.writelines(lines)
myobject.close()_

myfile.txt को नोटपैड का उपयोग करके खोलने पर, इसकी सामग्री चित्र 2.1 के रूप में प्रदर्शित होगी।

चित्र 2.1: myfile.txt की सामग्री

सोचिए और विचार कीजिए

क्या हम संख्याओं का एक tuple writelines() के तर्क के रूप में पास कर सकते हैं? क्या यह फ़ाइल में लिखा जाएगा या कोई त्रुटि उत्पन्न होगी?

2.5 एक टेक्स्ट फ़ाइल से पढ़ना

हम एक प्रोग्राम लिख सकते हैं जो किसी फ़ाइल की सामग्री पढ़े। फ़ाइल पढ़ने से पहले, हमें यह सुनिश्चित करना होगा कि फ़ाइल “r”, “r+”, “w+” या “a+” मोड में खुली है। फ़ाइल की सामग्री पढ़ने के तीन तरीके हैं:

2.5.1 read() विधि

यह विधि किसी डेटा फ़ाइल से निर्दिष्ट संख्या में बाइट्स का डेटा पढ़ने के लिए प्रयोग की जाती है। read() विधि का सिंटैक्स है:

file_object.read(n)

read() विधि के उपयोग को समझने के लिए निम्नलिखित कथनों को देखें:

>>> myobject=open("myfile.txt",'r')
>>> myobject.read(10)
'Hello ever'
>>> myobject.close()

यदि कोई तर्क या ऋणात्मक संख्या read() में निर्दिष्ट नहीं की जाती है, तो संपूर्ण फ़ाइल सामग्री पढ़ी जाती है। उदाहरण के लिए,

>>> myobject=open("myfile.txt",'r')
>>> print(myobject.read())
Hello everyone
Writing multiline strings
This is the third line
>>> myobject.close()

2.5.2 readline([n]) विधि

यह विधि फ़ाइल से एक पूरी पंक्ति पढ़ती है जहाँ प्रत्येक पंक्ति न्यूलाइन $(\backslash n)$ वर्ण से समाप्त होती है। इसका उपयोग फ़ाइल से निर्दिष्ट संख्या (n) के बाइट्स डेटा को पढ़ने के लिए भी किया जा सकता है, लेकिन अधिकतम न्यूलाइन वर्ण $(\backslash n)$ तक। निम्न उदाहरण में, दूसरा कथन टेक्स्ट फ़ाइल की पहली पंक्ति के पहले दस वर्णों को पढ़ता है और उन्हें स्क्रीन पर प्रदर्शित करता है।

>>> myobject=open(“myfi le.txt”,‘r’)
>>> myobject.readline(10)
‘Hello ever’
>>> myobject.close

यदि कोई आर्गुमेंट या ऋणात्मक संख्या निर्दिष्ट नहीं की जाती है, तो यह एक पूरी पंक्ति पढ़ता है और स्ट्रिंग लौटाता है।

>>> myobject=open(“myfi le.txt”,‘r’)
>>> print (myobject.readline())
‘Hello everyone\n’

पूरी फ़ाइल को पंक्ति दर पंक्ति readline() का उपयोग करके पढ़ने के लिए, हम एक लूप का उपयोग कर सकते हैं। इस प्रक्रिया को लूपिंग/फ़ाइल ऑब्जेक्ट पर इटरेट करना कहा जाता है। यह EOF तक पहुँचने पर एक खाली स्ट्रिंग लौटाता है।

Activity 2.4

एक फ़ाइल बनाएँ जिसमें बहुपंक्ति डेटा हो और readline() का उपयोग एक इटरेटर के साथ करें फ़ाइल की सामग्री को पंक्ति दर पंक्ति पढ़ने के लिए

2.5.3 The readlines() method

यह विधि सभी पंक्तियों को पढ़ती है और न्यूलाइन के साथ पंक्तियों को स्ट्रिंग्स की सूची के रूप में लौटाती है। निम्न उदाहरण readlines() का उपयोग करता है टेक्स्ट फ़ाइल myfile.txt से डेटा पढ़ने के लिए।

>>> myobject=open(“myfi le.txt”, ‘r’)
>>> print(myobject.readlines())
[‘Hello everyone\n’, ‘Writing multiline
strings\n’, ‘This is the third line’]
>>> myobject.close()

जैसा कि ऊपर के आउटपुट में दिखाया गया है, जब हम readlines() फ़ंक्शन का उपयोग करके एक फ़ाइल को पढ़ते हैं, तो फ़ाइल में मौजूद पंक्तियाँ एक सूची के सदस्य बन जाती हैं, जहाँ प्रत्येक सूची तत्व एक न्यूलाइन वर्ण (’ $\backslash n$ ‘) के साथ समाप्त होता है।

यदि हम किसी पंक्ति के प्रत्येक शब्द को अलग-अलग रूप से सूची के एक तत्व के रूप में प्रदर्शित करना चाहते हैं, तो हम split() फ़ंक्शन का उपयोग कर सकते हैं। निम्नलिखित कोड split() फ़ंक्शन के उपयोग को प्रदर्शित करता है।

>>> myobject=open(“myfi le.txt”,‘r’)
>>> d=myobject.readlines()
>>> for line in d:
$\quad$ words=line.split()
$\quad$ print(words)

[‘Hello’, ’everyone’]
[‘Writing’, ‘multiline’, ‘strings’]
[‘This’, ‘is’, ’the’, ’third’, ’line’]

आउटपुट में, प्रत्येक स्ट्रिंग एक सूची के तत्वों के रूप में लौटाया जाता है। हालाँकि, यदि split() के स्थान पर splitlines() का उपयोग किया जाता है, तो प्रत्येक पंक्ति एक सूची के तत्व के रूप में लौटाई जाती है, जैसा कि नीचे दिए गए आउटपुट में दिखाया गया है:

>>> for line in d:
$\quad$ words=line.splitlines()
$\quad$ print(words)
[‘Hello everyone’]
[‘Writing multiline strings’]
[‘This is the third line’]

आइए अब एक ऐसा प्रोग्राम लिखें जो उपयोगकर्ता से एक स्ट्रिंग स्वीकार करता है और उसे एक टेक्स्ट फ़ाइल में लिखता है। तत्पश्चात, वही प्रोग्राम टेक्स्ट फ़ाइल को पढ़ता है और उसे स्क्रीन पर प्रदर्शित करता है।

प्रोग्राम 2-1 टेक्स्ट फ़ाइल में लिखना और पढ़ना

fobject=open(“testfi le.txt”,“w”) $\qquad$# एक डेटा फ़ाइल बनाना
sentence=input(“Enter the contents to be written in the file: “)
fobject.write(sentence) $\qquad$# फ़ाइल में डेटा लिखना
fobject.close() $\qquad$# फ़ाइल बंद करना

print(“Now reading the contents of the file: “)
fobject=open(“testfi le.txt”,“r”)
#looping over the fi le object to read the file
for str in fobject:
$\quad$ print(str) fobject.close

प्रोग्राम 2.1 में, testfile.txt नामक फ़ाइल को write मोड में खोला गया है और fobject नामक फ़ाइल हैंडल लौटाया गया है। उपयोगकर्ता से स्ट्रिंग स्वीकार की जाती है और write() का उपयोग कर फ़ाइल में लिखी जाती है। फिर फ़ाइल बंद की जाती है और पुनः read मोड में खोली जाती है। फ़ाइल से डेटा पढ़ा जाता है और EOF तक प्रदर्शित किया जाता है।

प्रोग्राम 2-1 का आउटपुट:

>>>
RESTART: Path_to_fi le\Program2-1.py
Enter the contents to be written in the fi le:
roll_numbers = [1, 2, 3, 4, 5, 6]
Now reading the contents of the fi le:
roll_numbers = [1, 2, 3, 4, 5, 6]
>>>

2.6 फ़ाइल में ऑफ़सेट सेट करना

जिन फंक्शन्स को हमने अब तक सीखा है, वे फ़ाइल से डेटा को क्रमिक रूप से एक्सेस करने के लिए उपयोग किए जाते हैं। लेकिन यदि हम डेटा को यादृच्छिक तरीके से एक्सेस करना चाहते हैं, तो Python हमें seek() और tell() फंक्शन प्रदान करता है।

2.6.1 tell() मेथड

यह फंक्शन एक पूर्णांक लौटाता है जो फ़ाइल ऑब्जेक्ट की फ़ाइल में वर्तमान स्थिति को निर्दिष्ट करता है। यह स्थिति फ़ाइल की शुरुआत से वर्तमान स्थिति तक का बाइट स्थान होता है। tell() का उपयोग करने का सिंटैक्स है:

file_object.tell ()

2.6.2 seek() मेथड

यह मेथड फ़ाइल ऑब्जेक्ट को फ़ाइल में किसी विशेष स्थिति पर रखने के लिए उपयोग किया जाता है। seek() का सिंटैक्स है:

फ़ाइल_ऑब्जेक्ट.seek(ऑफ़सेट [, संदर्भ_बिंदु])

सोचिए और विचार कीजिए

क्या seek() फ़ंक्शन टेक्स्ट और बाइनरी फ़ाइलों के लिए एक ही तरह से काम करता है?

उपरोक्त सिंटैक्स में, ऑफ़सेट वह बाइट्स की संख्या है जिससे फ़ाइल ऑब्जेक्ट को स्थानांतरित किया जाना है। संदर्भ_बिंदु फ़ाइल ऑब्जेक्ट की प्रारंभिक स्थिति को दर्शाता है। अर्थात्, किस स्थिति के सापेक्ष ऑफ़सेट गिना जाना है। इसमें निम्नलिखित मानों में से कोई भी हो सकता है:

0 - फ़ाइल की शुरुआत
1 - फ़ाइल की वर्तमान स्थिति
2 - फ़ाइल के अंत

डिफ़ॉल्ट रूप से, संदर्भ_बिंदु का मान 0 होता है, अर्थात् ऑफ़सेट फ़ाइल की शुरुआत से गिना जाता है। उदाहरण के लिए, कथन fileObject.seek $(5,0)$ फ़ाइल ऑब्जेक्ट को फ़ाइल की शुरुआत से $5^{\text {वें}}$ बाइट स्थिति पर रखेगा। नीचे प्रोग्राम 2-2 में दिया गया कोड seek() और tell() के उपयोग को प्रदर्शित करता है।

प्रोग्राम 2-2 seek() और tell() का अनुप्रयोग

print(“फ़ाइल ऑब्जेक्ट को स्थानांतरित करना सीखना”)
फ़ाइलऑब्जेक्ट=open(“testfile.txt”,“r+”)
str=फ़ाइलऑब्जेक्ट.read()
print(str)
print(“प्रारंभ में, फ़ाइल ऑब्जेक्ट की स्थिति है: “,fileobject.
tell())
फ़ाइलऑब्जेक्ट.seek(0)
print(“अब फ़ाइल ऑब्जेक्ट फ़ाइल की शुरुआत पर है: “,fileobject.tell())
fileobject.seek(10)
print(“हम फ़ाइल की शुरुआत से 10वें बाइट स्थिति पर जा रहे हैं”)
print(“फ़ाइल ऑब्जेक्ट की स्थिति है”, fileobject.tell()) str=फ़ाइलऑब्जेक्ट.read()
print(str)

प्रोग्राम 2-2 का आउटपुट:

>>> RESTART: Path_to_fi le\Program2-2.py
फ़ाइल ऑब्जेक्ट को हिलाना सीखना
roll_numbers = [1, 2, 3, 4, 5, 6]
प्रारंभ में, फ़ाइल ऑब्जेक्ट की स्थिति है: 33
अब फ़ाइल ऑब्जेक्ट फ़ाइल की शुरुआत पर है: 0

हम फ़ाइल की शुरुआत से 10वें बाइट स्थान पर जा रहे हैं
फ़ाइल ऑब्जेक्ट की स्थिति 10 पर है
rs = [1, 2, 3, 4, 5, 6]
>>>

2.7 एक टेक्स्ट फ़ाइल बनाना और उसका अन्वेषण करना

विभिन्न विधियाँ सीखने के बाद जो हमें फ़ाइल खोलने और बंद करने, टेक्स्ट फ़ाइल में डेटा पढ़ने और लिखने, फ़ाइल ऑब्जेक्ट की स्थिति ज्ञात करने और फ़ाइल ऑब्जेक्ट को इच्छित स्थान पर ले जाने में मदद करती हैं, आइए अब टेक्स्ट फ़ाइल पर कुछ बुनियादी संचालन करें। इन संचालनों को करने के लिए, आइए मान लें कि हम practice.txt के साथ काम कर रहे हैं।

2.7.1 फ़ाइल बनाना और डेटा लिखना

एक टेक्स्ट फ़ाइल बनाने के लिए, हम open() मेथड का उपयोग करते हैं और फ़ाइल का नाम तथा मोड प्रदान करते हैं। यदि पहले से ही उसी नाम की फ़ाइल मौजूद है, तो open() फ़ंक्शन का व्यवहार इस्तेमाल किए गए मोड (write या append) के अनुसार अलग होगा। यदि यह write मोड (w) में है, तो फ़ाइल के सभी मौजूदा कंटेंट खो जाएँगे और उसी नाम से एक खाली फ़ाइल बन जाएगी। लेकिन, यदि फ़ाइल append मोड (a) में बनाई जाती है, तो नया डेटा मौजूदा डेटा के बाद लिखा जाएगा। दोनों ही स्थितियों में, यदि फ़ाइल मौजूद नहीं है, तो एक नई खाली फ़ाइल बना दी जाएगी। प्रोग्राम 2-3 में, एक फ़ाइल practice.txt को write (w) मोड में खोला गया है और उसमें तीन वाक्य संग्रहीत किए गए हैं, जैसा कि आउटपुट स्क्रीन में दिखाया गया है।

प्रोग्राम 2-3 एक टेक्स्ट फ़ाइल बनाना और उसमें डेटा लिखना

fileobject=open(“practice.txt”,“w+”)
while True:
$\quad$ data= input(“Enter data to save in the text file: “)
$\quad$ fileobject.write(data)
$\quad$ ans=input(“Do you wish to enter more data?(y/n): “)
$\quad$ if ans==‘n’: break
fileobject.close()

प्रोग्राम 2-3 का आउटपुट:

>>>
RESTART: Path_to_fi le\Program2-3.py
Enter data to save in the text fi le: I am interested to learn about Computer Science
Do you wish to enter more data?(y/n): y
Enter data to save in the text fi le: Python is easy to learn
Do you wish to enter more data?(y/n): n
>>>

2.7.2 फ़ाइल को ट्रैवर्स करना और डेटा प्रदर्शित करना

टेक्स्ट फ़ाइल में संग्रहीत डेटा को पढ़ने और प्रदर्शित करने के लिए, हम पिछले उदाहरण का उल्लेख करेंगे जहाँ हमने practice.txt फ़ाइल बनाई थी। फ़ाइल को रीड मोड में खोला जाएगा और पढ़ना फ़ाइल की शुरुआत से शुरू होगा।

प्रोग्राम 2-4 टेक्स्ट फ़ाइल से डेटा प्रदर्शित करने के लिए

fileobject=open(“practice.txt”,“r”)
str = fileobject.readline()
while str:
$\quad$ print(str)
$\quad$ str=fileobject.readline()
fileobject.close()

प्रोग्राम 2-4 में, while लूप में readline() का उपयोग टेक्स्ट फ़ाइल से डेटा को लाइन दर लाइन पढ़ने के लिए किया गया है। लाइनों को print() का उपयोग करके प्रदर्शित किया गया है। जैसे ही फ़ाइल का अंत आता है, readline() एक खाली स्ट्रिंग लौटाएगा। अंत में, close() का उपयोग करके फ़ाइल बंद की जाती है।

प्रोग्राम 2-4 का आउटपुट:

>>>
I am interested to learn about Computer SciencePython is easy to learn

अब तक, हम फ़ाइल में डेटा लिखने और फ़ाइल को पढ़ने के लिए अलग-अलग प्रोग्राम बना रहे हैं। अब आइए एक ही प्रोग्राम बनाएँ जो एक ही फ़ाइल ऑब्जेक्ट का उपयोग करके डेटा को पढ़ने और लिखने दोनों कार्य करे। चूँकि दोनों कार्यों को एक ही फ़ाइल ऑब्जेक्ट का उपयोग करके करना है, फ़ाइल को $\mathrm{w}^{+}$ मोड में खोला जाएगा।

प्रोग्राम 2-5 टेक्स्ट फ़ाइल में रीडिंग और राइटिंग ऑपरेशन करने के लिए

fileobject=open(“report.txt”, “w+”)
print (“फ़ाइल में डेटा लिखा जा रहा है”)
print() $\quad$ # एक खाली पंक्ति दिखाने के लिए
while True:
$\quad$ line= input(“एक वाक्य दर्ज करें “)
$\quad$ fileobject.write(line)
$\quad$ fileobject.write(’\n’)
$\quad$ choice=input(“क्या आप और डेटा दर्ज करना चाहते हैं? (y/n): “)
$\quad$ if choice in (’n’,‘N’): break
print(“फ़ाइल ऑब्जेक्ट का बाइट स्थान है “,fileobject.tell())
fileobject.seek(0) #फ़ाइल ऑब्जेक्ट को फ़ाइल की शुरुआत पर रखता है
print()
print(“फ़ाइल से डेटा पढ़ा जा रहा है”)
str=fileobject.read()
print(str)
fileobject.close

प्रोग्राम $2-5$ में, फ़ाइल तब तक पढ़ी जाएगी जब तक फ़ाइल का अंत नहीं आ जाता और नीचे दिखाए गए अनुसार आउटपुट प्रदर्शित होता है।

प्रोग्राम 2-5 का आउटपुट:

>>>
RESTART: Path_to_file\Program2-5.py
फ़ाइल में डेटा लिखा जा रहा है

एक वाक्य दर्ज करें I am a student of class XII
क्या आप और डेटा दर्ज करना चाहते हैं? (y/n): y
एक वाक्य दर्ज करें my school contact number is 4390xxx8
क्या आप और डेटा दर्ज करना चाहते हैं? (y/n): n
फ़ाइल ऑब्जेक्ट का बाइट स्थान है 67

फ़ाइल से डेटा पढ़ा जा रहा है
I am a student of class XII
my school contact number is 4390xxx8
>>>

2.8 पिकल मॉड्यूल

हम जानते हैं कि Python सब कुछ एक object मानता है। इसलिए, सभी data types जैसे list, tuple, dictionary आदि को भी objects माना जाता है।
किसी program के execution के दौरान हमें variables की current state को store करने की आवश्यकता हो सकती है ताकि हम बाद में उन्हें उसी present state में retrieve कर सकें।
मान लीजिए आप कोई video game खेल रहे हैं और कुछ समय बाद आप उसे बंद करना चाहते हैं। तो program को game की current state—जैसे current level/stage, आपका score आदि—को एक Python object के रूप में store करने में सक्षम होना चाहिए।
इसी तरह, आप एक Python dictionary को object के रूप में store करना चाहेंगे ताकि बाद में retrieve किया जा सके।
किसी भी object structure को data सहित save करने के लिए Python एक module देता है जिसे Pickle कहा जाता है।
Pickle module किसी भी Python object structure को serialize और de-serialize करने के लिए उपयोग किया जाता है।
Pickling खाद्य वस्तुओं को किसी solution में रखकर उन्हें preserve करने की एक विधि है, जिससे उनकी shelf life बढ़ जाती है; दूसरे शब्दों में, यह भोजन को बाद में उपभोग के लिए store करने की विधि है।

Serialization वह process है जिसमें memory (RAM) में मौजूद data या object को byte streams नामक bytes के stream में transform किया जाता है।
इन byte streams को binary file में disk या database में store किया जा सकता है या network के माध्यम से भेजा जा सकता है।
Serialization process को pickling भी कहा जाता है।

De-serialization या unpickling pickling process का inverse है जिसमें byte stream को वापस Python object में convert किया जाता है।

पिकल मॉड्यूल बाइनरी फ़ाइलों से संबंधित है। यहाँ डेटा लिखा नहीं जाता बल्कि डंप किया जाता है और इसी प्रकार, डेटा पढ़ा नहीं जाता बल्कि लोड किया जाता है। डेटा को लोड और डंप करने के लिए पिकल मॉड्यूल को आयात करना आवश्यक है। पिकल मॉड्यूल दो विधियाँ प्रदान करता है - dump() और load() - जो क्रमशः पिकलिंग और अनपिकलिंग के लिए बाइनरी फ़ाइलों के साथ काम करती हैं।

2.8.1 dump() विधि

यह विधि पायथन ऑब्जेक्ट्स को बाइनरी फ़ाइल में डेटा लिखने के लिए परिवर्तित (पिकलिंग) करने के लिए प्रयोग की जाती है। फ़ाइल जिसमें डेटा डंप किया जाना है, उसे बाइनरी राइट मोड (wb) में खोला जाना चाहिए।

dump() का सिंटैक्स इस प्रकार है:

dump (data_object, file_object)

जहाँ data_object वह ऑब्जेक्ट है जिसे file_object नामक फ़ाइल हैंडल वाली फ़ाइल में डंप किया जाना है। उदाहरण के लिए, प्रोग्राम 2-6 एक छात्र का रिकॉर्ड (roll_no, name, gender और marks) को mybinary.dat नामक बाइनरी फ़ाइल में dump() का उपयोग करके लिखता है। पिकलिंग के बाद फ़ाइल को बंद करना आवश्यक है।

प्रोग्राम 2-6 पायथन में डेटा को पिकल करना

import pickle
listvalues=[1,“Geetika”,‘F’, 26]
fileobject=open(“mybinary.dat”, “wb”)
pickle.dump(listvalues,fileobject)
fileobject.close()

2.8.2 load() विधि

यह विधि बाइनरी फ़ाइल से डेटा को लोड (अनपिकलिंग) करने के लिए प्रयोग की जाती है। लोड की जाने वाली फ़ाइल को बाइनरी रीड (rb) मोड में खोला जाता है। load() का सिंटैक्स इस प्रकार है:

Store_object $=$ load(file_object)

यहाँ, पिकल किया गया Python ऑब्जेक्ट file_object नामक फ़ाइल हैंडल वाली फ़ाइल से लोड किया जाता है और store object नामक नए फ़ाइल हैंडल में संग्रहित किया जाता है। प्रोग्राम 2-7 load() का उपयोग करके mybinary.dat फ़ाइल से डेटा पढ़ने का प्रदर्शन करता है।

प्रोग्राम 2-7 Python में अनपिकलिंग डेटा

import pickle
print(“The data that were stored in file are: “)
fileobject=open(“mybinary.dat”,“rb”)
objectvar=pickle.load(fileobject)
fileobject.close()
print(objectvar)

प्रोग्राम 2-7 का आउटपुट:

>>>
RESTART: Path_to_file\Program2-7.py
The data that were stored in file are:
[1, ‘Geetika’, ‘F’, 26]
>>>

2.8.3 पिकल मॉड्यूल का उपयोग करके फ़ाइल हैंडलिंग

जैसे हम टेक्स्ट फ़ाइल में डेटा पढ़ते और लिखते हैं, वैसे ही हम बाइनरी फ़ाइल के लिए डेटा जोड़ेंगे और प्रदर्शित करेंगे। प्रोग्राम 2-8 उपयोगकर्ता से एक कर्मचारी का रिकॉर्ड स्वीकार करता है और उसे बाइनरी फ़ाइल $t v$ में जोड़ता है। तत्पश्चात, रिकॉर्ड्स को बाइनरी फ़ाइल से पढ़ा जाता है और उसी ऑब्जेक्ट का उपयोग करके स्क्रीन पर प्रदर्शित किया जाता है। उपयोगकर्ता चाहें तो जितने चाहें उतने रिकॉर्ड दर्ज कर सकते हैं। प्रोग्राम रीडिंग प्रक्रिया प्रारंभ करने से पहले बाइनरी फ़ाइलों का आकार भी प्रदर्शित करता है।

प्रोग्राम 2-8 पिकल मॉड्यूल का उपयोग करके बाइनरी फ़ाइल पर मूलभूत संचालन करना

#बाइनरी फ़ाइल में कर्मचारी रिकॉर्ड लिखने और पढ़ने के लिए प्रोग्राम
import pickle
print(“बाइनरी फ़ाइलों के साथ कार्य”)
bfile=open(“empfile.dat”,“ab”)
recno=1
print (“कर्मचारियों के रिकॉर्ड दर्ज करें”)
print()
#उपयोगकर्ता से डेटा लेना और उसे सूची ऑब्जेक्ट के रूपमें फ़ाइल में डालना
while True:
$\quad$ print(“रिकॉर्ड सं.”, recno)
$\quad$ eno=int(input("\tकर्मचारी संख्या : “))
$\quad$ ename=input("\tकर्मचारी नाम : “)
$\quad$ ebasic=int(input("\tमूल वेतन : “))
$\quad$ allow=int(input("\tभत्ते : “))
$\quad$ totsal=ebasic+allow
$\quad$ print("\tकुल वेतन : “, totsal)
$\quad$ edata=[eno,ename,ebasic,allow,totsal]
$\quad$ pickle.dump(edata,bfile)
$\quad$ ans=input(“क्या आप और रिकॉर्ड दर्ज करना चाहते हैं (y/n)? “)
$\quad$ recno=recno+1
$\quad$ if ans.lower()==‘n’:
$\qquad$ print(“रिकॉर्ड प्रवेश समाप्त “)
$\qquad$ print()
$\qquad$ break
#फ़ाइल का आकार प्राप्त करना
print(“बाइनरी फ़ाइल का आकार (बाइट्स में):",bfile.tell())
bfile.close()
#load() मॉड्यूल का उपयोग कर फ़ाइल से कर्मचारी रिकॉर्ड पढ़ना
print(“अब फ़ाइल से कर्मचारी रिकॉर्ड पढ़े जा रहे हैं”)
print()
readrec=1
try:
$\quad$ with open(“empfile.dat”,“rb”) as bfile:
$\quad$ while True:
$\qquad$ edata=pickle.load(bfile)
$\qquad$ print(“रिकॉर्ड संख्या : “,readrec)
$\qquad$ print(edata)
$\qquad$ readrec=readrec+1
except EOFError:
$\quad$ pass
bfile.close

प्रोग्राम 2-8 का आउटपुट:

_»> RESTART: Path_to_file\Program2-8.py बाइनरी फ़ाइलों के साथ कार्य कर्मचारियों के रिकॉर्ड दर्ज करें

रिकॉर्ड संख्या 1   कर्मचारी संख्या : 11   कर्मचारी का नाम : D N Ravi   मूल वेतन : 32600   भत्ते : 4400   कुल वेतन : 37000 क्या आप और रिकॉर्ड दर्ज करना चाहते हैं (y/n)? y रिकॉर्ड संख्या 2   कर्मचारी संख्या : 12   कर्मचारी का नाम : Farida Ahmed   मूल वेतन : 38250   भत्ते : 5300   कुल वेतन : 43550 क्या आप और रिकॉर्ड दर्ज करना चाहते हैं (y/n)? n रिकॉर्ड प्रवेश समाप्त

बाइनरी फ़ाइल का आकार (बाइट्स में): 216 अब फ़ाइल से कर्मचारी रिकॉर्ड पढ़े जा रहे हैं

रिकॉर्ड संख्या : 1 [11, ‘D N Ravi’, 32600, 4400, 37000] रिकॉर्ड संख्या : 2 [12, ‘Farida Ahmed’, 38250, 5300, 43550]

_

चूँकि प्रत्येक कर्मचारी रिकॉर्ड empfile.dat फ़ाइल में एक सूची के रूप में संग्रहीत है, इसलिए फ़ाइल को पढ़ते समय प्रत्येक कर्मचारी का रिकॉर्ड दिखाने वाली एक सूची प्रदर्शित होती है। ध्यान दें कि प्रोग्राम 2-8 में हमने end-of-file अपवाद को संभालने के लिए try.. except ब्लॉक का भी प्रयोग किया है।

सारांश

• एक फ़ाइल एक नामित स्थान होता है द्वितीयक भंडारण माध्यम पर जहाँ डेटा स्थायी रूप से संग्रहीत किया जाता है बाद में पहुँच के लिए।
• एक पाठ फ़ाइल में केवल पाठ्य जानकारी होती है जिसमें वर्णमाला, संख्याएँ और अन्य विशेष प्रतीक शामिल होते हैं। ऐसी फ़ाइलें .txt, .py, .c, .csv, .html आदि एक्सटेंशन के साथ संग्रहीत की जाती हैं। पाठ फ़ाइल के प्रत्येक बाइट का प्रतिनिधित्व एक वर्ण करता है।
• पाठ फ़ाइल की प्रत्येक पंक्ति को वर्णों के ASCII समतुल्य के अनुक्रम के रूप में संग्रहीत किया जाता है और एक विशेष वर्ण द्वारा समाप्त किया जाता है, जिसे End of Line (EOL) कहा जाता है।
• बाइनरी फ़ाइल में डेटा को बाइट्स की स्ट्रीम के रूप में संग्रहीत किया जाता है।
• open() विधि का उपयोग Python में एक फ़ाइल खोलने के लिए किया जाता है और यह एक फ़ाइल ऑब्जेक्ट को वापस करता है जिसे फ़ाइल हैंडल कहा जाता है। फ़ाइल हैंडल का उपयोग फ़ाइल से और फ़ाइल में डेटा स्थानांतरित करने के लिए किया जाता है Python के io मॉड्यूल में परिभाषित फंक्शनों को कॉल करके।
• close() विधि का उपयोग फ़ाइल बंद करने के लिए किया जाता है। फ़ाइल बंद करते समय, सिस्टम सभी संसाधनों जैसे प्रोसेसर और मेमोरी को मुक्त कर देता है जो इसे आवंटित किए गए थे।
• write() विधि एक स्ट्रिंग को तर्क के रूप में लेती है और इसे पाठ फ़ाइल में लिखती है।
• writelines() विधि का उपयोग कई स्ट्रिंग्स को एक फ़ाइल में लिखने के लिए किया जाता है। हमें writelines() विधि को स्ट्रिंग्स युक्त एक पुनरावृत्त योग्य ऑब्जेक्ट जैसे सूची, टपल आदि पास करना होता है।
• $\operatorname{read}([n])$ विधि का उपयोग डेटा फ़ाइल से निर्दिष्ट संख्या (n) के बाइट्स डेटा को पढ़ने के लिए किया जाता है।
• readline([n]) विधि फ़ाइल से एक पूरी पंक्ति पढ़ती है जहाँ पंक्तियाँ न्यूलाइन $(\backslash n)$ से समाप्त होती हैं। इसका उपयोग फ़ाइल से निर्दिष्ट संख्या (n) के बाइट्स डेटा को पढ़ने के लिए भी किया जा सकता है लेकिन अधिकतम न्यूलाइन वर्ण $(\backslash n)$ तक।
• readlines() विधि सभी पंक्तियों को पढ़ती है और पंक्तियों को न्यूलाइन वर्ण के साथ, स्ट्रिंग्स की सूची के रूप में वापस करती है।
• tell() विधि एक पूर्णांक वापस करती है जो फ़ाइल ऑब्जेक्ट की वर्तमान स्थिति को निर्दिष्ट करता है। निर्दिष्ट की गई स्थिति फ़ाइल की शुरुआत से फ़ाइल ऑब्जेक्ट की वर्तमान स्थिति तक की बाइट स्थिति होती है।
• seek() विधि का उपयोग फ़ाइल ऑब्जेक्ट को फ़ाइल में किसी विशेष स्थिति पर स्थित करने के लिए किया जाता है।
• Pickling वह प्रक्रिया है जिसके द्वारा एक Python ऑब्जेक्ट

अभ्यास

1. अंतर बताइए:

a) टेक्स्ट फ़ाइल और बाइनरी फ़ाइल
b) readline() और readlines()
c) write() और writelines()

2. निम्नलिखित विधियों के उपयोग और सिंटैक्स लिखिए:

a) open()
b) read()
c) seek()
d) dump()

3. निम्नलिखित फ़ाइलों को खोलने के लिए प्रयोग होने वाले फ़ाइल मोड लिखिए। साथ ही इन फ़ाइलों को खोलने के लिए Python कथन भी लिखिए:

a) एक टेक्स्ट फ़ाइल “example.txt” को पढ़ने और लिखने दोनों मोड में
b) एक बाइनरी फ़ाइल “bfile.dat” को लिखने मोड में
c) एक टेक्स्ट फ़ाइल “try.txt” को जोड़ने और पढ़ने मोड में
d) एक बाइनरी फ़ाइल “btry.dat” को केवल पढ़ने मोड में।

4. फ़ाइल को पढ़ने-लिखने के कार्य समाप्त होने के बाद उसे बंद करने की सलाह क्यों दी जाती है? यदि हम उसे बंद न करें तो क्या होगा? क्या कोई त्रुटि संदेश दिखाई देगा?

5. निम्नलिखित कथन समूहों (a) और (b) में क्या अंतर है:

a) P = open(“practice.txt”,”r”)
$\quad$ P.read(10)
b) with open(“practice.txt”, “r”) as P:
$\quad$ x = P.read()

6. निम्नलिखित पंक्तियों को hello.txt नामक टेक्स्ट फ़ाइल में लिखने के लिए कमांड(कमांडों) लिखिए। मान लीजिए कि फ़ाइल को append मोड में खोला गया है।

“Welcome my class”
“It is a fun place”
“You will learn and play”

7. एक Python प्रोग्राम लिखिए जो प्रश्न संख्या 6 में प्रयुक्त फ़ाइल hello.txt को read मोड में खोलकर उसकी सामग्री प्रदर्शित करे। यदि फ़ाइल को append मोड के बजाय write मोड में खोला जाता तो क्या अंतर होता?

8. एक ऐसा प्रोग्राम लिखिए जो उपयोगकर्ता से तब तक स्ट्रिंग/वाक्य स्वीकार करता रहे जब तक कि उपयोगकर्ता “END” न दर्ज कर दे। डेटा को एक टेक्स्ट फ़ाइल में सहेजें और फिर केवल उन वाक्यों को प्रदर्शित करें जो किसी बड़े अक्षर से शुरू होते हैं।

9. Python में pickling को परिभाषित कीजिए। Python ऑब्जेक्ट के serialization और deserialization की व्याख्या कीजिए।

10. निम्नलिखित रिकॉर्ड्स को एक बाइनरी फ़ाइल में दर्ज करने के लिए एक प्रोग्राम लिखिए:

Item No $\hspace{3cm}$ integer
Item_Name $\hspace{2.5cm}$ string
Qty $\hspace{3.6cm}$ integer
Price $\hspace{3.4cm}$ float

दर्ज किए जाने वाले रिकॉर्�्ड्स की संख्या उपयोगकर्ता से स्वीकार की जानी चाहिए। फ़ाइल को पढ़कर निम्नलिखित प्रारूप में रिकॉर्ड्स प्रदर्शित करें:

Item No:
Item Name :
Quantity:
Price per item:
Amount: $\hspace{2cm}$ (Price * Qty के रूप में गणना की जानी है)