Learn What I/O Is in Python: Absolute Beginners Tutorial

Every useful program does two things: it receives data and it produces data. That exchange — taking something in and putting something out — is what programmers call I/O. Before you can write programs that interact with users or work with files, you need a clear picture of how Python handles that flow.

I/O stands for input/output. It describes the movement of data into and out of a running program. In Python, this takes several forms depending on where the data comes from and where it needs to go. At the beginner level the three forms you will work with most often are keyboard input, screen output, and file I/O. Each one uses a small set of built-in tools that Python provides out of the box.

What I/O Means and Why It Matters

A program that cannot receive data from the outside world can only ever do the same thing every time it runs. A program that cannot send data anywhere produces results nobody can see or use. I/O is what connects your code to reality.

Python organises I/O around the concept of streams. A stream is simply a sequence of data that flows in one direction. Three standard streams exist in almost every program:

Standard Output: The print() Function

The most common piece of output in Python is a call to print(). It takes whatever values you pass in, converts them to strings, and writes them to stdout followed by a newline. The Python documentation defines it precisely: print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False). At its simplest:

print("Hello, world!")
# Output: Hello, world!

You can pass multiple values separated by commas. Python joins them with a space by default:

name = "Mona"
age = 28
print("Name:", name, "| Age:", age)
# Output: Name: Mona | Age: 28

Two keyword arguments give you control over how values are joined and how the line ends:

# sep changes the separator between values (default is a space)
print("red", "green", "blue", sep=", ")
# Output: red, green, blue

# end changes the line terminator (default is "\n")
print("Loading", end="...")
print("done")
# Output: Loading...done

print("a", "b", "c", sep="-", end="!\n")
print("done")

"The desire for a simpler way to format strings in Python drove this PEP."

Standard Input: The input() Function

Where print() sends data out, input() brings data in. It pauses the program, displays an optional prompt, waits for the user to type something and press Enter, then returns everything typed as a plain string.

name = input("What is your name? ")
print(f"Nice to meet you, {name}!")

The return value is always a string, even when the user types a number. If you need to do arithmetic with the result, you have to convert it:

raw = input("Enter your birth year: ")
year = int(raw)          # convert string to integer
age = 2026 - year
print(f"You are approximately {age} years old.")

Here is what reading and writing looks like in practice:

# Writing to a file
with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("Python I/O is straightforward.\n")
    f.write("Use 'with' to handle files safely.\n")

# Reading from a file
with open("notes.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# Appending a new line without overwriting
with open("notes.txt", "a", encoding="utf-8") as f:
    f.write("Appended this line later.\n")

# Reading line by line using readlines()
with open("notes.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
    for line in lines:
        print(line, end="")

For writing, there is a counterpart to .readlines() that many beginners miss: .writelines(). It accepts an iterable of strings and writes each one to the file without adding newlines between them — you are responsible for including \n in each string if you need line breaks:

# .writelines() writes an iterable of strings — no newlines added automatically
lines = ["First line\n", "Second line\n", "Third line\n"]
with open("output.txt", "w", encoding="utf-8") as f:
    f.writelines(lines)

# Also works with a generator — useful for large datasets
with open("output.txt", "w", encoding="utf-8") as f:
    f.writelines(f"Item {i}\n" for i in range(1, 6))

There is a third approach that is more Pythonic than both .read() and .readlines() when you need to process a file line by line: iterating directly over the file object. Python's file objects are iterators, so you can use a for loop without loading the entire file into memory first:

# Iterate directly — one line at a time, no full load into memory
with open("notes.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line, end="")   # line already contains \n

"Explicit is better than implicit."

That principle applies directly to file I/O. The with statement makes the open and close operations visible and intentional. Leaving files open by calling open() without with and forgetting to call .close() is a real source of bugs, especially in long-running programs.

Output Buffering and Flushing

One behaviour that surprises many beginners is that print() does not always write to the screen the instant it is called. Python buffers stdout when it detects that output is going to a file or a pipe rather than an interactive terminal. That means your output may sit in memory and not appear until the buffer is full or the program ends.

You can force Python to write immediately using the flush keyword argument:

import time

for step in ["Connecting", "Authenticating", "Loading"]:
    print(step + "...", end="", flush=True)
    time.sleep(1)
    print(" done")

# Without flush=True the dots may not appear until after the sleep

You can also disable buffering entirely at startup by running Python with the -u flag (python -u script.py), or by setting the PYTHONUNBUFFERED=1 environment variable. Both approaches are common in containerised environments where log output needs to be visible in real time.

print("status", end="")
print(": OK")

Replacing stdin and stdout at Runtime

Because sys.stdin and sys.stdout are just file-like objects, you can replace them at runtime. This technique is used widely in testing and scripting to redirect I/O without touching the operating system level:

import sys
import io

# Capture all print() output into a string
buffer = io.StringIO()
sys.stdout = buffer

print("This goes into the buffer, not the terminal.")
print("So does this.")

sys.stdout = sys.__stdout__   # restore the original stdout
captured = buffer.getvalue()
print("Captured:", repr(captured))

Writing to stderr

The third standard stream, sys.stderr, is reserved for error messages and diagnostic output. Sending errors to stderr instead of stdout matters because the two streams can be redirected independently at the shell level. A user running your script can pipe stdout to a file and still see error messages on the terminal — something that is impossible if you print everything to stdout.

The cleanest way to write to stderr from Python is to pass sys.stderr as the file argument to print():

import sys

# Normal output goes to stdout
print("Processing started...")

# Error messages belong on stderr
print("Error: file not found", file=sys.stderr)

# You can also write directly to the stream (must be a string, not bytes)
sys.stderr.write("Critical failure\n")

At the shell, you can redirect stdout and stderr independently. Running python script.py > output.txt 2> errors.txt sends normal output to output.txt and error messages to errors.txt. This separation is what makes log files useful in production — you can filter signal from noise without mixing the two streams.

Encoding and Text Mode

When Python opens a file in text mode (the default), it automatically encodes and decodes bytes using a character encoding. The exact default depends on your platform and Python version. On most modern Linux and macOS systems it is UTF-8. On Windows, the default has historically been determined by the system locale — on older Windows installations it may be cp1252, cp932, or another legacy encoding — which has been a persistent source of cross-platform bugs for years.

This is a frequent source of bugs when code written on one machine is run on another. The safest practice — and mandatory for code that must work on Python 3.14 and earlier — is to always specify the encoding explicitly:

# Always specify encoding when portability matters
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

# Binary mode bypasses encoding entirely — use for images, PDFs, etc.
with open("image.png", "rb") as f:
    raw_bytes = f.read()

If you need to read a file whose encoding you do not know, the third-party chardet library can detect it. For files that may contain encoding errors, the errors parameter on open() controls the behaviour: errors="ignore" silently drops undecodable bytes, while errors="replace" substitutes a replacement character.

"The default encoding is platform dependent."

This is accurate through Python 3.14. From Python 3.15 onward, PEP 686 changes the default to UTF-8 on all platforms. The same advice still applies: specifying encoding="utf-8" explicitly is the portable choice that works correctly on every Python version and operating system.

Handling Missing Files

If you pass a path that does not exist to open() in read mode, Python raises a FileNotFoundError — a subclass of OSError. This is the single most common file I/O error beginners encounter, and it stops the program unless you handle it. The right tool is a try/except block:

import sys

try:
    with open("config.txt", "r", encoding="utf-8") as f:
        content = f.read()
except FileNotFoundError:
    print("Error: config.txt not found.", file=sys.stderr)
    sys.exit(1)    # exit with a non-zero code to signal failure

Notice the error message goes to sys.stderr, not stdout. The sys.exit(1) call terminates the program and signals to the calling shell or process that something went wrong. Exit code 0 means success; any non-zero value means failure.

Command-Line Arguments with sys.argv

The input() function handles interactive keyboard input, but many Python scripts need to accept input before they start running — through arguments typed on the command line. Python collects those arguments in sys.argv, a list of strings. The first element (sys.argv[0]) is always the script name; the rest are the arguments the user passed.

# greet.py
import sys

if len(sys.argv) < 2:
    print("Usage: python greet.py <name>", file=sys.stderr)
    sys.exit(1)

name = sys.argv[1]
print(f"Hello, {name}!")

Running this script with python greet.py Alice produces Hello, Alice!. Running it without an argument prints the usage message to stderr and exits with code 1.

All sys.argv values are strings, just like the return value of input(). Convert them with int() or float() when your script expects a number. For more sophisticated argument parsing — named flags, optional arguments, automatic help text — the standard library's argparse module builds on this foundation.

Python I/O Learning Summary

1. I/O means input/output. Every program that does something useful takes data in and sends data out. Python organises this around three standard streams: stdin, stdout, and stderr.
2. print() handles output. It writes to stdout by default. Use sep to control how multiple values are joined and end to control the line terminator. The flush argument (added in Python 3.3) forces immediate output. F-strings are the most readable way to embed variable values in output.
3. input() handles keyboard input. It always returns a string. Convert the result with int() or float() when you need a numeric value.
4. open() handles file I/O. Use 'r' to read, 'w' to write (overwrites), 'a' to append, and 'x' to create exclusively (raises FileExistsError if the file already exists). Always wrap open() in a with statement so the file is closed automatically.
5. Three read methods, three use cases. Use .read() for the full file as one string, .readlines() for a list of lines, and .readline() to pull one line at a time — useful when reading large files you cannot load into memory all at once.
6. Type conversion is your responsibility. Python does not convert data for you when reading from input() or reading strings from files. You need to call int(), float(), or other converters explicitly.
7. Buffering affects when output appears. stdout is buffered when writing to a pipe or file. Use flush=True or the -u flag when you need output to appear in real time.
8. stderr is for errors. Pass file=sys.stderr to print() to send error messages to the error stream instead of stdout. The two streams can be redirected independently at the shell level, which is what makes this distinction useful.
9. Iterate over files directly. A for line in f: loop is the idiomatic way to read a file line by line without loading it all into memory. Use it instead of .readlines() when the file could be large.
10. FileNotFoundError is the common file exception. Wrap open() in a try/except FileNotFoundError block rather than checking existence with os.path.exists() first. This avoids the race condition between the check and the open.
11. sys.argv holds command-line arguments. Every string after the script name on the command line appears as an element of sys.argv. All values are strings; convert them as needed. For complex argument parsing, use the standard library's argparse module.
12. Always specify encoding when opening files. Default encodings differ between operating systems on Python 3.14 and earlier — check your platform default with locale.getencoding() (Python 3.11+) or locale.getpreferredencoding(). Python 3.15 makes UTF-8 the default on all platforms via PEP 686, but passing encoding="utf-8" explicitly to open() remains the correct practice for code targeting any Python version.

These fundamentals cover the I/O you will use in the vast majority of beginner and intermediate Python programs. More advanced forms — network sockets, database connections, binary file reading, serialisation formats like JSON and CSV — all follow the same mental model: data comes in through some channel, your program transforms it, and data goes out through some channel.

If you are working through python tutorials and this is your first encounter with I/O, take time to experiment with each function before moving on. Run the code examples in a terminal or IDE, intentionally cause a ValueError by passing the wrong type, and try redirecting stdout to a file from the command line with python script.py > output.txt. Hands-on repetition is what moves I/O from concept to instinct.

One detail worth understanding at the systems level: print() and input() are high-level wrappers built on top of the underlying C standard library calls fwrite and fgets. CPython calls these through the operating system's file descriptor API. Every call to print() ultimately writes bytes to file descriptor 1 (stdout), and every call to input() reads bytes from file descriptor 0 (stdin). Understanding this helps explain why you can redirect stdin and stdout at the shell level — the operating system owns those file descriptors, not Python. This is the kind of detail that separates programmers who understand the tool from those who only use it.

import sys

# sys.stdout is a TextIOWrapper
print(type(sys.stdout))           # <class '_io.TextIOWrapper'>

# .buffer is the BufferedWriter underneath
print(type(sys.stdout.buffer))    # <class '_io.BufferedWriter'>

# .buffer.raw is the FileIO at the bottom
print(type(sys.stdout.buffer.raw))  # <class '_io.FileIO'>

# The file descriptor number (1 = stdout, 0 = stdin, 2 = stderr)
print(sys.stdout.fileno())        # 1

import os

with open("critical.dat", "w", encoding="utf-8") as f:
    f.write("important data\n")
    f.flush()          # moves from Python buffer → OS kernel page cache
    os.fsync(f.fileno())  # forces OS to flush kernel cache → physical disk
    # After fsync(), a power failure will NOT corrupt the data

import sys

# Slow: one write() call per line, plus print() overhead
for i in range(1_000_000):
    print(i)

# Fast: accumulate, then one write() call
sys.stdout.write("\n".join(str(i) for i in range(1_000_000)) + "\n")

# Fastest for very large output: write directly to the binary buffer
# (bypasses the text encoding layer — only valid for pure ASCII)
out = "\n".join(str(i) for i in range(1_000_000)) + "\n"
sys.stdout.buffer.write(out.encode("ascii"))

# Line-buffered: every newline triggers a flush — useful for log files
# that need to be tail-able without losing data on crash
with open("app.log", "w", encoding="utf-8", buffering=1) as log:
    log.write("Server started\n")    # flushed immediately
    log.write("Listening on :8080\n") # flushed immediately

# Read with universal newline translation (default)
with open("file.txt", "r", encoding="utf-8") as f:
    content = f.read()   # \r\n and \r both become \n

# Disable translation — get bytes exactly as stored on disk
with open("file.txt", "r", encoding="utf-8", newline="") as f:
    content = f.read()   # \r\n preserved as-is

# This matters for: CSV parsing (csv module sets newline="" internally),
# processing files from mixed-OS sources, and diff-generation tools.

import os

with open("notes.txt", "w", encoding="utf-8") as f:
    fd = f.fileno()           # e.g. 3, 4, 5 — always >= 3 (0,1,2 are stdin/stdout/stderr)
    print(f"File descriptor: {fd}")

# os.open() returns a raw fd, not a Python file object
fd2 = os.open("notes.txt", os.O_RDONLY)
f2 = os.fdopen(fd2, "r", encoding="utf-8")   # wrap it in a Python file object
try:
    print(f2.read())
finally:
    f2.close()    # closing f2 also closes fd2

import sys, io

# Some library replaces sys.stdout
sys.stdout = io.StringIO()

# Your code still needs to reach the terminal
print("This is lost in the StringIO buffer")

# Emergency escape hatch — always points to the original terminal stream
sys.__stdout__.write("This reaches the terminal no matter what\n")