Question 1

What are common useful string methods?

Accepted Answer

Strings are **immutable**, so every method returns a **new** string (the original is untouched). The everyday toolkit:

- **`split(sep)` / `rsplit` / `splitlines`** and **`sep.join(iterable)`** — the idiomatic pair for tokenizing and assembling. `' '.join(parts)` is the right way to build a string, **not** repeated `+=` in a loop (which is O(n²)).
- **`strip()` / `lstrip` / `rstrip`** — trim whitespace (or given chars).
- **`replace(old, new)`**, **`startswith`/`endswith`** (accept a tuple of op

Question 2

What is the difference between '==' and 'is'?

Accepted Answer

- **`==`** tests **value equality** — 'do these represent the same value?' It calls the object's `__eq__`, so you can customize it.
- **`is`** tests **identity** — 'are these the exact same object in memory?' It compares `id()` and can't be overridden.

Two distinct lists with equal contents are `==` but not `is`. The rule of thumb: use **`==`** for value comparisons, and reserve **`is`** for singletons — above all `x is None` (also `is True`/`is False`, and sentinel objects).

The classic trap

Question 3

What are mutable and immutable types in Python?

Accepted Answer

Every Python object is either **mutable** (its state can change in place) or **immutable** (any 'change' actually produces a new object). The distinction is about identity over time, not about whether a *name* can be reassigned.

- **Immutable:** `int`, `float`, `bool`, `complex`, `str`, `bytes`, `tuple`, `frozenset`, `range`. Operations return new objects; the original is untouched.
- **Mutable:** `list`, `dict`, `set`, `bytearray`, and most user-defined class instances.

Three practical conseq

Question 4

Why use virtual environments?

Accepted Answer

A **virtual environment** is an isolated Python installation for a single project: its own `site-packages` (and a pinned interpreter), separate from the system Python and from other projects. You create one with **`python -m venv .venv`**, activate it, then `pip install` into *that* sandbox.

Why it matters:

- **No dependency conflicts:** project A needs `Django 3`, project B needs `Django 5` — without isolation those collide in one global `site-packages`. Each venv gets its own versions.
- **R

Question 5

How does slicing with start:stop:step work?

Accepted Answer

`seq[start:stop:step]` returns a **new** subsequence. The range is **half-open** — it includes `start` but **excludes `stop`** — and `step` picks every *n*-th element (default 1). All three parts are optional and have sensible defaults:

Question 6

How does iterable unpacking work?

Accepted Answer

**Unpacking** assigns the elements of an iterable to multiple targets at once: `a, b, c = [1, 2, 3]`. The count must match — unless you use a **starred target** `*rest`, which greedily absorbs the remaining items into a **list**: `first, *middle, last = [1, 2, 3, 4, 5]` gives `first=1`, `middle=[2,3,4]`, `last=5`. Exactly one star is allowed, and it works at either end or the middle.

Unpacking powers several idioms:

- **Swapping** without a temp: `a, b = b, a` (the right side becomes a tuple f

Question 7

How are Python dictionaries implemented and ordered?

Accepted Answer

A `dict` is a **hash table**: keys are hashed (`hash(key)`) to find a slot, giving **average O(1)** lookup, insertion and deletion (worst case O(n) under pathological collisions). Keys must be **hashable** — i.e. immutable-by-value with stable `__hash__`/`__eq__` (so `str`, `int`, `tuple` work; `list`/`dict` don't).

Since **Python 3.7** dicts **preserve insertion order** as a **language guarantee** (it was a CPython implementation detail in 3.6). The modern 'compact dict' stores entries in a de

Question 8

What is the difference between a list and a tuple?

Accepted Answer

Both are ordered sequences, but the defining difference is **mutability**.

| | `list` | `tuple` |
|---|---|---|
| Mutable | yes — append/insert/remove/reassign | no — fixed once created |
| Syntax | `[1, 2, 3]` | `(1, 2, 3)` |
| Hashable | no (can't be a dict key / set member) | yes, if all items are hashable |
| Memory & speed | larger, slight overhead for resizing | smaller, marginally faster to build/iterate |
| Intent | a homogeneous collection you'll change | a fixed, often heterogeneous r

Question 9

What set operations does Python support?

Accepted Answer

A `set` is an **unordered** collection of **unique, hashable** items with average **O(1)** membership tests — ideal for de-duplication and fast 'is this in here?' checks. It supports the full algebra of sets, with both operator and method forms:

| Operation | Operator | Method | Result |
|---|---|---|---|
| Union | `a | b` | `a.union(b)` | in either |
| Intersection | `a & b` | `a.intersection(b)` | in both |
| Difference | `a - b` | `a.difference(b)` | in `a`, not `b` |
| Symmetric diff | `a ^

Question 10

What are f-strings?

Accepted Answer

**f-strings** (formatted string literals, 3.6+) embed expressions directly inside a string prefixed with `f`: `f"{name} is {age}"`. The `{...}` parts are evaluated at runtime and inserted. They're the **most readable and fastest** way to format strings — faster than `%`-formatting and `str.format`, because the parsing happens at compile time.

They do more than interpolate names — any expression works: `f"{a + b}"`, `f"{user.name.upper()}"`, `f"{items[0]}"`. And they support **format specs** aft

Python Interview Library

Question Catalog

What are common useful string methods?

What is the difference between '==' and 'is'?

What are mutable and immutable types in Python?

Why use virtual environments?

How does slicing with start:stop:step work?

How does iterable unpacking work?

How are Python dictionaries implemented and ordered?

What is the difference between a list and a tuple?

What set operations does Python support?

What are f-strings?

What is the difference between __repr__ and __str__?

How does the in operator work in Python?

How do you sort with a custom key, and how does sorted differ from sort?

How does comparison chaining (a < b < c) work?

What do enumerate and zip do?

What values are falsy in Python?

What is duck typing in Python?

What is the walrus operator?

How does exception handling work in Python?

What is the difference between shallow and deep copy?

What are mixins in Python?

What is the difference between an iterable and an iterator?

What are dunder (magic) methods?

What do the global and nonlocal keywords do?

What is structural pattern matching (match/case)?

What is the difference between bytes and str?

How does collections.deque work internally?

What is the @property decorator?

What is composition versus inheritance?

What are decorators in Python?

How do generator pipelines stream data lazily?

What useful types does the collections module provide?

What is the difference between a module and a package?

What are abstract base classes and Protocols?

What is the LEGB rule for scope resolution?

How does heapq work in Python?

How does a + b dispatch in Python?

What are lambda functions and map/filter/reduce?

What is the difference between classmethod and staticmethod?

How does exception propagation work up the call stack?

What do *args and **kwargs mean?

When do you use threading, multiprocessing, or asyncio?

What are dataclasses?

How does a for loop work under the hood?

What are bound and unbound methods in Python?

How does yield from delegation work?

What is the difference between the call stack and the heap in Python?

How does functools.lru_cache work?

How does functools.reduce fold a sequence?

Why use functools.wraps when writing decorators?

What are generators and why use them?

How does Python's name and object reference model work?

How does the bisect module work?

Why does Python cache small integers?

What is string interning in Python?

What does the functools module offer?

How does Timsort make Python's sort fast and stable?

What is the memory difference between a list comprehension and a generator expression?

What is the difference between class variables and instance variables?

What are generics and TypeVar in Python?

What are list/dict/set comprehensions?

What is a context manager?

What is monkey patching in Python?

What is a generator's lifecycle?

How does a Python list grow in memory?

How do you use multiple context managers at once?

What is the difference between concurrency and parallelism in Python?

What is EAFP vs LBYL in Python?

What is pickling and what are its risks?

What is the itertools module used for?

What does __slots__ do?

How do type hints work in Python?

What is a race condition and how do locks prevent it?

How does Python manage memory and garbage collection?

What is the Global Interpreter Lock (GIL)?

Why is using a mutable default argument dangerous?

What is an async iterator and async for?

How does the Python import system work?

What is the difference between repr and str?

What does slots do?

What is the difference between new and init?

What is the hash and eq contract?

What is the difference between getattr and getattribute?

What is the difference between del, del, and garbage collection?