File Handling in Python: The Complete Beginner's Guide

1What is file handling

Almost every real program eventually needs to remember something after it closes: a saved game, a log of what happened, a config the user set last time, a report someone can open later. That is what file handling is for. It is how a running Python program talks to the file system underneath it rather than just holding values in memory that vanish the moment the script ends.

In Python, file handling covers five basic operations:

• Creating a new file on disk
• Reading content out of an existing file
• Writing data into a file
• Modifying existing content
• Deleting a file entirely

Python handles all of this through a small set of built-in functions and a consistent, readable syntax, so once the core pattern clicks, the same approach carries you through logs, config files, CSV data, and even binary formats like images.

2Opening a file and file modes

Every file operation in Python starts with the built-in open() function. It takes a filename and a mode, and returns a file object you then read from or write to.

file = open("example.txt", "r")

The general syntax is straightforward: a filename (or path) first, then a mode string second.

open(filename, mode)

Common file modes

These modes combine, so you will often see something like "rb" (read binary) or "wt" (write text, though this is the same as plain "w" since text is already the default).

3Reading a file three ways

Assume example.txt contains these two lines:

Method 1: read()

Reads the entire file into a single string, whitespace and newlines included. This is the simplest option for small files where you want everything at once.

file = open("example.txt", "r")
content = file.read()
print(content)
file.close()

Method 2: readline()

Reads a single line at a time, moving forward through the file with each call. Useful when you want to process a file line by line without loading it all into memory.

file = open("example.txt", "r")
line1 = file.readline()
line2 = file.readline()
print(line1, line2)
file.close()

Method 3: readlines()

Reads every line and returns them as a list of strings, each one still carrying its trailing newline character. Looping over that list is the standard way to process a file line by line.

file = open("example.txt", "r")
lines = file.readlines()
for line in lines:
    print(line.strip())
file.close()

4Writing and appending to a file

Overwrite a file

"w" mode replaces the entire contents of the file with whatever you write. If the file does not exist yet, it is created.

file = open("example.txt", "w")
file.write("This replaces everything.\n")
file.write("Second line.")
file.close()

Append to a file

"a" mode keeps the existing content and adds new text to the end, making it the right choice for anything like logging where you never want to lose earlier entries.

file = open("example.txt", "a")
file.write("\nThis is a new line.")
file.close()

5The with statement, and why it matters

Every example so far ends with an explicit file.close() call, and every one of those calls is a place a bug can sneak in. If an error happens between open() and close(), the close line never runs, and the file stays open longer than it should, sometimes locking it or losing buffered writes that never actually made it to disk.

The with statement solves this by managing the file's lifecycle for you. It opens the file, gives you a variable to work with, and guarantees the file is closed when the block ends, whether it finished normally or an exception was raised partway through.

with open("example.txt", "r") as file:
    content = file.read()
    print(content)
# file is automatically closed here, even if an error occurred above

No need to call file.close() manually, and no risk of forgetting it. This is why with open(...) is the pattern used in essentially all professional Python code, and it is the version you should default to from here on.

6Reading and writing at the same time

Mode "r+" opens a file for both reading and writing without truncating it first, which makes it useful when you need to inspect and modify a file in the same session.

with open("example.txt", "r+") as file:
    file.write("Start: ")
    content = file.read()
    print(content)

7Working with binary files

Text mode assumes the file contains readable characters and decodes it using a text encoding. Binary files, images, PDFs, audio, compiled programs, are not text at all, and opening them in text mode either corrupts the data or raises a decoding error. Binary mode reads and writes raw bytes instead:

with open("image.jpg", "rb") as file:
    data = file.read()

data here is a bytes object rather than a string. You will see this pattern whenever a program downloads a file, copies an image, or hands raw content to another library, for example reading image data for computer vision often starts from exactly this kind of byte-level file access before OpenCV decodes it into pixel arrays.

8Checking if a file exists

Trying to read a file that is not there raises an error, so it is common to check first using the standard library's os module:

import os

if os.path.exists("example.txt"):
    print("File exists!")
else:
    print("File not found.")

9Deleting a file

The same os module handles deletion:

import os

os.remove("example.txt")

10Copying file content

You do not need any special library to copy a text file's contents, opening both files at once and passing data between them is enough:

with open("source.txt", "r") as src:
    with open("destination.txt", "w") as dest:
        dest.write(src.read())

You can nest with statements like this, or combine them on one line using a comma, both open at the same time and both close automatically when the block ends.

with open("source.txt", "r") as src, open("destination.txt", "w") as dest:
    dest.write(src.read())

11Common errors and how to fix them

Handling these gracefully means wrapping the risky operation in a try block rather than letting the whole program crash:

try:
    with open("data.txt", "r") as f:
        print(f.read())
except FileNotFoundError:
    print("File not found.")

12Working with paths safely

Every example above uses a bare filename like "example.txt", which Python resolves relative to wherever the script was run from, not necessarily where the script file itself lives. This is one of the most common sources of "file not found" confusion for beginners, since running the same script from a different folder changes what a relative path points to.

For anything beyond a quick script, the standard library's pathlib module is the modern, recommended way to build paths that work correctly across Windows, macOS, and Linux without manually worrying about slash direction:

from pathlib import Path

# Build a path relative to this script's own location
script_dir = Path(__file__).parent
file_path = script_dir / "data" / "example.txt"

with open(file_path, "r") as f:
    print(f.read())

13Best practices checklist

• Always use with open() instead of manual open() and close() calls, so files are never left open by accident.
• Handle errors with try/except around any file operation that touches user-provided paths or external data.
• Prefer pathlib over string concatenation when building file paths, especially in code that might run on more than one operating system.
• Be precise with modes. Reach for "a" instead of "w" whenever you do not want to risk erasing existing content.
• Avoid hardcoding filenames where possible, pass them as function arguments or configuration values instead, so the same code can be reused for different files.
• Read large files in chunks rather than loading them entirely into memory with a single read() call.

14What to learn next

Python's file handling is one of its most beginner-friendly features. With just a few lines of code you can read, write, and manage files, whether that is logs, datasets, or reports, and the with pattern you learned here carries forward into almost every other resource-handling situation in Python, including database connections and network sockets.

Once you are comfortable with basic file I/O, a natural next step is structured data formats built on top of these same principles:

• CSV and JSON files, the two most common formats for structured data exchange, both readable with a few extra lines on top of what you learned here.
• Reading large files efficiently, including chunked reading and generators that avoid loading an entire file into memory at once.
• Handling directories and file trees with os and pathlib, walking folders, filtering by extension, and organizing output automatically.

The data storage in Python guide picks up exactly here and goes further into structured formats and persistence patterns. If you want the full sequence from fundamentals onward, the Python roadmap lays out what to study before and after this topic.