I/O Python

Mode	Text/Binary	Purpose

'r'

Text

Read-only, file must exist

'w'

Text

Write-only, overwrite existing file

'a'

Text

Append-only, creates file if missing

'x'

Text

Create file, fails if exists

'r+'

Text

Read & write, file must exist

'w+'

Text

Write & read, overwrite file

'a+'

Text

Append & read, create if missing

'rb'

Binary

Read bytes

'wb'

Binary

Write bytes, overwrite file

'ab'

Binary

Append bytes

'xb'

Binary

Create binary file, fail if exists

'r+b'

Binary

Read & write bytes

'w+b'

Binary

Write & read bytes

'a+b'

Binary

Append & read bytes

1️⃣Open a text file to read

with open("file.txt", "r") as f:  # default mode is 'r'
    content = f.read()  # read entire file
    print(content)

• 'r' → read-only, file must exist
• 'rt' → explicit text mode (default)

with is called a context manager in Python.

It ensures that resources are properly managed, even if an error occurs.

In file handling, it automatically closes the file after the block ends — you don’t need to call f.close() manually.

Without with:

f = open(„file.txt“, „r“)
content = f.read()
print(content)
f.close()

If an error occurs before f.close(), the file might stay open → resource leak.

Other read variants:

with open("file.txt", "r") as f:
    line = f.readline()    # read one line
    lines = f.readlines()  # read all lines into a list

---

2️⃣ Open a text file to write

with open("file.txt", "w") as f:
    f.write("Hello world\n")

• 'w' → write-only, overwrites file if it exists
• 'wt' → explicit text mode

---

3️⃣ Open a text file to append

with open("file.txt", "a") as f:
    f.write("Appended line\n")

• 'a' → append-only, adds to end of file
• 'a+' → append + read

---

4️⃣ Open a text file to read and write

with open("file.txt", "r+") as f:
    content = f.read()
    f.write("\nNew line at the end")

• 'r+' → read & write, file must exist
• 'w+' → write & read, overwrites file
• 'a+' → append & read, file created if it does not exist

---

5️⃣ Open a text file for exclusive creation

with open("newfile.txt", "x") as f:
    f.write("This file did not exist before")

• 'x' → fails if file exists
• 'x+' → create exclusively with read/write

---

6️⃣ Open a file in binary mode

Read binary:

with open("file.bin", "rb") as f:
    data = f.read()

Write binary:

with open("file.bin", "wb") as f:
    f.write(b"Hello bytes")

Append binary:

with open("file.bin", "ab") as f:
    f.write(b"\nMore bytes")

Read & write binary:

with open("file.bin", "r+b") as f:
    data = f.read()
    f.write(b"\nNew binary content")

From the course

read(number)

• Purpose: Reads data from a file.
• Parameter: number (optional) — the maximum number of characters (text mode) or bytes (binary mode) to read.
• Returns: A string (text mode) or bytes (binary mode) containing the read data.
• Behavior:
  • If number is omitted or negative → reads the entire file.
  • Reading starts from the current file cursor position.
  • Subsequent read() calls continue from where the last read ended.

Example:

with open("file.txt", "r") as f:
    first_5_chars = f.read(5)  # reads first 5 characters
    next_chars = f.read(10)    # reads next 10 characters

• Useful for reading large files in chunks instead of loading the whole file into memory

readline()

• Purpose: Reads one line from the file at a time.
• Parameter: Optional size — maximum number of characters to read from the line.
• Returns: A string containing the line, including the newline character \n at the end (if present).
• Behavior:
  • Each call reads the next line from the current file cursor.
  • When the end of file is reached, it returns an empty string ''.

Example:

with open("file.txt", "r") as f:
    line1 = f.readline()  # reads first line
    line2 = f.readline()  # reads second line

• Useful when you want to process a file line by line, especially for large files, without loading the entire content into memory.

readlines(number)

• Purpose: Reads multiple lines from a file and returns them as a list of strings.
• Parameter: number (optional) — maximum number of bytes/characters to read from the file.
• Returns: A list where each element is one line (including \n at the end of each line, if present).
• Behavior:
  • If number is omitted → reads all remaining lines into a list.
  • If number is provided → reads approximately that many bytes/characters (may stop mid-file).
  • Stops when file ends.

Example:

with open("file.txt", "r") as f:
    all_lines = f.readlines()       # returns all lines as a list
    first_few = f.readlines(50)     # reads about 50 bytes worth of lines

---

👉 In practice, if you want to iterate line by line efficiently, it’s often better to do:

with open("file.txt", "r") as f:
    for line in f:
        print(line.strip())

(because readlines() loads everything into memory).

readinto(bytearray)

• Purpose: Reads raw bytes from a file directly into a pre-allocated mutable buffer (like a bytearray or memoryview).
• Parameter: bytearray — a writable buffer that will store the read bytes.
• Returns: The number of bytes actually read.
• Behavior:
  • Overwrites the content of the given buffer.
  • Reads at most len(bytearray) bytes.
  • Useful for binary data processing and performance-sensitive code (avoids creating new objects).

---

Example:

with open("file.bin", "rb") as f:
    buf = bytearray(16)        # allocate 16 bytes
    n = f.readinto(buf)        # read up to 16 bytes into buf
    print("Bytes read:", n)
    print("Buffer content:", buf)

If the file has fewer than 16 bytes, only that many will be read, and the rest of the buffer stays unchanged.

write(string)

• Purpose: Writes a string (in text mode) or bytes (in binary mode) to the file.
• Parameter: string (or bytes if file is opened in binary mode).
• Returns: The number of characters/bytes written.
• Behavior:
  • If the file is opened in text mode ("w", "a", "r+" etc.) → expects a string.
  • If the file is opened in binary mode ("wb", "ab", "r+b") → expects a bytes-like object (bytes, bytearray).
  • Data is buffered → not always written to disk immediately (use f.flush() or with to ensure closing).

---

Examples:

✅ Writing text:

with open("file.txt", "w") as f:
    n = f.write("Hello, World!\n")
    print("Characters written:", n)

✅ Writing binary:

with open("file.bin", "wb") as f:
    data = b"\x48\x65\x6C\x6C\x6F"  # "Hello" in hex
    n = f.write(data)
    print("Bytes written:", n)

---

⚡ Notes:

• Overwrites content if the file is in "w" mode.
• Appends content if the file is in "a" mode.
• Does not automatically add a newline (\n), you must include it explicitly.

write(bytearray)

• Purpose: Writes the contents of a bytes-like object (e.g., bytearray, bytes, memoryview) directly to a file.
• Parameter: bytearray (or any buffer-supporting object).
• Returns: The number of bytes written.
• Behavior:
  • File must be opened in a binary mode ("wb", "ab", "rb+", etc.).
  • The entire bytearray (or up to its length) is written to the file.
  • Like write(string), data is buffered until the file is flushed or closed.

---

Example:

data = bytearray([65, 66, 67, 68])  # corresponds to "ABCD"

with open("file.bin", "wb") as f:
    n = f.write(data)
    print("Bytes written:", n)   # → 4

File content (in hex):

41 42 43 44

which is "ABCD" in ASCII.

open()

• Purpose: Opens a file and returns a file object (also called a handle) that allows reading, writing, or updating the file.
• Basic syntax:

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

Parameter	Description

file	Path to the file (string or path-like object). Example: "file.txt"

mode	How the file is opened (read, write, append, binary, etc.). Default: "r" (read, text).

buffering

Controls buffering: 0 → unbuffered (binary only) 1 → line-buffered (text only) >1 → use buffer of that size -1 (default) → system default

encoding

Text encoding (e.g., "utf-8", "latin-1"). Required for non-ASCII text.

errors

How to handle encoding/decoding errors (e.g., "ignore", "replace").

newline

Controls how newlines are handled in text mode (None, "", "\n", "\r", "\r\n").

closefd

If False, keeps file descriptor open (advanced use, rarely needed).

opener

Custom opener function (rare, for low-level control).