Articles
Panimula sa Python
Ang `io` Module sa Python

Ang `io` Module sa Python

Ipinapaliwanag ng artikulong ito ang io module sa Python.

Ipapaliwanag namin ang io module sa Python gamit ang mga praktikal na halimbawa.

YouTube Video

Ang io Module sa Python

Ang pagpoproseso ng input/output ang pundasyon ng iba’t ibang uri ng operasyon sa datos, gaya ng mga file, network, at standard I/O. Ang io module ng Python ay nagbibigay ng hanay ng mga abstract class na nag-iisa ng mga input/output na operasyong ito. Ang susi upang maunawaan ang module na ito ay ang konsepto ng "stream".

Ano ang isang stream?

Ang stream ay isang abstract na daloy para sa sunod-sunod at tuloy-tuloy na pagbabasa at pagsulat ng datos.

Kapag nagbabasa ng laman ng file kada byte o nagpapadala at tumatanggap ng datos sa network, ang lahat ng ito ay maaaring hawakan bilang mga data stream.

Sa pamamagitan ng pag-aabstract ng mekanismong ito, ang mga file, memory, at network—iba’t ibang pinagkukunan ng I/O—ay maaaring i-handle gamit ang iisang operasyon gaya ng pagbabasa at pagsulat.

Ang io module ng Python ay nagbibigay ng unified interface para sa streams, kaya’t nagiging mas episyente ang paghawak ng parehong text at binary data.

Pangunahing Estruktura ng io Module

Ang io module ay may tatlong-layer na hierarchy ayon sa uri ng streams.

  1. Raw Layer (RawIOBase)

    Ang RawIOBase ay humahawak ng pinakamababang antas ng byte I/O, gaya ng OS file descriptors at mga device.

  2. Buffered Layer (BufferedIOBase)

    Ang BufferedIOBase ay nagbibigay ng cache (buffer) upang mapabuti ang I/O efficiency. Ang BufferedReader at BufferedWriter ay pangkaraniwang halimbawa.

  3. Text Layer (TextIOBase)

    Ang TextIOBase ay nagko-convert ng byte sequence sa mga string at humahawak ng encoding. Kadalasan, kapag nagbubukas ng file gamit ang open() function, ang TextIOWrapper mula sa layer na ito ang ginagamit.

Dahil sa estrukturang ito, malinaw na pinaghiwalay ng io module ang text at binary I/O habang pinapayagan ang flexible na kombinasyon.

Pangunahing Estruktura ng io Module

Ang RawIOBase ay humahawak ng OS file descriptors sa pinakaibabang layer, tapos may cache mula sa BufferedIOBase sa itaas nito, at ang TextIOBase sa pinakataas ay humahawak ng string conversion.

1import io
2
3# Check the core base classes hierarchy
4print(io.IOBase.__subclasses__())
  • Ang code na ito ay para sa pagsuri ng pangkat ng abstract classes na namamana mula sa IOBase. Makikita mo dito ang TextIOBase, BufferedIOBase, at RawIOBase, na nagpapatunay sa hierarchical na estraktura.

io.IOBase: Ang Pinakapayak na Class ng Lahat

Ang IOBase ang abstract base class para sa lahat ng I/O object at nagdedepina ng mga karaniwang method gaya ng close(), flush(), at seekable(). Bihira itong ginagamit direkta at kadalasan ay nilalapitan sa pamamagitan ng mga derived class.

1import io
2
3f = io.StringIO("data")
4print(f.seekable())   # True
5print(f.readable())   # True
6print(f.writable())   # True
7f.close()
  • Ipinapakita ng halimbawang ito na ang mga karaniwang method ng IOBase ay puwede ring magamit sa mga upper class. Ang seekable() at readable() ay kapaki-pakinabang para suriin ang mga katangian ng isang stream.

io.RawIOBase: Ang Pinakamababang Layer

Ang RawIOBase ang pinaka-malapit na layer sa OS file descriptor at hindi nagbabuffer. Ang pangkaraniwang implementasyon ay ang FileIO, na nagbabasa at nagsusulat kada byte.

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()
  • Ang FileIO ay konkreto na implementasyon ng RawIOBase; lahat ng pagbabasa at pagsulat ay ginaganap bilang bytes. Mas mapapabuti ang efficiency kung pagsasamahin ito sa upper layer na BufferedIOBase.

io.BufferedIOBase: Gitnang Layer (May Buffering)

Ang BufferedIOBase ay intermediate layer na gumagamit ng buffering para gawing mas episyente ang pag-access ng disk. Ang mga pangunahing implementasyon ay ang BufferedReader, BufferedWriter, BufferedRandom, at 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'
  • Sa halimbawang ito, ang data na naisulat gamit ang BufferedWriter ay pansamantalang iniimbak sa memory buffer at naipapasa lamang sa lower layer kapag tinawag ang flush().

Halimbawa ng BufferedReader

BufferedReader ay isang read-only na buffered stream na sumusuporta sa mahusay na pagbabasa gamit ang peek() at 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'
  • Ang peek() ay tumitingin lamang sa data at hindi inaabante ang pointer. Sa pamamagitan ng pagsasama nito sa read(), maaari mong kontrolin ng flexible ang buffering.

io.TextIOBase: Pang-text Lamang na Layer

TextIOBase ay isang abstraction layer para sa paghawak ng mga string, na internally gumagawa ng decoding at encoding. Isang tipikal na implementation class ay ang 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'))
  • Sa halimbawa, ang TextIOWrapper ay nag-e-encode ng string sa UTF-8 at sinusulat ito sa underlying binary stream.

Halimbawa ng Pagbabasa gamit ang TextIOWrapper

Awtomatikong nagkakaroon ng decoding kapag nagbabasa.

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'
  • Ang TextIOWrapper ang pangunahing class para sa text I/O at nagiging basehan ng halos lahat ng high-level na file operation.

io.StringIO: In-Memory na Text Stream

Ang StringIO ay isang class na pumapayag sa iyo na mag-manage ng string sa memory na parang mga file sila. Ito ay kapaki-pakinabang para sa I/O testing at pansamantalang paggawa ng data.

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'
  • Ang StringIO ay nagbibigay-daan sa operations na parang file kahit hindi gumagamit ng disk, kaya’t madalas itong gamitin sa unit testing.

io.BytesIO: In-Memory na Binary Stream

Ang BytesIO ay isang in-memory file class para sa paghawak ng mga byte sequence (bytes). Ito ay kapaki-pakinabang sa mga sitwasyon tulad ng binary processing o data compression na ayaw mong gumamit ng mga file.

1import io
2
3buf = io.BytesIO()
4buf.write(b'\x01\x02\x03')
5buf.seek(0)
6print(list(buf.read()))  # [1, 2, 3]
  • Ang BytesIO ay may parehong interface ng BufferedIOBase at maaaring gamitin bilang kapalit ng maraming file API.

Custom na Streams (Paglikha ng Sariling Mga Klase)

Ang mga klase sa io ay puwedeng i-extend, kaya’t maaari kang gumawa ng sarili mong stream class. Sa ibaba ay isang halimbawa ng TextIOBase subclass na ginagawang lahat uppercase ang text kapag sinusulat.

 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"
  • Basta’t sinusunod mo ang kontrata ng TextIOBase, maaari kang magtakda ng kahit anong custom na behavior na katulad nito. Madali ring i-extend ang mga stream para sa partikular na gamit, gaya ng files at networks.

Buod

Inoorganisa ng io module ang input/output processing sa isang hierarchy ng mga abstract at concretong klase.

  • Ang RawIOBase ay isang class para sa byte I/O sa OS na antas.
  • Ang BufferedIOBase ay isang class na nagbibigay ng efficient cache layer.
  • Ang TextIOBase ay class na namamahala sa pagbabasa at pagsusulat ng mga string.
  • Ang StringIO at BytesIO ay mga class na nagbibigay ng in-memory na stream.

Ang pagkaunawa sa mga klase na ito ay nagbibigay-daan upang mas mauanawaan mo ang takbo ng I/O system ng Python at magamit ito sa operations ng file, komunikasyon sa network, at sa pagdisenyo ng test streams.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video

Operasyon ng File sa Python