Quick answer: Use open(path, mode, encoding=…) inside a with statement so the file closes predictably. Choose text or binary mode deliberately, specify an encoding for text, and remember that w truncates existing content while a appends.
Python open() creates a file object for reading, writing, appending, or binary access. The most important choices are the file path, mode, encoding, and whether the file is closed correctly after use. File operations can raise Errno 22 when a path, filename, mode, or handle is invalid; Fix OSError errno 22 invalid argument provides the platform-specific checks. Using a closed, duplicated, or invalid file handle can raise Errno 9; Fix Bad File Descriptor in Python traces the descriptor lifecycle and repair steps.
In modern Python code, use with open(...) for most file handling. The context manager closes the file automatically, even if an exception happens inside the block. That keeps file descriptors from leaking and makes the lifetime of the file object obvious. Code using with open() can be tested without touching disk; Python Mock Context Manager Guide shows how to mock __enter__, __exit__, and the yielded resource.
The mode you choose controls what operations the file object supports. A file opened for reading cannot be written to, and a file opened in binary mode returns bytes instead of strings. Choose the mode before writing the rest of the file logic.
The official Python open documentation, file input and output tutorial, Path.open documentation, and io module documentation are the primary references.
Read A Text File
Use mode "r" for reading text. Specify an encoding when you know the file’s text encoding.
with open("notes.txt", "r", encoding="utf-8") as file:
text = file.read()
print(text)
If the file does not exist, Python raises FileNotFoundError. Handle that case near the code that knows whether a missing file is acceptable.
For configuration files, a missing file may be an error. For optional cache files, it may be normal. The calling code should make that decision instead of hiding every file error.
Read Lines Safely
Iterating over a file object reads one line at a time, which is better for large files than reading everything into memory.
with open("notes.txt", "r", encoding="utf-8") as file:
for line_number, line in enumerate(file, start=1):
print(line_number, line.rstrip())
rstrip() removes the ending newline for display. The file object still provides each line in order.
This pattern is useful for logs, reports, and text files that may be larger than memory. It also lets you stop early if you find the line you need.
Write A Text File
Use mode "w" to create a file or replace the full contents of an existing file.
message = "Python file handling\n"
with open("output.txt", "w", encoding="utf-8") as file:
file.write(message)
Write mode is destructive for existing files because it starts from an empty file. Use it when replacement is intended.
When you are testing a script, write to a new output path first. After the result is correct, decide whether the script should replace the original file or keep both versions.
Append To A File
Use mode "a" when new text should go to the end of the file.
log_line = "job finished\n"
with open("app.log", "a", encoding="utf-8") as file:
file.write(log_line)
Append mode is useful for logs and simple history files. It is not the right mode for editing text in the middle of a file.
If you need to update existing content in the middle of a text file, it is often clearer to read the file, build the new text, and write the full result back to a separate output file.
Read Binary Data
Use binary modes such as "rb" and "wb" when the file contains bytes instead of text.
with open("image.bin", "rb") as file:
header = file.read(8)
print(header)
Do not pass an encoding in binary mode. Encodings apply to text, not raw bytes.
Binary mode is common for compressed files, images, archives, and network payloads saved to disk. Text methods such as readline() still exist, but they return bytes lines rather than string lines.
Use pathlib With open()
pathlib.Path provides an object-oriented way to build paths and open files.
from pathlib import Path
path = Path("data") / "notes.txt"
path.parent.mkdir(parents=True, exist_ok=True)
with path.open("w", encoding="utf-8") as file:
file.write("created with pathlib\n")
This is helpful when code builds paths from directories and filenames. It also keeps path operations readable across platforms.
pathlib is especially useful when paths are composed from user choices, config values, or project directories. It avoids fragile string concatenation and keeps directory creation close to the file operation. If open() cannot resolve the requested path, Fix IOError Errno 2 No Such File or Directory separates missing files from wrong working directories, malformed paths, and absent parent folders.
Choose The Right Mode
Use "r" for reading, "w" for replacing, "a" for appending, "x" for creating only when missing, and binary variants like "rb" or "wb" for byte data. If you need both reading and writing, modes such as "r+" exist, but they require careful use of the file position.
Always decide whether the operation should preserve existing content. That decision determines the mode and prevents accidental file replacement.
Also decide whether the file is text or bytes. Text mode handles decoding and encoding. Binary mode preserves bytes exactly. Mixing those two concepts is a common source of confusing file bugs.
The reliable pattern is to open files with with, choose an explicit mode, pass an encoding for text files, use binary mode for bytes, and keep path handling clear with pathlib when paths become more than a literal filename. When a file should exist only during one operation or test, Python tempfile Module: Temporary Files Guide provides safe temporary files and directories with automatic cleanup.
Choose Text Or Binary
Text mode decodes bytes into strings and accepts an encoding, while binary mode returns bytes and is appropriate for images, archives, and other non-text data. Do not mix the two interfaces accidentally.
Choose The Mode Carefully
r reads an existing file, w creates or truncates, x creates only when absent, and a appends. Add + only when a read-and-write workflow is truly needed, because it complicates the file position and buffering rules.
Specify Encoding And Newlines
UTF-8 is a common explicit choice for text, but the correct encoding belongs to the data contract. Set newline behavior when cross-platform line endings matter and test files from the environments you support.
Use A Context Manager
The with open(…) as handle pattern closes the resource when the block exits, including most exception paths. Keep the operation inside the block and do not return a handle that has already been closed.
Handle Paths And Errors
Validate the path policy, distinguish a missing file from a permission error, and avoid overwriting user data without an explicit decision. For atomic replacement, write a temporary file and replace it after a successful close.
Test Round Trips
Test empty files, Unicode, newlines, binary bytes, append behavior, truncation, missing paths, permissions, and exceptions. Assert both the data and the resulting file state.
The official open() documentation defines modes, encoding, newline, and error behavior. Related Python Pool references include tests and dictionaries.
For related file workflows, compare text and encoding behavior, round-trip tests, and structured records before choosing an open mode.
Frequently Asked Questions
How do I open a file in Python?
Use open(path, mode, encoding=…) inside a with statement, then read or write through the returned file object.
Why should I specify an encoding?
The default encoding can vary by environment; an explicit encoding such as UTF-8 makes text behavior more reproducible.
What is the difference between w and a mode?
w creates or truncates a file, while a appends to an existing file or creates it, so choose carefully to avoid data loss.
Why use a context manager with open?
The with statement closes the file even when the body raises an exception, which prevents leaked descriptors and incomplete resource handling.
