Python Tutorial: File Objects - Reading and Writing to Files

Python file objects hinge on two practical choices: opening files in the right mode and managing their lifecycle safely. Using open() without cleanup can leave files open and eventually exhaust the system’s file descriptors, so the tutorial pushes the with context manager as the default pattern. Inside that with block, the file object stays usable; once the block ends, the file is automatically closed—even if the variable still exists—so attempts to read afterward raise an “I/O operation on a closed file” error.

Once a file is open for reading (mode “r”), the tutorial walks through several ways to pull data out. f.read() loads the entire contents into memory, which is fine for small files but risky for very large ones. f.readlines() returns a list of lines, preserving newline characters, while f.readline() advances one line at a time. For large files, iterating directly—“for line in f”—streams line by line without loading everything at once. When more control is needed, f.read(size) reads a fixed number of characters and advances the file pointer accordingly. The pointer position can be inspected via f.tell(), and repositioned with f.seek(). A chunked read loop uses f.read(size) repeatedly until it returns an empty string at end-of-file, avoiding both memory blowups and hardcoded assumptions about file length.

Writing follows the same mode-driven logic. Opening a file in read mode prevents writing and triggers an error (“not writable”), so writing requires mode “w” (overwrite/create) or “a” (append). After writing, the file pointer advances just like reading, so consecutive writes append at the current position. f.seek() can reposition during writing too, but it can be confusing: seeking to the start and writing again overwrites only the portion covered by the new content, leaving any remaining bytes from the earlier write intact.

To combine reading and writing, the tutorial demonstrates copying files using two context managers at once: open the source in read mode and open the destination in write mode, then write each line from the source to the target. The same approach fails for images when treated as text, producing a UnicodeDecodeError. The fix is binary mode: add “b” to the read/write modes (e.g., “rb” and “wb”) so the code transfers bytes rather than decoding text. Finally, it shows chunk-based copying for large binary files: read a fixed-size block (e.g., 496 bytes) in a loop and write each chunk until the read returns an empty result, producing an exact copy without excessive memory use.

Overall, the core takeaway is that reliable file handling in Python comes down to correct modes, context-managed cleanup, and choosing the right read/write strategy—line iteration for text, binary mode for images, and chunked loops for large data.