पाइथन में `io` मॉड्यूल

यह लेख पाइथन में io मॉड्यूल की व्याख्या करता है।

हम पाइथन में io मॉड्यूल को व्यावहारिक उदाहरणों के साथ समझाएंगे।

YouTube Video

पाइथन में io मॉड्यूल

इनपुट/आउटपुट प्रोसेसिंग फाइलें, नेटवर्क और मानक I/O जैसी सभी प्रकार की डेटा प्रक्रियाओं की नींव है। पाइथन का io मॉड्यूल अमूर्त क्लासों का एक सेट प्रदान करता है जो इन इनपुट/आउटपुट संचालन को एकीकृत करता है। इस मॉड्यूल को समझने की कुंजी 'स्ट्रीम' की अवधारणा है।

स्ट्रीम क्या है?

स्ट्रीम डेटा को क्रमबद्ध और सतत रूप से पढ़ने और लिखने के लिए एक अमूर्त प्रवाह है।

जब आप फ़ाइल की सामग्री को बाइट दर बाइट पढ़ते हैं या नेटवर्क पर डेटा भेजते या प्राप्त करते हैं, तो इन सबको डेटा स्ट्रीम के रूप में संभाला जा सकता है।

इस तंत्र को अमूर्त बनाकर, फाइलें, मेमोरी, और नेटवर्क—इनपुट/आउटपुट के विभिन्न स्रोत—सामान्य ऑपरेशनों जैसे पढ़ना और लिखना के साथ संभाले जा सकते हैं।

पाइथन का io मॉड्यूल स्ट्रीमों के लिए एकीकृत इंटरफेस प्रदान करता है, जिससे टेक्स्ट और बाइनरी डेटा दोनों का कुशल प्रबंधन किया जा सकता है।

io मॉड्यूल की मूल संरचना

io मॉड्यूल में स्ट्रीम की प्रकृति के अनुसार तीन-स्तरीय पदानुक्रम है।

1. रॉ लेयर (RawIOBase)

   RawIOBase सबसे निचले स्तर के बाइट I/O जैसे OS फ़ाइल डेस्क्रिप्टर और डिवाइसों को संभालता है।

2. बफर्ड लेयर (BufferedIOBase)

   BufferedIOBase I/O दक्षता बढ़ाने के लिए कैश (बफर) प्रदान करता है। BufferedReader और BufferedWriter इसके सामान्य उदाहरण हैं।

3. टेक्स्ट लेयर (TextIOBase)

   TextIOBase बाइट अनुक्रमों को स्ट्रिंग में परिवर्तित करता है और एनकोडिंग को संभालता है। आम तौर पर, जब open() फ़ंक्शन के साथ फ़ाइल खोली जाती है, तो इस लेयर का TextIOWrapper उपयोग किया जाता है।

इस संरचना के कारण, io मॉड्यूल टेक्स्ट और बाइनरी I/O को स्पष्ट रूप से अलग करता है और लचीला संयोजन भी संभव बनाता है।

io मॉड्यूल की मूल संरचना

RawIOBase सबसे निचले स्तर पर OS फ़ाइल डेस्क्रिप्टर को संभालता है, उस पर BufferedIOBase कैश जोड़ता है, और सबसे ऊपर TextIOBase स्ट्रिंग रूपांतरण को संभालता है।

1import io
2
3# Check the core base classes hierarchy
4print(io.IOBase.__subclasses__())

• यह कोड उन अमूर्त क्लासों के समूह की जांच के लिए है जो IOBase से विरासत में मिली हैं। आप TextIOBase, BufferedIOBase, और RawIOBase देख सकते हैं, जिससे पदानुक्रम की संरचना की पुष्टि होती है।

io.IOBase: सभी की मूल क्लास

IOBase सभी I/O ऑब्जेक्ट्स के लिए अमूर्त बेस क्लास है, जो close(), flush(), और seekable() जैसे सामान्य मेथड्स परिभाषित करती है। इसका सीधा उपयोग कम किया जाता है और प्रायः इसे डेरिव्ड क्लासों के माध्यम से एक्सेस किया जाता है।

1import io
2
3f = io.StringIO("data")
4print(f.seekable())   # True
5print(f.readable())   # True
6print(f.writable())   # True
7f.close()

• यह उदाहरण दिखाता है कि IOBase के सामान्य मेथड्स को ऊपरी क्लासों में भी उपयोग किया जा सकता है। seekable() और readable() स्ट्रीम की गुणधर्म जांचने के लिए उपयोगी हैं।

io.RawIOBase: सबसे निचला लेयर

RawIOBase OS फ़ाइल डेस्क्रिप्टर के सबसे करीब की लेयर है और यह बफरिंग नहीं करता। आम तौर पर इसका क्रियान्वयन FileIO के रूप में किया जाता है, जो बाइट दर बाइट पढ़ता और लिखता है।

1import io, os
2
3# Create a low-level FileIO object (no buffering)
4fd = os.open('raw_demo.bin', os.O_RDWR | os.O_CREAT)
5raw = io.FileIO(fd, mode='w+')
6raw.write(b'abc123')
7raw.seek(0)
8print(raw.read(6))  # b'abc123'
9raw.close()

• FileIO RawIOBase की एक ठोस क्रियान्वयन है; सभी रीड और राइट ऑपरेशन bytes के रूप में किए जाते हैं। इसे ऊपरी BufferedIOBase लेयर के साथ मिलाकर कार्यक्षमता में सुधार किया जा सकता है।

io.BufferedIOBase: मध्यस्थ लेयर (बफरिंग के साथ)

BufferedIOBase एक मध्यस्थ लेयर है जो बफरिंग करती है और डिस्क एक्सेस को अधिक कुशल बनाती है। मुख्य क्रियान्वयन हैं BufferedReader, BufferedWriter, BufferedRandom, और BufferedRWPair।

1import io
2
3# Create a buffered binary stream on top of a BytesIO (simulate file)
4base = io.BytesIO()
5buffered = io.BufferedWriter(base)
6buffered.write(b'Python IO buffering')
7buffered.flush()
8base.seek(0)
9print(base.read())  # b'Python IO buffering'

• इस उदाहरण में, BufferedWriter के माध्यम से लिखा गया डेटा अस्थायी रूप से मेमोरी बफर में संग्रहित होता है और flush() कॉल करने पर निचली लेयर में स्थानांतरित कर दिया जाता है।

BufferedReader का उदाहरण

BufferedReader एक केवल-पठन बफर स्ट्रीम है जो peek() और read() के साथ कुशल पठन का समर्थन करता है।

1import io
2
3stream = io.BytesIO(b"1234567890")
4reader = io.BufferedReader(stream)
5print(reader.peek(5))   # b'12345' (non-destructive)
6print(reader.read(4))   # b'1234'
7print(reader.read(3))   # b'567'

• peek() डेटा को केवल 'झांकता' है और पॉइंटर को नहीं बदलता। read() के साथ मिलाकर आप बफरिंग को लचीले ढंग से नियंत्रित कर सकते हैं।

io.TextIOBase: केवल टेक्स्ट लेयर

TextIOBase स्ट्रिंग्स को संभालने के लिए एक अमूर्त लेयर है, जो आंतरिक रूप से डिकोडिंग और एन्कोडिंग करती है। एक सामान्य क्रियान्वयन क्लास TextIOWrapper है।

 1import io
 2
 3# Wrap a binary stream to handle text encoding
 4binary = io.BytesIO()
 5text_stream = io.TextIOWrapper(binary, encoding='utf-8')
 6text_stream.write("\u3053\u3093\u306B\u3061\u306F")
 7text_stream.flush()
 8
 9# Reset stream position
10binary.seek(0)
11
12# Read bytes once
13data = binary.read()
14
15# Show both raw bytes and decoded text
16print("Raw bytes:", data)
17print("Decoded text:", data.decode('utf-8'))

• इस उदाहरण में, TextIOWrapper स्ट्रिंग को UTF-8 में एनकोड करता है और उसे अंडरलाइंग बाइनरी स्ट्रीम में लिख देता है।

TextIOWrapper के साथ पढ़ने का उदाहरण

पढ़ते समय डिकोडिंग स्वतः होती है।

1import io
2
3binary_data = io.BytesIO("Python I/O".encode('utf-8'))
4text_reader = io.TextIOWrapper(binary_data, encoding='utf-8')
5print(text_reader.read())  # 'Python I/O'

• TextIOWrapper टेक्स्ट I/O के लिए मौलिक क्लास है और लगभग सभी उच्चस्तरीय फ़ाइल संचालन का आधार बनाता है।

io.StringIO: इन-मेमोरी टेक्स्ट स्ट्रीम

StringIO एक क्लास है जो आपको मेमोरी में स्ट्रिंग्स को ऐसे संभालने देता है जैसे वे फाइलें हों। यह I/O परीक्षण और अस्थायी डेटा उत्पादन के लिए उपयोगी है।

1import io
2
3text_buf = io.StringIO()
4text_buf.write("In-memory text stream")
5text_buf.seek(0)
6print(text_buf.read())  # 'In-memory text stream'

• StringIO डिस्क का उपयोग किए बिना फाइल जैसे ऑपरेशनों की अनुमति देता है और यूनिट टेस्टिंग में व्यापक रूप से प्रयोग होता है।

io.BytesIO: इन-मेमोरी बाइनरी स्ट्रीम

BytesIO बाइट अनुक्रम (bytes) को संभालने के लिए इन-मेमोरी फाइल क्लास है। यह बाइनरी प्रोसेसिंग या डेटा कंप्रेशन जैसी परिस्थितियों में उपयोगी है जहां आप फाइलों का उपयोग नहीं करना चाहते।

1import io
2
3buf = io.BytesIO()
4buf.write(b'\x01\x02\x03')
5buf.seek(0)
6print(list(buf.read()))  # [1, 2, 3]

• BytesIO, BufferedIOBase जैसा ही इंटरफेस प्रदान करता है और कई फ़ाइल API के विकल्प के रूप में उपयोग किया जा सकता है।

कस्टम स्ट्रीम्स (मूल क्लास बनाना)

io की क्लासों का विस्तार किया जा सकता है, जिससे आप अपनी खुद की स्ट्रीम क्लास बना सकते हैं। नीचे एक TextIOBase सबक्लास का उदाहरण है जो लिखते समय सभी टेक्स्ट को कैपिटल में बदल देता है।

 1import io
 2
 3class UpperTextIO(io.TextIOBase):
 4    def __init__(self):
 5        self.buffer = ""
 6    def write(self, s):
 7        self.buffer += s.upper()
 8        return len(s)
 9
10u = UpperTextIO()
11u.write("hello io")
12print(u.buffer)  # "HELLO IO"

• जब तक आप TextIOBase के अनुबंध का पालन करते हैं, आप इस तरह का कोई भी कस्टम व्यवहार परिभाषित कर सकते हैं। फाइल और नेटवर्क जैसे विशिष्ट उपयोगों के लिए स्ट्रीम्स का विस्तार करना भी आसान है।

सारांश

io मॉड्यूल इनपुट/आउटपुट प्रोसेसिंग को अमूर्त और ठोस क्लासों के पदानुक्रम में संगठित करता है।

• RawIOBase OS स्तर के बाइट I/O के लिए एक क्लास है।
• BufferedIOBase एक क्लास है जो एक कुशल कैश लेयर प्रदान करती है।
• TextIOBase एक क्लास है जो स्ट्रिंग्स के पढ़ने और लिखने का प्रबंधन करती है।
• StringIO और BytesIO वे क्लास हैं जो इन-मेमोरी स्ट्रीम्स प्रदान करती हैं।

इन क्लासों को समझने से आप पाइथन के I/O सिस्टम की कार्यप्रणाली को सही ढंग से समझ सकते हैं और इनका उपयोग फ़ाइल संचालन, नेटवर्क संचार और टेस्ट स्ट्रीम की डिजाइन में कर सकते हैं।

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video