← Python

File I/O & Context Managers

← File I/O & Context Managers

Select a question from the sidebar

12 questions in this topic

Question 1 / 12

What are the different file modes in Python's `open()` function?

The open() function accepts a mode string that controls how the file is opened:

Basic modes:

'r' -- Read (default). File must exist.
'w' -- Write. Creates file or truncates existing file.
'a' -- Append. Creates file or appends to existing.
'x' -- Exclusive create. Fails if file already exists.

Modifiers (added to basic mode):

'b' -- Binary mode. Data is bytes, not str.
't' -- Text mode (default). Data is str.
'+' -- Read AND write.

Common combinations:

'rb' -- Read binary (images, audio)
'wb' -- Write binary
'r+' -- Read/write without truncating
'w+' -- Read/write, truncates first
'a+' -- Read/append

Additional open() parameters: encoding (default varies by OS, explicitly set to 'utf-8'), newline, buffering, errors.

Pseudo Code

r  = read (must exist)
w  = write (truncates!)
a  = append (creates if needed)
x  = exclusive create (fails if exists)
b  = binary mode (bytes)
t  = text mode (str, default)
+  = read+write

Always specify encoding='utf-8' for text files

Code

import os

# Write a new file
with open("/tmp/example.txt", "w", encoding="utf-8") as f:
    f.write("Hello, World!\n")
    f.write("Second line\n")

# Read the file
with open("/tmp/example.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# Append to the file
with open("/tmp/example.txt", "a", encoding="utf-8") as f:
    f.write("Appended line\n")

# Exclusive create -- fails if exists
try:
    with open("/tmp/example.txt", "x", encoding="utf-8") as f:
        f.write("New file")
except FileExistsError:
    print("File already exists!")

# Read + Write (without truncating)
with open("/tmp/example.txt", "r+", encoding="utf-8") as f:
    content = f.read()  # read all
    f.seek(0)           # go back to start
    f.write("MODIFIED") # overwrite beginning

# Binary mode for non-text files
with open("/tmp/data.bin", "wb") as f:
    f.write(b"\x00\x01\x02\x03")

with open("/tmp/data.bin", "rb") as f:
    data = f.read()
    print(data)  # b'\x00\x01\x02\x03'
    print(type(data))  # <class 'bytes'>

# Always specify encoding for text files
# Bad: open("file.txt")  -- encoding depends on OS
# Good: open("file.txt", encoding="utf-8")

# Reading methods
with open("/tmp/example.txt", "r", encoding="utf-8") as f:
    all_content = f.read()          # entire file as string
    f.seek(0)
    one_line = f.readline()         # one line
    f.seek(0)
    all_lines = f.readlines()       # list of lines
    f.seek(0)
    for line in f:                  # iterate line by line (memory efficient)
        print(line.rstrip())

# Cleanup
os.remove("/tmp/example.txt")
os.remove("/tmp/data.bin")

Hello, World!
Second line

File already exists!
b'\x00\x01\x02\x03'
<class 'bytes'>
MODIFIEDorld!
Second line
Appended line

Key Points

•'w' truncates existing files -- use 'a' to append
•'x' prevents overwriting existing files
•Always specify encoding='utf-8' for text files
•'rb'/'wb' for binary files (images, audio, etc.)

Gotchas

•'w' mode silently destroys existing file contents!
•Default encoding varies by OS -- always specify utf-8
•'r+' requires file to exist; 'w+' creates but truncates
•Binary mode returns bytes, text mode returns str

'r' read, 'w' write (truncates!), 'a' append, 'x' exclusive create. Add 'b' for binary, '+' for read+write. Always specify encoding='utf-8'.

•'w' truncates, 'a' appends, 'x' exclusive create
•Always specify encoding for text files

# Write (creates or truncates)
with open("file.txt", "w", encoding="utf-8") as f:
    f.write("Hello\n")

# Read
with open("file.txt", "r", encoding="utf-8") as f:
    print(f.read())

# Append
with open("file.txt", "a", encoding="utf-8") as f:
    f.write("More\n")

# Binary
with open("image.png", "rb") as f:
    data = f.read()  # bytes

'w' silently destroys existing content

Question 2 / 12

How do you create custom context managers using `enter` and `exit`?

Custom context managers implement the context manager protocol: __enter__ (setup) and __exit__ (cleanup). The with statement calls __enter__ on entry, binds the return value to as, and guarantees __exit__ on exit.

__exit__ receives three arguments for exception info: exc_type, exc_val, exc_tb. All are None if no exception occurred. Return True to suppress an exception, False/None to propagate it.

Alternatively, use @contextlib.contextmanager to create context managers with a simpler generator-based syntax: code before yield is __enter__, code after yield is __exit__.

Pseudo Code

Class-based:
  __enter__(self) -> return resource (bound to 'as')
  __exit__(self, exc_type, exc_val, exc_tb) -> cleanup
    return True to suppress exception
    return False/None to propagate

Generator-based (@contextmanager):
  setup code
  yield value  (the 'as' value)
  cleanup code

Code

import time
from contextlib import contextmanager

# Class-based context manager
class DatabaseConnection:
    def __init__(self, connection_string):
        self.connection_string = connection_string
        self.connection = None

    def __enter__(self):
        print(f"Connecting to {self.connection_string}")
        self.connection = {"status": "connected"}  # simulate
        return self.connection

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Closing connection")
        self.connection = None
        if exc_type is not None:
            print(f"Error during operation: {exc_val}")
        return False  # don't suppress exceptions

with DatabaseConnection("sqlite:///app.db") as conn:
    print(f"Status: {conn['status']}")
# Connecting to sqlite:///app.db
# Status: connected
# Closing connection

# Generator-based context manager (simpler)
@contextmanager
def timer(label="Operation"):
    start = time.perf_counter()
    try:
        yield  # code inside 'with' runs here
    finally:
        elapsed = time.perf_counter() - start
        print(f"{label}: {elapsed:.4f}s")

with timer("Sorting"):
    sorted(range(100_000, 0, -1))
# Sorting: 0.0087s

# Generator-based with value
@contextmanager
def temp_file(path, mode="w", encoding="utf-8"):
    import os
    f = open(path, mode, encoding=encoding)
    try:
        yield f
    finally:
        f.close()
        os.remove(path)  # cleanup: delete temp file

with temp_file("/tmp/scratch.txt") as f:
    f.write("temporary data")
# File is closed and deleted after the block

# Reentrant context manager
class IndentPrinter:
    def __init__(self):
        self.level = 0

    def __enter__(self):
        self.level += 1
        return self

    def __exit__(self, *args):
        self.level -= 1
        return False

    def print(self, msg):
        print("  " * self.level + msg)

printer = IndentPrinter()
with printer:
    printer.print("Level 1")
    with printer:
        printer.print("Level 2")
        with printer:
            printer.print("Level 3")
    printer.print("Back to 1")
#   Level 1
#     Level 2
#       Level 3
#   Back to 1

Connecting to sqlite:///app.db
Status: connected
Closing connection
Sorting: 0.0010s
Level 1
Level 2
Level 3
Back to 1

Key Points

•__enter__ returns the resource, __exit__ cleans up
•@contextmanager simplifies creation with yield-based syntax
•finally in @contextmanager ensures cleanup even on exceptions
•__exit__ return True to suppress exceptions, False to propagate

Gotchas

•@contextmanager must have exactly one yield
•Without try/finally in @contextmanager, cleanup code won't run on exceptions
•If __enter__ raises, __exit__ is NOT called
•__exit__ exception suppression (return True) is powerful but dangerous

Class: __enter__ returns resource, __exit__ cleans up. Generator: @contextmanager with yield separating setup/cleanup. Use try/finally to ensure cleanup in generators.

•@contextmanager with yield for simple context managers
•try/finally ensures cleanup on exceptions

from contextlib import contextmanager

@contextmanager
def managed(name):
    print(f"Setup {name}")
    try:
        yield name
    finally:
        print(f"Cleanup {name}")

with managed("resource") as r:
    print(f"Using {r}")
# Setup resource -> Using resource -> Cleanup resource

Setup resource
Using resource
Cleanup resource

Without try/finally, cleanup skipped on exceptions

Question 3 / 12

How do you use `contextlib` utilities for context management?

The contextlib module provides several utilities for working with context managers:

@contextmanager: Create context managers from generators
suppress(*exceptions): Suppress specific exceptions cleanly
ExitStack: Manage a dynamic number of context managers
redirect_stdout/redirect_stderr: Redirect output streams
closing(obj): Wraps objects with .close() method
nullcontext(value): No-op context manager (placeholder)
AbstractContextManager: ABC for context managers
AsyncExitStack: Async version of ExitStack

Pseudo Code

suppress(Error) -- replaces try/except/pass
ExitStack -- dynamic number of context managers
closing(obj) -- auto-close objects with .close()
nullcontext() -- placeholder when context manager is optional
redirect_stdout(f) -- capture print output

Code

from contextlib import (
    suppress, ExitStack, closing, nullcontext,
    redirect_stdout, contextmanager
)
import io
import os

# suppress -- clean exception suppression
with suppress(FileNotFoundError, PermissionError):
    os.remove("/tmp/nonexistent_file")
# No exception, no try/except needed

# ExitStack -- dynamic context managers
def process_files(paths):
    with ExitStack() as stack:
        files = []
        for path in paths:
            f = stack.enter_context(open(path, encoding="utf-8"))
            files.append(f)
        # All files are open here
        return [f.read() for f in files]
    # All files automatically closed, even if one fails

# ExitStack with callbacks
with ExitStack() as stack:
    stack.callback(print, "Third")   # LIFO order
    stack.callback(print, "Second")
    stack.callback(print, "First")
# Prints: First, Second, Third

# closing -- for objects with .close() but no __enter__/__exit__
class Connection:
    def close(self):
        print("Connection closed")

with closing(Connection()) as conn:
    print("Using connection")
# Using connection
# Connection closed

# redirect_stdout -- capture print output
f = io.StringIO()
with redirect_stdout(f):
    print("This goes to the buffer")
    print("So does this")

captured = f.getvalue()
print(f"Captured: {captured!r}")
# Captured: 'This goes to the buffer\nSo does this\n'

# nullcontext -- placeholder context manager
def process(data, lock=None):
    # Use lock if provided, otherwise no-op
    cm = lock if lock is not None else nullcontext()
    with cm:
        return sum(data)

import threading
result1 = process([1, 2, 3])  # no lock
result2 = process([1, 2, 3], lock=threading.Lock())  # with lock

# Combining: ExitStack with conditionals
def open_maybe(path):
    """Open file or return stdin."""
    stack = ExitStack()
    if path:
        f = stack.enter_context(open(path, encoding="utf-8"))
    else:
        import sys
        f = sys.stdin
    return stack, f

First
Second
Third
Using connection
Connection closed
Captured: 'This goes to the buffer\nSo does this\n'

Key Points

•suppress() replaces try/except/pass cleanly
•ExitStack manages dynamic numbers of context managers
•closing() wraps objects with .close() method
•nullcontext() is a no-op placeholder for optional context managers

Gotchas

•ExitStack callbacks run in LIFO (reverse) order
•suppress() swallows the entire exception -- use carefully
•redirect_stdout only captures print(), not direct sys.stdout.write() in subprocesses
•ExitStack.enter_context() returns the context manager's __enter__ result

suppress() for clean exception suppression, ExitStack for dynamic context managers, closing() for objects with .close(), nullcontext() as a no-op placeholder.

•suppress for try/except/pass replacement
•ExitStack for dynamic context managers

from contextlib import suppress, ExitStack, closing

# Clean suppression
with suppress(FileNotFoundError):
    import os
    os.remove("/nonexistent")

# Dynamic context managers
with ExitStack() as stack:
    files = [stack.enter_context(open(p)) for p in paths]

ExitStack callbacks run in LIFO order

Question 4 / 12

How do you use `pathlib.Path` for file operations?

pathlib.Path (Python 3.4+) provides an object-oriented interface for file system paths, replacing many os.path functions. It's the modern, Pythonic way to work with paths.

Advantages over os.path:

Object-oriented: path / 'subdir' / 'file.txt' instead of os.path.join()
Methods for common operations: .read_text(), .write_text(), .exists(), .mkdir()
Platform-independent: handles Windows and Unix paths correctly
Rich API: glob patterns, suffix manipulation, parent directories

Pseudo Code

Path operations:
  Path('dir') / 'file.txt'  -- join paths
  path.read_text()          -- read file
  path.write_text('data')   -- write file
  path.exists()             -- check existence
  path.mkdir(parents=True)  -- create directories
  path.glob('*.py')         -- find files
  path.stem, path.suffix    -- name parts

Code

from pathlib import Path

# Creating paths
p = Path("/tmp/myproject")
config = p / "config" / "settings.json"  # operator / joins paths
print(config)  # /tmp/myproject/config/settings.json

# Path components
print(config.name)     # settings.json
print(config.stem)     # settings
print(config.suffix)   # .json
print(config.parent)   # /tmp/myproject/config
print(config.parents[1])  # /tmp/myproject
print(config.parts)    # ('/', 'tmp', 'myproject', 'config', 'settings.json')

# Create directories
p.mkdir(parents=True, exist_ok=True)

# Write and read text files
file_path = p / "hello.txt"
file_path.write_text("Hello, World!\n", encoding="utf-8")
content = file_path.read_text(encoding="utf-8")
print(content)  # Hello, World!

# Write and read binary files
bin_path = p / "data.bin"
bin_path.write_bytes(b"\x00\x01\x02")
data = bin_path.read_bytes()
print(data)  # b'\x00\x01\x02'

# File checks
print(file_path.exists())      # True
print(file_path.is_file())     # True
print(p.is_dir())              # True
print(file_path.stat().st_size)  # file size in bytes

# Glob patterns
(p / "src").mkdir(exist_ok=True)
(p / "src" / "main.py").write_text("# main", encoding="utf-8")
(p / "src" / "utils.py").write_text("# utils", encoding="utf-8")

for py_file in p.glob("**/*.py"):  # recursive
    print(py_file)

# Path manipulation
original = Path("report.txt")
backup = original.with_suffix(".bak")      # report.bak
versioned = original.with_stem("report_v2")  # report_v2.txt (Python 3.9+)

# Convert to/from strings
str_path = str(file_path)  # "/tmp/myproject/hello.txt"
path_obj = Path(str_path)  # back to Path

# Home directory and current directory
home = Path.home()     # /Users/username
cwd = Path.cwd()       # current working directory

# Iterate directory contents
for item in p.iterdir():
    kind = "dir" if item.is_dir() else "file"
    print(f"{kind}: {item.name}")

# Cleanup
import shutil
shutil.rmtree(p)

/tmp/myproject/config/settings.json
settings.json
settings
.json
/tmp/myproject/config
/tmp/myproject
('/', 'tmp', 'myproject', 'config', 'settings.json')
Hello, World!

b'\x00\x01\x02'
True
True
True
14
/tmp/myproject/src/utils.py
/tmp/myproject/src/main.py
file: hello.txt
file: data.bin
dir: src

Key Points

•Use / operator to join paths: Path('dir') / 'file.txt'
•.read_text() and .write_text() for simple file I/O
•.glob('**/*.py') for recursive pattern matching
•.stem, .suffix, .parent for path component access

Gotchas

•Some libraries don't accept Path objects (use str(path) to convert)
•.read_text() reads entire file into memory -- not for large files
•.mkdir() without parents=True fails if parent directories don't exist
•.write_text() overwrites without warning (like 'w' mode)

pathlib.Path provides OOP file operations. Use / to join paths, .read_text()/.write_text() for I/O, .glob() for finding files, and .exists()/.is_file() for checks.

•/ operator joins paths
•.read_text()/.write_text() for simple I/O

from pathlib import Path

p = Path("/tmp") / "data" / "file.txt"
p.parent.mkdir(parents=True, exist_ok=True)
p.write_text("Hello!", encoding="utf-8")
print(p.read_text(encoding="utf-8"))  # Hello!
print(p.stem)    # file
print(p.suffix)  # .txt

Hello!
file
.txt

Some libraries need str(path) conversion

Question 5 / 12

How do you read and write CSV files in Python?

Python's csv module handles CSV reading and writing, properly handling edge cases like commas in fields, quoting, and different dialects.

Key classes:

csv.reader: Returns rows as lists of strings
csv.writer: Writes lists as CSV rows
csv.DictReader: Returns rows as dictionaries (using header as keys)
csv.DictWriter: Writes dictionaries as CSV rows

DictReader/DictWriter are preferred for most use cases because they use column names instead of indices, making code more readable and robust against column reordering.

Important: Open CSV files with newline='' to prevent double newlines on Windows.

Pseudo Code

Reading:
  csv.reader(file) -> lists of strings
  csv.DictReader(file) -> dicts with header keys

Writing:
  csv.writer(file).writerow([values])
  csv.DictWriter(file, fieldnames).writerow({dict})

Always: open(path, newline='', encoding='utf-8')

Code

import csv
import os

path = "/tmp/people.csv"

# Write CSV with csv.writer
with open(path, "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["name", "age", "city"])  # header
    writer.writerow(["Alice", 30, "New York"])
    writer.writerow(["Bob", 25, "San Francisco"])
    writer.writerow(["Charlie, Jr.", 35, "Chicago"])  # comma in name handled

# Read CSV with csv.reader
with open(path, "r", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    header = next(reader)  # skip header
    for row in reader:
        print(f"{row[0]} is {row[1]} from {row[2]}")
# Alice is 30 from New York
# Bob is 25 from San Francisco
# Charlie, Jr. is 35 from Chicago

# Write with DictWriter (preferred)
people = [
    {"name": "Diana", "age": 28, "city": "Boston"},
    {"name": "Eve", "age": 32, "city": "Denver"},
]

with open(path, "w", newline="", encoding="utf-8") as f:
    fieldnames = ["name", "age", "city"]
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerows(people)

# Read with DictReader (preferred)
with open(path, "r", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['name']} ({row['age']}) - {row['city']}")
# Diana (28) - Boston
# Eve (32) - Denver

# Custom delimiter (TSV)
with open("/tmp/data.tsv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f, delimiter="\t")
    writer.writerow(["name", "score"])
    writer.writerow(["Alice", 95])

# Reading with different dialects
with open("/tmp/data.tsv", "r", newline="", encoding="utf-8") as f:
    reader = csv.reader(f, delimiter="\t")
    for row in reader:
        print(row)

# Cleanup
os.remove(path)
os.remove("/tmp/data.tsv")

Alice is 30 from New York
Bob is 25 from San Francisco
Charlie, Jr. is 35 from Chicago
Diana (28) - Boston
Eve (32) - Denver
['name', 'score']
['Alice', '95']

Key Points

•DictReader/DictWriter for named column access (preferred)
•Always open with newline='' and encoding='utf-8'
•csv module handles quoting, escaping, and commas in fields
•Use delimiter parameter for TSV or other separators

Gotchas

•Without newline='', Windows adds extra blank lines between rows
•csv.reader returns strings -- numbers are not auto-converted
•DictWriter requires fieldnames even if writing from dicts
•Large CSV files should be processed row by row (iterator), not loaded entirely

Use csv.DictReader/DictWriter for named column access. Always open with newline='' and encoding='utf-8'. The csv module handles quoting and escaping automatically.

•DictReader/DictWriter for named columns
•newline='' prevents extra blank lines on Windows

import csv

# Write
with open("data.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "age"])
    writer.writeheader()
    writer.writerow({"name": "Alice", "age": 30})

# Read
with open("data.csv", "r", newline="", encoding="utf-8") as f:
    for row in csv.DictReader(f):
        print(row["name"], row["age"])

Alice 30

Values are always strings -- convert manually

Question 6 / 12

How do you read and write JSON files in Python?

Python's json module handles JSON serialization (Python objects to JSON) and deserialization (JSON to Python objects).

Key functions:

json.dump(obj, file): Write Python object to file as JSON
json.dumps(obj): Convert Python object to JSON string
json.load(file): Read JSON from file to Python object
json.loads(string): Parse JSON string to Python object

Type mapping: dict <-> object, list <-> array, str <-> string, int/float <-> number, True/False <-> true/false, None <-> null.

For custom objects, use the default parameter in dump/dumps or a custom JSONEncoder. For deserialization, use object_hook in load/loads.

Pseudo Code

Write: json.dump(obj, file) or json.dumps(obj) -> string
Read:  json.load(file) or json.loads(string) -> Python object

Formatting: indent=2 for pretty-print
Custom types: default=str or custom encoder
Sorting keys: sort_keys=True

Code

import json
from datetime import datetime
from pathlib import Path

# Write JSON to file
data = {
    "name": "Alice",
    "age": 30,
    "scores": [95, 87, 92],
    "address": {"city": "New York", "state": "NY"},
    "active": True,
    "nickname": None
}

path = Path("/tmp/data.json")
with open(path, "w", encoding="utf-8") as f:
    json.dump(data, f, indent=2, ensure_ascii=False)

# Read JSON from file
with open(path, "r", encoding="utf-8") as f:
    loaded = json.load(f)
print(loaded["name"])     # Alice
print(loaded["scores"])   # [95, 87, 92]
print(type(loaded))       # <class 'dict'>

# JSON string conversion
json_str = json.dumps(data, indent=2, sort_keys=True)
print(json_str)

parsed = json.loads(json_str)
print(parsed == data)  # True

# Handling custom types with default
class User:
    def __init__(self, name, joined):
        self.name = name
        self.joined = joined

def custom_serializer(obj):
    if isinstance(obj, datetime):
        return obj.isoformat()
    if isinstance(obj, User):
        return {"name": obj.name, "joined": obj.joined.isoformat()}
    raise TypeError(f"Object of type {type(obj)} is not JSON serializable")

user = User("Bob", datetime(2024, 1, 15))
print(json.dumps(user, default=custom_serializer, indent=2))
# {"name": "Bob", "joined": "2024-01-15T00:00:00"}

# Custom deserialization with object_hook
def custom_deserializer(dct):
    if "joined" in dct:
        dct["joined"] = datetime.fromisoformat(dct["joined"])
    return dct

json_str = '{"name": "Bob", "joined": "2024-01-15T00:00:00"}'
result = json.loads(json_str, object_hook=custom_deserializer)
print(result["joined"])  # 2024-01-15 00:00:00
print(type(result["joined"]))  # <class 'datetime.datetime'>

# Pathlib shortcut
path.write_text(json.dumps(data, indent=2), encoding="utf-8")
loaded = json.loads(path.read_text(encoding="utf-8"))

# Cleanup
path.unlink()

Alice
[95, 87, 92]
<class 'dict'>
{
"active": true,
"address": {
"city": "New York",
"state": "NY"
},
"age": 30,
"name": "Alice",
"nickname": null,
"scores": [
95,
87,
92
]
}
True
{
"name": "Bob",
"joined": "2024-01-15T00:00:00"
}
2024-01-15 00:00:00
<class 'datetime.datetime'>

Key Points

•json.dump/load for files, json.dumps/loads for strings
•indent=2 for pretty-printed output
•default parameter handles custom types in serialization
•object_hook handles custom deserialization

Gotchas

•JSON keys must be strings -- int keys are converted to strings
•Tuples become arrays (lists) in JSON -- no round-trip preservation
•datetime, set, bytes are not JSON-serializable by default
•json.load reads entire file into memory -- not suitable for huge files

json.dump(obj, file) writes to file, json.load(file) reads. json.dumps/loads for strings. Use indent=2 for formatting, default for custom types.

•dump/load for files, dumps/loads for strings
•default parameter for custom types

import json

# Write
with open("data.json", "w", encoding="utf-8") as f:
    json.dump({"name": "Alice", "age": 30}, f, indent=2)

# Read
with open("data.json", "r", encoding="utf-8") as f:
    data = json.load(f)
print(data["name"])  # Alice

Alice

Tuples become lists, int keys become strings

Question 7 / 12

How does file encoding work in Python, and how do you handle encoding errors?

File encoding specifies how characters are mapped to bytes. UTF-8 is the most common encoding and should be your default choice.

Python 3 distinguishes between str (Unicode text) and bytes (raw binary). When reading text files, Python decodes bytes to str using the specified encoding. When writing, it encodes str to bytes.

The errors parameter in open() controls how encoding/decoding errors are handled:

'strict' (default): Raise UnicodeDecodeError/UnicodeEncodeError
'ignore': Skip problematic characters
'replace': Replace with ? (encoding) or \ufffd (decoding)
'backslashreplace': Replace with \xNN escape sequences
'xmlcharrefreplace': Replace with XML character references (encoding only)

Always specify encoding explicitly to avoid platform-dependent behavior.

Pseudo Code

1. Always specify encoding='utf-8' in open()
2. str = text (Unicode), bytes = raw binary
3. encode: str -> bytes, decode: bytes -> str
4. errors='strict' raises on problems (default)
5. errors='replace' substitutes problem characters

Code

# Always specify encoding
with open("/tmp/utf8.txt", "w", encoding="utf-8") as f:
    f.write("Hello!")

# Reading with wrong encoding
with open("/tmp/utf8.txt", "w", encoding="utf-8") as f:
    f.write("Caf\u00e9")  # e with accent

with open("/tmp/utf8.txt", "r", encoding="utf-8") as f:
    print(f.read())  # Cafe (correct)

# Handling encoding errors
import os

# Create a file with mixed encoding (simulate real-world mess)
with open("/tmp/mixed.txt", "wb") as f:
    f.write(b"Hello \xff\xfe World")  # invalid UTF-8 bytes

# strict (default) -- raises error
try:
    with open("/tmp/mixed.txt", "r", encoding="utf-8") as f:
        content = f.read()
except UnicodeDecodeError as e:
    print(f"Decode error: {e}")

# replace -- substitutes problem characters
with open("/tmp/mixed.txt", "r", encoding="utf-8", errors="replace") as f:
    content = f.read()
    print(content)  # Hello \ufffd\ufffd World

# ignore -- skips problem characters
with open("/tmp/mixed.txt", "r", encoding="utf-8", errors="ignore") as f:
    content = f.read()
    print(content)  # Hello  World

# Detecting encoding with chardet (third-party)
# pip install chardet
# import chardet
# with open("unknown.txt", "rb") as f:
#     result = chardet.detect(f.read())
#     print(result)  # {'encoding': 'utf-8', 'confidence': 0.99}

# Manual encode/decode
text = "Caf\u00e9"
encoded = text.encode("utf-8")
print(encoded)  # b'Caf\xc3\xa9'
print(len(text), len(encoded))  # 4, 5 (e-accent is 2 bytes in UTF-8)

decoded = encoded.decode("utf-8")
print(decoded)  # Cafe

# BOM handling (Windows files often have BOM)
with open("/tmp/bom.txt", "w", encoding="utf-8-sig") as f:
    f.write("Data with BOM")

# utf-8-sig strips BOM on read
with open("/tmp/bom.txt", "r", encoding="utf-8-sig") as f:
    print(f.read())  # Data with BOM (no BOM character)

# Cleanup
for p in ["/tmp/utf8.txt", "/tmp/mixed.txt", "/tmp/bom.txt"]:
    os.remove(p)

Café
Decode error: 'utf-8' codec can't decode byte 0xff in position 6: invalid start byte
Hello �� World
Hello  World
b'Caf\xc3\xa9'
4 5
Café
Data with BOM

Key Points

•Always specify encoding='utf-8' explicitly
•errors='replace' for tolerant reading, 'strict' for validation
•str is Unicode text, bytes is raw binary
•utf-8-sig handles BOM (Byte Order Mark) from Windows files

Gotchas

•Default encoding varies by platform -- always specify explicitly
•UTF-8 characters can be 1-4 bytes -- len(str) != len(bytes)
•Reading binary files in text mode causes encoding errors
•'ignore' silently loses data -- use 'replace' to at least see something

Always use encoding='utf-8' with open(). Use errors='replace' for tolerant reading, 'strict' for validation. utf-8-sig handles Windows BOM files.

•Always specify encoding='utf-8'
•errors='replace' for tolerant reading

# Always specify encoding
with open("file.txt", "r", encoding="utf-8") as f:
    text = f.read()

# Handle encoding errors gracefully
with open("messy.txt", "r", encoding="utf-8", errors="replace") as f:
    text = f.read()  # bad chars become \ufffd

Default encoding varies by OS -- always specify

Question 8 / 12

How do file seeking and buffered I/O work in Python?

File seeking lets you move the read/write position within a file. seek(offset, whence) moves the position, and tell() returns the current position.

whence values:

0 (SEEK_SET): From file start (default)
1 (SEEK_CUR): From current position
2 (SEEK_END): From file end

Note: In text mode, only seek(0) and seek(tell()) are guaranteed to work. For arbitrary seeking, use binary mode.

Buffering controls how data is written to disk:

buffering=0: Unbuffered (binary only)
buffering=1: Line-buffered (text only)
buffering=-1: System default (usually 4KB or 8KB)
buffering=N: Buffer of N bytes

Buffers are flushed with .flush() or when the file is closed.

Pseudo Code

seek(offset, whence):
  whence=0: from start
  whence=1: from current (binary only)
  whence=2: from end (binary only)

tell() -> current position in bytes
flush() -> write buffer to disk
truncate() -> resize file at current position

Code

import os

# Basic seek and tell
path = "/tmp/seektest.txt"
with open(path, "w", encoding="utf-8") as f:
    f.write("Hello, World!")

with open(path, "r", encoding="utf-8") as f:
    print(f.tell())    # 0 (start of file)
    print(f.read(5))   # Hello
    print(f.tell())    # 5
    f.seek(0)          # go back to start
    print(f.read())    # Hello, World!

# Binary mode allows all seek operations
with open(path, "rb") as f:
    f.seek(0, 2)       # seek to end
    size = f.tell()    # file size
    print(f"File size: {size}")  # 13

    f.seek(-6, 2)      # 6 bytes before end
    print(f.read())    # b'World!'

    f.seek(7, 0)       # 7 bytes from start
    print(f.read(5))   # b'World'

# Read + Write with seek
with open(path, "r+", encoding="utf-8") as f:
    content = f.read()
    f.seek(0)                    # go back to start
    f.write(content.upper())     # overwrite with uppercase

with open(path, "r", encoding="utf-8") as f:
    print(f.read())  # HELLO, WORLD!

# Truncate -- resize file
with open(path, "r+", encoding="utf-8") as f:
    f.truncate(5)  # keep only first 5 bytes

with open(path, "r", encoding="utf-8") as f:
    print(f.read())  # HELLO

# Buffering demonstration
import io

# Line-buffered: flushes on newline
with open(path, "w", encoding="utf-8", buffering=1) as f:
    f.write("line 1\n")  # flushed immediately (newline)
    f.write("partial")    # NOT flushed until close or explicit flush
    f.flush()              # force flush

# Reading large files efficiently
def read_in_chunks(path, chunk_size=8192):
    with open(path, "rb") as f:
        while True:
            chunk = f.read(chunk_size)
            if not chunk:
                break
            yield chunk

# Tail-like: read last N bytes
def tail_bytes(path, n=100):
    with open(path, "rb") as f:
        f.seek(0, 2)      # seek to end
        size = f.tell()
        f.seek(max(0, size - n))  # seek to N bytes before end
        return f.read()

print(tail_bytes(path, 3))  # b'LLO'

os.remove(path)

0
Hello
5
Hello, World!
File size: 13
b'World!'
b'World'
HELLO, WORLD!
HELLO
b'ial'

Key Points

•seek(offset, whence) moves file position; tell() returns it
•Text mode only supports seek(0) reliably; use binary for arbitrary seeking
•buffering=1 is line-buffered; flush() forces writes to disk
•Read large files in chunks to avoid memory issues

Gotchas

•Text mode seek with non-zero whence or arbitrary offsets may fail
•tell() returns bytes in binary, characters in text (but implementation varies)
•Unflushed data is lost if the process crashes before close()
•seek() past end of file followed by write creates sparse files

seek(offset, whence) moves the file pointer. tell() returns current position. Use binary mode for arbitrary seeking. flush() forces buffered data to disk.

•seek(0, 2) goes to end; tell() gives position
•Binary mode for arbitrary seeking

with open("file.txt", "rb") as f:
    f.seek(0, 2)       # go to end
    size = f.tell()    # file size
    f.seek(-10, 2)     # 10 bytes from end
    tail = f.read()    # last 10 bytes

Text mode only supports seek(0) reliably

Question 9 / 12

How do you use the `tempfile` module for temporary files and directories?

The tempfile module creates temporary files and directories that are automatically cleaned up. Key functions:

TemporaryFile(): Creates a temp file that's deleted when closed. Not accessible by name on some OS.
NamedTemporaryFile(): Like TemporaryFile but has a .name attribute. Use delete=False to keep after closing.
TemporaryDirectory(): Creates a temp directory, deleted when the context exits.
mkstemp(): Creates a temp file, returns (fd, path). Caller must clean up.
mkdtemp(): Creates a temp directory. Caller must clean up.
gettempdir(): Returns the system temp directory.

Always prefer the context manager forms (NamedTemporaryFile, TemporaryDirectory) for automatic cleanup.

Pseudo Code

TemporaryFile() -- deleted on close, no name
NamedTemporaryFile() -- deleted on close, has .name
TemporaryDirectory() -- deleted on __exit__
mkstemp() -> (fd, path) -- manual cleanup
mkdtemp() -> path -- manual cleanup

Code

import tempfile
import os

# TemporaryFile -- auto-deleted, no visible name
with tempfile.TemporaryFile(mode="w+", encoding="utf-8") as f:
    f.write("temporary data")
    f.seek(0)
    print(f.read())  # temporary data
# File is deleted here

# NamedTemporaryFile -- has a name, auto-deleted
with tempfile.NamedTemporaryFile(
    mode="w", suffix=".txt", prefix="myapp_",
    encoding="utf-8", delete=True
) as f:
    print(f.name)  # /tmp/myapp_abc123.txt
    f.write("named temp data")
    f.flush()
    # File exists and can be accessed by name here
print(os.path.exists(f.name))  # False -- deleted

# NamedTemporaryFile with delete=False -- keep the file
with tempfile.NamedTemporaryFile(
    mode="w", suffix=".csv", delete=False, encoding="utf-8"
) as f:
    f.write("col1,col2\n1,2\n")
    temp_path = f.name

print(os.path.exists(temp_path))  # True -- not deleted
os.remove(temp_path)  # manual cleanup

# TemporaryDirectory -- auto-deleted directory
with tempfile.TemporaryDirectory(prefix="work_") as tmpdir:
    print(tmpdir)  # /tmp/work_abc123
    # Create files in the temp directory
    file_path = os.path.join(tmpdir, "data.txt")
    with open(file_path, "w", encoding="utf-8") as f:
        f.write("temp data")
    print(os.path.exists(file_path))  # True
print(os.path.exists(tmpdir))  # False -- entire directory deleted

# mkstemp and mkdtemp -- low-level, manual cleanup
fd, path = tempfile.mkstemp(suffix=".dat")
try:
    with os.fdopen(fd, "w", encoding="utf-8") as f:
        f.write("low-level temp")
    # Process the file
finally:
    os.remove(path)  # must clean up manually

tmp_dir = tempfile.mkdtemp()
try:
    # Use the directory
    pass
finally:
    import shutil
    shutil.rmtree(tmp_dir)  # must clean up manually

# Get the system temp directory
print(tempfile.gettempdir())  # /tmp or C:\Users\...\Temp

# SpooledTemporaryFile -- in-memory until size threshold
with tempfile.SpooledTemporaryFile(
    max_size=1024, mode="w+", encoding="utf-8"
) as f:
    f.write("small data")  # stays in memory
    f.seek(0)
    print(f.read())

temporary data
/var/folders/qz/99sz9qnd1gld4tqq0rgyd41m0000gn/T/myapp_yon4qz2n.txt
False
True
/var/folders/qz/99sz9qnd1gld4tqq0rgyd41m0000gn/T/work_czroluw0
True
False
/var/folders/qz/99sz9qnd1gld4tqq0rgyd41m0000gn/T
small data

Key Points

•NamedTemporaryFile for temp files with names, auto-deleted on close
•TemporaryDirectory for temp dirs, auto-deleted on context exit
•Use delete=False to keep the file after closing
•mkstemp/mkdtemp for low-level control (manual cleanup required)

Gotchas

•NamedTemporaryFile on Windows can't be opened by another process while open
•mkstemp returns a file descriptor (int), not a file object -- use os.fdopen()
•mkstemp/mkdtemp require manual cleanup (os.remove/shutil.rmtree)
•SpooledTemporaryFile writes to disk when exceeding max_size

NamedTemporaryFile creates auto-deleting temp files with names. TemporaryDirectory creates auto-deleting temp dirs. Use delete=False to keep files after closing.

•NamedTemporaryFile and TemporaryDirectory auto-cleanup
•delete=False to keep temp files

import tempfile

# Auto-deleted temp file
with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", encoding="utf-8") as f:
    f.write("temp data")
    print(f.name)  # /tmp/tmp_abc123.txt

# Auto-deleted temp directory
with tempfile.TemporaryDirectory() as tmpdir:
    print(tmpdir)  # /tmp/tmp_xyz789

/var/folders/qz/99sz9qnd1gld4tqq0rgyd41m0000gn/T/tmptrtjevs2.txt
/var/folders/qz/99sz9qnd1gld4tqq0rgyd41m0000gn/T/tmp18qsqg1o

NamedTemporaryFile on Windows can't be opened by other processes

Question 10 / 12

What is the `with` statement and why should you always use it for files?

The with statement guarantees that resources are properly cleaned up after use, even if exceptions occur. For files, it ensures the file is closed regardless of what happens inside the block.

Without with, you need explicit try/finally to ensure cleanup. with makes this automatic and less error-prone.

The with statement works with any object implementing the context manager protocol (__enter__ and __exit__). Files, database connections, locks, and network sockets all support it.

Python 3.1+ supports multiple context managers in a single with statement, and Python 3.10+ supports parenthesized syntax for cleaner multi-line with.

Pseudo Code

Without with (error-prone):
  f = open('file')
  try:
      data = f.read()
  finally:
      f.close()  # must remember!

With with (safe):
  with open('file') as f:
      data = f.read()
  # f.close() called automatically

Code

# BAD: without with -- file might not be closed on exception
f = open("/tmp/test.txt", "w", encoding="utf-8")
f.write("data")
# If exception occurs here, f is never closed!
f.close()

# GOOD: with statement guarantees close
with open("/tmp/test.txt", "w", encoding="utf-8") as f:
    f.write("data")
    # Even if exception here, file is closed

# File is closed after the block
print(f.closed)  # True

# Multiple context managers
with open("/tmp/input.txt", "w", encoding="utf-8") as f:
    f.write("hello")

with (open("/tmp/input.txt", "r", encoding="utf-8") as fin,
      open("/tmp/output.txt", "w", encoding="utf-8") as fout):
    fout.write(fin.read().upper())

with open("/tmp/output.txt", "r", encoding="utf-8") as f:
    print(f.read())  # HELLO

# Equivalent try/finally (what with does internally)
f = open("/tmp/test.txt", "r", encoding="utf-8")
try:
    data = f.read()
finally:
    f.close()  # always runs

# Why it matters: resource leaks
import os

# This leaks file descriptors in a loop
# for i in range(100000):
#     f = open("file.txt")  # never closed!
#     data = f.read()
# Eventually: OSError: Too many open files

# Safe version
for i in range(100):
    with open("/tmp/test.txt", "r", encoding="utf-8") as f:
        data = f.read()  # closed each iteration

# Nested with statements
with open("/tmp/test.txt", "r", encoding="utf-8") as f:
    with open("/tmp/copy.txt", "w", encoding="utf-8") as out:
        out.write(f.read())

# Cleanup
for p in ["/tmp/test.txt", "/tmp/input.txt", "/tmp/output.txt", "/tmp/copy.txt"]:
    os.remove(p)

True
HELLO

Key Points

•with guarantees file.close() even on exceptions
•Prevents resource leaks (file descriptors, connections)
•Multiple context managers in one with statement
•Always use with for files -- never manually open/close

Gotchas

•The file object is still accessible after the with block, but it's closed
•Writing to a closed file raises ValueError
•with doesn't create a new scope -- variables defined inside are accessible outside
•Forgetting with in loops causes 'Too many open files' errors

with guarantees file cleanup (.close()) even on exceptions. Always use it for files. Prevents resource leaks and "Too many open files" errors.

•Guarantees cleanup on exceptions
•Prevents resource leaks

# Always use with for files
with open("file.txt", "r", encoding="utf-8") as f:
    data = f.read()
# f is automatically closed here, even if exception occurred

# Multiple files
with open("in.txt") as fin, open("out.txt", "w") as fout:
    fout.write(fin.read())

File is closed after with, but variable still exists

Question 11 / 12

How do you read large files efficiently without loading them entirely into memory?

Reading entire large files into memory with .read() or .readlines() can cause MemoryError. Instead, process files line by line or in chunks.

Strategies for large files:

Line iteration: for line in file -- reads one line at a time (text files)
Chunk reading: file.read(chunk_size) -- reads fixed-size blocks (binary files)
mmap: Memory-mapped files for random access without loading entirely
Generator/iterator: Process lazily, yielding results
Specific libraries: pandas read_csv(chunksize=N) for large CSVs

Pseudo Code

Line by line (text):
  for line in file: process(line)

Chunks (binary):
  while chunk := file.read(8192): process(chunk)

mmap (random access):
  with mmap.mmap(f.fileno(), 0) as mm: mm[start:end]

Key: never use .read() or .readlines() on large files

Code

import os
import mmap

# Create a test file
path = "/tmp/large_test.txt"
with open(path, "w", encoding="utf-8") as f:
    for i in range(100_000):
        f.write(f"Line {i}: some data here\n")

print(f"File size: {os.path.getsize(path) / 1024 / 1024:.1f} MB")

# BAD: reads entire file into memory
# with open(path) as f:
#     content = f.read()  # all in memory!
#     lines = content.split('\n')  # doubles memory!

# GOOD: iterate line by line (memory efficient)
line_count = 0
with open(path, "r", encoding="utf-8") as f:
    for line in f:  # reads one line at a time
        line_count += 1
print(f"Lines: {line_count}")

# GOOD: process in chunks (for binary or when lines don't matter)
def count_bytes(path, chunk_size=8192):
    total = 0
    with open(path, "rb") as f:
        while True:
            chunk = f.read(chunk_size)
            if not chunk:
                break
            total += len(chunk)
    return total

# Python 3.8+ walrus operator version
def count_bytes_walrus(path, chunk_size=8192):
    total = 0
    with open(path, "rb") as f:
        while chunk := f.read(chunk_size):
            total += len(chunk)
    return total

print(f"Bytes: {count_bytes(path)}")

# GOOD: generator for lazy processing
def search_lines(path, pattern):
    with open(path, "r", encoding="utf-8") as f:
        for line_num, line in enumerate(f, 1):
            if pattern in line:
                yield line_num, line.rstrip()

# Only processes lines as needed
for num, line in search_lines(path, "Line 99999"):
    print(f"{num}: {line}")
    break  # stop after first match -- file not fully read

# Memory-mapped file for random access
with open(path, "r", encoding="utf-8") as f:
    with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
        # Find pattern without loading entire file
        pos = mm.find(b"Line 50000")
        if pos != -1:
            mm.seek(pos)
            print(mm.readline().decode())  # Line 50000: some data here

# Counting specific lines efficiently
def count_matching(path, predicate):
    count = 0
    with open(path, "r", encoding="utf-8") as f:
        count = sum(1 for line in f if predicate(line))
    return count

matches = count_matching(path, lambda l: "999" in l)
print(f"Lines containing '999': {matches}")

os.remove(path)

File size: 2.6 MB
Lines: 100000
Bytes: 2688890
100000: Line 99999: some data here
Line 50000: some data here

Lines containing '999': 280

Key Points

•for line in file iterates one line at a time (memory efficient)
•file.read(chunk_size) for binary chunk processing
•mmap for random access without loading entire file
•Never use .read() or .readlines() on large files

Gotchas

•.readlines() loads ALL lines into memory as a list
•Line iteration buffers internally but only exposes one line at a time
•mmap may not work on files larger than available address space (32-bit systems)
•Generator-based processing can't easily go backward -- it's forward-only

Use for line in file for line-by-line reading. Use file.read(chunk_size) for binary chunks. Never use .read() or .readlines() on large files.

•for line in file = one line at a time
•read(chunk_size) for binary processing

# Line by line (memory efficient)
with open("huge.txt", "r", encoding="utf-8") as f:
    for line in f:
        process(line)  # one line in memory at a time

# Binary chunks
with open("huge.bin", "rb") as f:
    while chunk := f.read(8192):
        process(chunk)

.readlines() loads everything into memory

Question 12 / 12

How does `os.path` compare to `pathlib`, and when would you use each?

os.path is the traditional string-based path manipulation module. pathlib.Path (Python 3.4+) is the modern object-oriented replacement.

Prefer pathlib for:

New code (it's the modern standard)
Path manipulation (joining, splitting, suffix handling)
File operations (read, write, exists, mkdir)
Cleaner, more readable code

Use os.path when:

Working with legacy code
Libraries that don't accept Path objects (use str(path) to convert)
You need functions not yet in pathlib (rare)

Most os.path functions have pathlib equivalents. The / operator in pathlib replaces os.path.join(), making path construction much more readable.

Pseudo Code

os.path equivalents in pathlib:
  os.path.join(a, b)     -> Path(a) / b
  os.path.exists(p)      -> Path(p).exists()
  os.path.isfile(p)      -> Path(p).is_file()
  os.path.basename(p)    -> Path(p).name
  os.path.dirname(p)     -> Path(p).parent
  os.path.splitext(p)    -> Path(p).stem, Path(p).suffix
  os.path.expanduser('~') -> Path.home()
  os.path.abspath(p)     -> Path(p).resolve()

Code

import os
from pathlib import Path

# Path joining
# os.path
old = os.path.join("/tmp", "project", "data", "file.txt")
# pathlib
new = Path("/tmp") / "project" / "data" / "file.txt"
print(old == str(new))  # True

# File existence
# os.path
print(os.path.exists("/tmp"))  # True
# pathlib
print(Path("/tmp").exists())   # True

# Path components
p = Path("/tmp/project/data/report.csv")

# os.path way
print(os.path.basename("/tmp/project/data/report.csv"))  # report.csv
print(os.path.dirname("/tmp/project/data/report.csv"))   # /tmp/project/data
name, ext = os.path.splitext("/tmp/project/data/report.csv")
print(name, ext)  # /tmp/project/data/report .csv

# pathlib way (cleaner)
print(p.name)    # report.csv
print(p.parent)  # /tmp/project/data
print(p.stem)    # report
print(p.suffix)  # .csv
print(p.parts)   # ('/', 'tmp', 'project', 'data', 'report.csv')

# File operations
# os way
os.makedirs("/tmp/test_dir/sub", exist_ok=True)
with open("/tmp/test_dir/sub/file.txt", "w") as f:
    f.write("hello")

# pathlib way (much cleaner)
base = Path("/tmp/test_dir2/sub")
base.mkdir(parents=True, exist_ok=True)
(base / "file.txt").write_text("hello", encoding="utf-8")

# Glob
# os + glob
import glob
for f in glob.glob("/tmp/test_dir/**/*.txt", recursive=True):
    print(f)

# pathlib
for f in Path("/tmp/test_dir").glob("**/*.txt"):
    print(f)

# Converting between them
path_obj = Path("/tmp/file.txt")
str_path = str(path_obj)         # Path -> str
path_back = Path(str_path)       # str -> Path
os_path = os.fspath(path_obj)    # Path -> os-compatible string

# Resolve (absolute path)
relative = Path("../file.txt")
absolute = relative.resolve()
print(absolute)

# Cleanup
import shutil
shutil.rmtree("/tmp/test_dir", ignore_errors=True)
shutil.rmtree("/tmp/test_dir2", ignore_errors=True)

True
True
True
report.csv
/tmp/project/data
/tmp/project/data/report .csv
report.csv
/tmp/project/data
report
.csv
('/', 'tmp', 'project', 'data', 'report.csv')
/tmp/test_dir/sub/file.txt
/tmp/test_dir/sub/file.txt
/Users/prakersh/projects/file.txt

Key Points

•pathlib is modern and Pythonic; os.path is legacy
•/ operator replaces os.path.join()
•.read_text()/.write_text() replace open()/read()/write()/close()
•str(Path) converts for libraries that need string paths

Gotchas

•Some older libraries don't accept Path objects -- use str() to convert
•os.path returns strings, pathlib returns Path objects
•Path.resolve() may behave differently than os.path.abspath() for symlinks
•pathlib.Path is slightly slower than os.path for high-volume path operations

pathlib.Path is modern and OOP. os.path is legacy string-based. Prefer pathlib for new code. Use str(path) when libraries need strings.

•pathlib: OOP, / operator, .stem/.suffix
•os.path: legacy, string-based

from pathlib import Path

# pathlib (modern)
p = Path("/tmp") / "dir" / "file.txt"
print(p.stem)    # file
print(p.suffix)  # .txt
print(p.parent)  # /tmp/dir

# os.path (legacy)
import os
print(os.path.join("/tmp", "dir", "file.txt"))

file
.txt
/tmp/dir
/tmp/dir/file.txt

Use str(Path) for libraries that need strings

Built by onllm.dev

Home GitHub Support awesomePrep

What are the different file modes in Python's `open()` function?

How do you create custom context managers using `__enter__` and `__exit__`?

How do you use `contextlib` utilities for context management?

How do you use `pathlib.Path` for file operations?

How do you read and write CSV files in Python?

How do you read and write JSON files in Python?

How does file encoding work in Python, and how do you handle encoding errors?

How do file seeking and buffered I/O work in Python?

How do you use the `tempfile` module for temporary files and directories?

What is the `with` statement and why should you always use it for files?

How do you read large files efficiently without loading them entirely into memory?

How does `os.path` compare to `pathlib`, and when would you use each?

File I/O & Context Managers

How do you create custom context managers using `enter` and `exit`?