File I/O

Ensures safe file writing with guaranteed resource cleanup on block exit.

Configuration management: writing settings to a config file, Data processing: saving transformed output to disk, Logging: directing application output to a log file

Python scripts, data processing pipelines, web scraping utilities, any code that needs to write text files.

with open(filename, mode, encoding=encoding) as handle:

with open(..., ..., encoding=...) as ...:

filename: str, mode: 'r'|'w'|'a' etc., encoding: str (e.g., 'utf-8'), file_var: identifier

• write()
• writelines()
• print(...
• file=f)
• json.dump()

• using pathlib.Path.open()
• using open() without encoding (relies on platform default)
• using a try/finally block

Omitting with and calling open() directly: causes file descriptor leaks if close() is skipped or an exception occurs before close(). Using mode 'r' when intending to write: causes UnsupportedOperation error since the file is read-only. Specifying an invalid encoding name: causes LookupError at open time. Opening with binary mode 'wb' but writing str instead of bytes: causes TypeError since binary mode expects bytes objects.

with open(..., 'rb') as f: for binary reading; using contextlib.suppress for ignoring errors; using open() without with statement (manual close)

Coming from C: expecting to call fclose() manually after fopen() → Python's with statement calls close() automatically on block exit. Coming from Java: looking for try-with-resources syntax → Python uses with open(...) as f: instead.

• file handling
• context managers
• resource acquisition is initialization (RAII)

When NOT to use: avoid when a file must remain open across function boundaries or for an object's lifetime; use explicit open/close or a dedicated class instead. Performance: the with block adds negligible overhead; the real cost is the I/O itself. Boundary condition: if encoding is omitted, Python defaults to locale.getpreferredencoding(False), which varies across platforms and can cause UnicodeEncodeError on systems with non-UTF-8 defaults.

Guarantees proper resource cleanup, preventing file descriptor leaks and ensuring data is flushed.

Think 'with open' as a file hug that automatically lets go when done.

The file is guaranteed to be closed when the block exits, however, exceptions inside the block are not suppressed unless handled.

Using pathlib.Path('output.txt').open('w', encoding='utf-8') as f: for more modern path handling.