Python Standard Library Modules -

Interview Ready Guide

Likely interview questions, model answers, class map, and memorable examples

Precision note: In everyday conversation, people often say built-in modules. The more
precise term is Python standard library modules. This handbook focuses on the modules and
classes that show up most often in modern scripts, backend services, automation, data
handling, testing, and DevOps work.

How to use this guide

• Read the module snapshot first to learn what the module solves and which classes
interviewers expect you to recognize.
• Use the interview angles and model questions to practice speaking clearly, not just writing
code.
• Memorize the code shape for common tasks such as path handling, JSON/CSV I/O, logging,
subprocess calls, and timezone-aware datetime work.

What interviewers usually test

Interview dimension What strong candidates say
Recognition Can you name the module, the important
classes, and the normal use case?
Trade-offs Can you explain why one tool is better than
another in a given situation?
Correctness Do you know the common pitfalls such as
naive datetimes, shell=True, or mutable
dataclass defaults?
Production thinking Can you connect the module to logging,
testing, debugging, and failure handling?

pathlib
pathlib
Modern, object-oriented path handling for files and folders.

Module snapshot Notes

Important classes / objects Path, PosixPath, WindowsPath, PurePath
Where it is used Automation scripts, backend file uploads,
config loading, report generation, cross-
platform tooling.
High-value concepts Path joining with /, name/stem/suffix,
exists/is_file/is_dir, mkdir, glob/rglob,
read_text/write_text.
Likely interview angles
• Why Path is preferred over manual string concatenation or [Link] in modern code.
• Difference between PurePath and Path.
• How to create repeatable output folders safely with mkdir(parents=True, exist_ok=True).
Example

from pathlib import Path

report_dir = Path('artifacts') / '2026-03-02'

report_dir.mkdir(parents=True, exist_ok=True)

json_path = report_dir / '[Link]'

json_path.write_text('{"status": "ok"}', encoding='utf-8')

print(json_path.exists())
print(json_path.suffix)

Pitfalls to remember
• Do not mix many raw string paths and Path objects in the same code path.
• Always choose an explicit encoding for text files.
• Use resolve() carefully if symlinks and deployment mounts matter.
Question Strong answer
Why do modern codebases prefer pathlib? Because Path objects are clearer, cross-
platform, and offer both path manipulation
and file operations in one API.
What is the difference between Path and Path can touch the real filesystem. PurePath
PurePath? only models path logic without file I/O.

os and sys
os and sys
Core operating-system and interpreter interfaces.

Module snapshot Notes

Important classes / objects [Link], [Link]; key objects:
[Link], [Link], [Link], [Link],
[Link]
Where it is used Environment-driven apps, CI/CD jobs, shell
integration, process exit control, path
scanning.
High-value concepts getenv/environ, [Link]/scandir, argv parsing
basics, [Link], stderr, platform/version
introspection.

Likely interview angles

• When to use [Link] versus hard-coded config.
• Why non-zero exit codes matter in automation.
 • Difference between os tasks and pathlib tasks.
Example

import os
import sys

env = [Link]('APP_ENV', 'dev')

if env not in {'dev', 'test', 'prod'}:

print('Invalid APP_ENV', file=[Link])
raise SystemExit(2)

print('running in', env)

Pitfalls to remember
• Environment variables arrive as strings; convert them explicitly.
• Use argparse instead of manual [Link] parsing for serious CLI tools.
Question Strong answer
What is [Link] used for? Reading environment-driven configuration
such as ports, tokens, or deployment
environment.
Why is [Link] important in automation? Exit codes are how calling tools detect
success or failure.

json and csv

json and csv
Data interchange for APIs, configs, imports, and exports.

Module snapshot Notes

Important classes / objects [Link], [Link];
[Link], [Link], reader, writer
Where it is used REST APIs, configuration files, ETL exports,
report downloads, spreadsheet imports.
High-value concepts load/loads, dump/dumps, schema awareness,
DictReader/DictWriter, newline='',
ensure_ascii, indentation.

Likely interview angles

• Difference between load and loads, dump and dumps.
• Why newline='' matters with csv on Windows.
• How to preserve column names during CSV processing.
Example

import csv
import json
from pathlib import Path

data = {"service": "billing", "retry_count": 3}

Path('[Link]').write_text([Link](data, indent=2), encoding='utf-8')
 rows = [{"id": 1, "status": "done"}, {"id": 2, "status": "queued"}]
with open('[Link]', 'w', newline='', encoding='utf-8') as f:
writer = [Link](f, fieldnames=['id', 'status'])
[Link]()
[Link](rows)

Pitfalls to remember
• JSON can only represent basic data types unless you customize encoding.
• CSV is not schema-safe by itself; validate headers and data types.
Question Strong answer
load vs loads? load reads from a file-like object; loads parses
a string.
Why use DictReader? It binds each row to column names, which
makes code safer and more readable.

datetime and zoneinfo

datetime and zoneinfo
Date, time, timezone, and scheduling primitives.

Module snapshot Notes

Important classes / objects datetime, date, time, timedelta, timezone;
[Link]
Where it is used Audit logs, SLAs, scheduling, expirations,
billing periods, API timestamps.
High-value concepts naive vs aware datetimes, UTC storage,
timedelta arithmetic, ISO formatting, ZoneInfo
for business time.

Likely interview angles

• Explain naive vs timezone-aware datetime.
• Why teams often store timestamps in UTC.
• How ZoneInfo helps with daylight-saving correctness.
Example

from datetime import datetime, timedelta, UTC

from zoneinfo import ZoneInfo

created_at = [Link](UTC)
expiry = created_at + timedelta(hours=2)
kolkata_time = created_at.astimezone(ZoneInfo('Asia/Kolkata'))

print(created_at.isoformat())
print([Link]())
print(kolkata_time.isoformat())

Pitfalls to remember
• Avoid mixing naive and aware datetime objects.
• Prefer UTC internally and convert for display.
 Question Strong answer
Naive vs aware datetime? Naive has no timezone context; aware carries
timezone info and is safer for real systems.
Best storage rule? Store in UTC, convert at the edges.

re
re
Pattern matching for validation, extraction, and transformation.

Module snapshot Notes

Important classes / objects [Link], [Link]
Where it is used Log parsing, input validation, quick
extraction, filename normalization, text
cleanup.
High-value concepts compile, search, match, fullmatch, findall,
finditer, groups, named groups, substitution.

Likely interview angles

• Difference between match, search, and fullmatch.
• When regex is the right tool and when plain string methods are enough.
• How named groups make patterns maintainable.
Example

import re

pattern = [Link](r'(?P<user>[a-z0-9._%+-]+)@(?P<domain>[a-z0-9.-]+\.[a-z]{2,})')
text = 'Contact ops-team@[Link] for support'

m = [Link](text)
if m:
print([Link]('user'))
print([Link]('domain'))

Pitfalls to remember
• Do not overuse regex for simple contains/replace tasks.
• Test patterns on edge cases to avoid brittle parsing.
Question Strong answer
search vs fullmatch? search finds a match anywhere; fullmatch
requires the whole string to match.
When not to use regex? When a simple split, replace, startswith,
endswith, or in check is enough.

collections, dataclasses, and typing

collections, dataclasses, and typing
Cleaner data models and specialized containers.
 Module snapshot Notes
Important classes / objects Counter, defaultdict, deque, namedtuple;
[Link]; [Link], Any,
Iterable, Mapping
Where it is used Event aggregation, queues, readable data
models, typed APIs, service-layer contracts.
High-value concepts Counter counting, defaultdict defaults, deque
queue ops, dataclass for value objects, type
hints for readability.

Likely interview angles

• Why dataclasses reduce boilerplate.
• Counter versus dict for frequency counting.
• What type hints improve even though Python remains dynamically typed.
Example

from collections import Counter, defaultdict, deque

from dataclasses import dataclass

events = ['ok', 'ok', 'failed', 'ok']

print(Counter(events))

buckets = defaultdict(list)
buckets['api'].append('GET /health')

queue = deque(['job1', 'job2'])

[Link]('job3')
print([Link]())

@dataclass
class User:
user_id: int
email: str

Pitfalls to remember
• Type hints help tools and humans, but they do not enforce runtime validation by
themselves.
• Default mutable dataclass fields need default_factory.
Question Strong answer
When is Counter better than dict? When frequency counting is the primary
operation.
Why use dataclass? It reduces boilerplate for simple value-
carrying classes.

itertools and functools

itertools and functools
Small, composable tools for iteration and functional composition.

Module snapshot Notes

 Important classes / objects iterator types from itertools; [Link],
lru_cache
Where it is used Streaming data, batched processing, reusable
adapters, memoization, high-volume loops.
High-value concepts chain, islice, groupby, product, partial,
reduce, lru_cache.

Likely interview angles

• What makes itertools memory-efficient.
• How lru_cache helps expensive pure functions.
• When partial is cleaner than tiny wrapper functions.
Example

from functools import lru_cache, partial

from itertools import chain, islice

print(list(islice(chain([1, 2], [3, 4], [5]), 4)))

@lru_cache(maxsize=128)
def fib(n):
if n < 2:
return n
return fib(n - 1) + fib(n - 2)

base2 = partial(int, base=2)

print(base2('1010'))

Pitfalls to remember
• groupby groups only adjacent items, so sort first if grouping by key.
• Cache only deterministic functions with stable inputs.
Question Strong answer
Why are itertools tools efficient? Many of them return iterators and avoid
loading everything into memory.
When should lru_cache be avoided? When the function has side effects or
depends on changing external state.

argparse and logging

argparse and logging
Command-line interfaces and production-grade diagnostics.

Module snapshot Notes

Important classes / objects [Link], Namespace;
[Link], Handler, Formatter, Filter,
LogRecord
Where it is used CLI tools, deployment utilities, batch jobs,
service diagnostics, audit trails.
High-value concepts positional vs optional args, type conversion,
subcommands, logging levels, handlers,
structured message fields.
Likely interview angles
• Why argparse is safer than manual argv parsing.
• Difference between print and logging in production.
• Why logger configuration should usually happen once at app startup.
Example

import argparse
import logging

[Link](level=[Link], format='%(asctime)s %(levelname)s %(message)s')

logger = [Link](__name__)

parser = [Link]()
parser.add_argument('--limit', type=int, default=100)
args = parser.parse_args([])

[Link]('starting job with limit=%s', [Link])

Pitfalls to remember
• Use [Link]('x=%s', value) instead of string concatenation to defer formatting.
• Avoid configuring the root logger in many files.
Question Strong answer
Why logging over print? It gives levels, handlers, formatting,
timestamps, and routing to different outputs.
What does ArgumentParser return? A Namespace object with parsed argument
values.

subprocess
subprocess
Safe interaction with shell commands and external tools.

Module snapshot Notes

Important classes / objects CompletedProcess, Popen, TimeoutExpired,
CalledProcessError
Where it is used Git, cloud CLIs, ffmpeg, Terraform, Salesforce
CLI, build tools, migration scripts.
High-value concepts run, capture_output, text=True, check=True,
timeouts, explicit argument lists.

Likely interview angles

• Why argument lists are safer than shell=True.
• How to capture stdout and stderr for diagnostics.
• How to fail fast on bad exit codes.
Example

import subprocess
 result = [Link](
['python', '--version'],
capture_output=True,
text=True,
check=True,
timeout=10,
)

print([Link]())

Pitfalls to remember
• Avoid shell=True unless you intentionally need shell features.
• Always think about timeouts, exit codes, and sensitive data in command logs.
Question Strong answer
Why avoid shell=True by default? Argument lists are safer and reduce shell
injection risks.
What does check=True do? It raises an exception if the command exits
non-zero.

asyncio, threading, and [Link]

asyncio, threading, and [Link]
Concurrency tools for I/O, waiting, and background execution.

Module snapshot Notes

Important classes / objects [Link], Event, Lock, Queue;
[Link], Lock;
[Link],
Future, ProcessPoolExecutor
Where it is used Web services, network clients, parallel I/O,
blocking adapter calls, background jobs.
High-value concepts coroutines, event loop, await, tasks, thread
pools, process pools, CPU-bound vs I/O-bound
choice.

Likely interview angles

• Difference between threading and asyncio.
• When to use a process pool instead of a thread pool.
• Why CPU-bound work does not usually speed up with threads in CPython.
Example

import asyncio

async def fetch(name):

await [Link](0.1)
return f'done:{name}'

async def main():

results = await [Link](fetch('a'), fetch('b'))
print(results)
 [Link](main())

Pitfalls to remember
• Do not block the event loop with long synchronous calls.
• Choose concurrency based on workload type, not fashion.
Question Strong answer
When to use asyncio? When handling many I/O waits cooperatively
inside one event loop.
Thread pool or process pool? Thread pool for I/O-bound work; process pool
for CPU-bound work.

sqlite3 and [Link]

sqlite3 and [Link]
Embedded database access and test isolation.

Module snapshot Notes

Important classes / objects [Link], Cursor, Row;
[Link]; [Link],
MagicMock, patch, AsyncMock
Where it is used Small local databases, prototypes, tooling
state, unit tests, API/client mocking.
High-value concepts connections, cursors, parameterized queries,
row factories, test cases, patch targets, call
assertions.

Likely interview angles

• Why parameterized SQL is safer than string interpolation.
• How patch works and what target should be patched.
• When sqlite is enough and when it is not.
Example

import sqlite3
from [Link] import patch

conn = [Link](':memory:')
[Link]('create table users(id integer, email text)')
[Link]('insert into users values (?, ?)', (1, 'a@[Link]'))
row = [Link]('select email from users where id = ?', (1,)).fetchone()
print(row[0])

with patch('[Link]', return_value='prod'):

import os
print([Link]('APP_ENV'))

Pitfalls to remember
• Patch where the symbol is looked up, not where it originally came from.
• Always use placeholders in SQL queries.
Question Strong answer
Why parameterized SQL? It prevents SQL injection and handles quoting
safely.
What should patch target? The symbol where the code under test looks it
up.

Rapid revision checklist

• Can I name the main classes in pathlib, argparse, logging, subprocess, sqlite3, and
[Link]?
• Can I explain naive vs aware datetimes and UTC storage in one minute?
• Can I explain I/O-bound vs CPU-bound when asked about asyncio, threads, and processes?
• Can I explain why JSON, CSV, environment variables, and subprocess outputs all need
boundary validation?

Primary references
• Python Standard Library index - [Link]/3/library/[Link]
• Python Module Index - [Link]/3/[Link]
• Python Built-in Functions - [Link]/3/library/[Link]