Learn What open() is in Python: Absolute Beginners Tutorial

Every Python program that touches a file — reading a config, saving output, loading data — starts with one call: open(). This tutorial explains exactly what that function is, what it returns, and how to use it safely from your very first line.

When you write a Python script, everything you work with lives in memory. The moment your program stops, that memory is gone. Files let you store information that outlasts your program — logs, data, results, configuration. The open() function is how Python connects your code to those files.

What open() Is and What It Does

open() is a Python built-in function. That means it comes with Python itself — you never need to import it. When you call it, Python creates a connection to a file on your computer and hands you back a file object. You use that file object to read from or write to the file.

Think of open() like opening a book. The book still exists on the shelf whether you open it or not. When you open it, you get access to its contents and you can start reading. When you are done, you close the book so others can use it. Python files work the same way.

The Syntax of open()

The official signature from the Python documentation is:

open(file, mode='r', buffering=-1, encoding=None,
     errors=None, newline=None, closefd=True, opener=None)

As a beginner, you only need to think about two parameters to start:

The simplest possible call looks like this:

f = open("notes.txt")   # Opens notes.txt in read mode ('r') by default

Because mode defaults to 'r', you do not have to pass it when reading. The variable f now holds a file object. You will use f to call methods like f.read().

File Modes

The mode parameter tells Python what you intend to do with the file. Choosing the wrong mode is one of the most common beginner mistakes — particularly using 'w' when you meant 'a', which silently erases your data.

Modes can be combined. For example, 'rb' means read in binary mode, and 'wb' means write in binary mode. Binary mode is used for images, PDFs, executables, and any file that is not plain text.

Reading a File

Once a file is open in read mode, there are three main methods for accessing its contents:

with open("notes.txt", "r", encoding="utf-8") as f:
    # 1. read() — returns the entire file as one string
    contents = f.read()
    print(contents)

with open("notes.txt", "r", encoding="utf-8") as f:
    # 2. readline() — returns one line per call; call it again for the next line
    first_line = f.readline()
    second_line = f.readline()

with open("notes.txt", "r", encoding="utf-8") as f:
    # 3. readlines() — returns a list; each element is one line
    lines = f.readlines()
    print(lines)

You can also iterate over a file object directly in a loop, which is memory-efficient for large files because Python reads one line at a time rather than loading everything at once:

with open("notes.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())   # .strip() removes the trailing newline

Writing and Appending to a File

Writing to a file uses the write() method on the file object. The key difference between write mode and append mode is what happens to any content already in the file:

# Write mode — creates or overwrites the file
with open("log.txt", "w", encoding="utf-8") as f:
    f.write("First entry\n")
    f.write("Second entry\n")

# Append mode — adds to the end without erasing
with open("log.txt", "a", encoding="utf-8") as f:
    f.write("Third entry\n")

Note that write() does not automatically add a newline character at the end of each string. You have to include \n yourself wherever you want a line break.

The writelines() method accepts a list of strings and writes them all in one call, but like write(), it does not insert newlines between items:

lines = ["line one\n", "line two\n", "line three\n"]

with open("output.txt", "w", encoding="utf-8") as f:
    f.writelines(lines)

The with Statement and Context Managers

Every file you open must eventually be closed. Closing a file releases the system resource (the file handle) it holds. If you forget to close a file, your program ties up that resource until the operating system forcibly reclaims it — or until your script ends.

You can close a file manually by calling f.close(), but this approach has a flaw: if an exception occurs between open() and f.close(), the close never runs:

# Fragile — if anything between open and close raises an exception,
# f.close() never runs
f = open("data.txt", encoding="utf-8")
contents = f.read()
f.close()   # May be skipped if an error occurs above

The correct approach is to use the with statement. It creates a context manager that guarantees the file will be closed when the block exits — no matter what:

# Correct — file is automatically closed when the block ends
with open("data.txt", encoding="utf-8") as f:
    contents = f.read()
    print(contents)
# f is now closed, even if read() raised an exception

You can open multiple files in a single with statement by separating them with a comma:

with open("input.txt", encoding="utf-8") as src, \
     open("output.txt", "w", encoding="utf-8") as dst:
    for line in src:
        dst.write(line.upper())

Handling Errors

When you open a file in read mode and the file does not exist, Python raises a FileNotFoundError. Rather than letting your program crash, you can catch that exception and handle it gracefully:

try:
    with open("config.txt", encoding="utf-8") as f:
        data = f.read()
except FileNotFoundError:
    print("config.txt was not found. Using default settings.")
except PermissionError:
    print("Access denied. Check file permissions.")

Two errors are particularly common when working with files: FileNotFoundError (file does not exist when reading) and PermissionError (the operating system blocked access). Catching both gives your program a sensible fallback for the most frequent failure modes.