Python quiz — 75 questions with answers and explanations

Answer: C

It prints 0.30000000000000004 then False. Floats in Python are IEEE-754 64-bit binary floats; 0.1 and 0.2 cannot be represented exactly in binary, so the sum is slightly off. Therefore comparing with == against 0.3 gives False. Compare floats using a tolerance, e.g. math.isclose(a, b).

Answer: A

It prints 3.5, 3, -4. In Python 3, / is true division and always returns a float (7 / 2 = 3.5). // is floor division: it rounds DOWN toward negative infinity, so 7 // 2 = 3 but -7 // 2 = -4 (not -3). This differs from the truncate-toward-zero behavior of C/Java.

Answer: A

Prints ['b', 'a', 'c']. Since Python 3.7, dict preserves INSERTION order as a language guarantee (before that it was a CPython 3.6 implementation detail). So iterating keys yields exactly the order they were added: b, a, c — a dict does NOT sort alphabetically. For a different order, use sorted(d).

Answer: A

Choose set. list = ordered sequence, allows duplicates, in is O(n); tuple = like a list but immutable (for fixed keys/records), in is also O(n); set = collection of unique elements, average O(1) membership test; dict = key→value mapping, O(1) lookup by key. For "unique collection + fast membership test" → set is the best fit.

Answer: C

In a function definition, *args collects any extra positional arguments into a tuple, while kwargs collects any extra keyword** arguments into a dict of name→value. They let a function accept an arbitrary number of arguments. At the call site, * and ** do the reverse: they unpack an iterable/dict into separate arguments.

Answer: C

ndarray stores elements of a single dtype in contiguous memory and enables vectorization — operations run once in C instead of a per-element Python loop. That makes it many times faster and more RAM-efficient for large numeric data. The trade-offs: fixed size (append is expensive) and numpy is a third-party library you have to install.

Answer: B

A list is mutable: you can add (append), modify (lst[0] = 9), and remove elements after creation. A tuple is immutable: once created it's fixed, and assigning to an element raises TypeError. Because of immutability, a tuple (containing hashable elements) can be used as a dict key and a set member — a list cannot. Use a list for changing sequences of data, a tuple for fixed records like coordinates (x, y).

Answer: C

Python uses indentation as syntax: after a line ending in : (like if, for, def, class), lines indented to the same level form a block; the block ends when the indentation returns to the previous level. Missing indentation or inconsistent levels raise IndentationError. The standard convention (PEP 8) is 4 spaces per level, never mixing tabs and spaces.

Answer: D

An f-string (Python 3.6+) is a string with the f prefix that lets you embed expressions in {}: f"Score: {score}, 2+3={2+3}" evaluates the expression right there and inserts the result into the string. It supports a format spec after a colon: f"{price:.2f}" (2 decimal places). Without the f prefix, {score} is printed literally. This is the recommended way to format strings instead of % and .format().

Answer: D

nums[1:3] returns [20, 30]: the slice [start:stop] takes from index start up to but not including stop (half-open — stop is excluded), with exactly stop - start elements. The result is a new list; the original stays unchanged. Slices don't raise on out-of-range indices but clamp to the valid range. Leaving both ends empty (nums[:]) creates a shallow copy of the whole list.

Answer: B

It prints False, True, False, True. Truthiness rule: an EMPTY container/string is falsy ("", [], {}, set()), while a NON-empty one is truthy — regardless of contents. So "False" (a 5-character string) is truthy, and [0] (a 1-element list) is also truthy even though the element is 0. Only the number 0 itself is falsy, not a list containing it.

Answer: B

The interpreter sets the __name__ of a directly-run module to "__main__"; when the module is imported, __name__ is the module name. So code inside the if __name__ == "__main__": block only runs with python foo.py, not with import foo. That lets a file be both a reusable module (import its functions) and a runnable script — the standard place to put a CLI entry point or test-run code.

Answer: B

It is shorter and slightly faster. It avoids looking up the append attribute and calling it each iteration, and it clearly expresses the intent "build a new list from the old one". It still builds the whole list in memory, just like a normal loop.

Answer: A

Because strings are immutable: each concatenation creates a new string and copies the entire content, so joining n pieces costs quadratic time. join traverses first to compute the total length, allocates once, then copies each piece in — linear overall.

Answer: D

Only when the try block completes without an exception. Its purpose is to separate code that should run only on success from the try, so try covers just the line that can raise and doesn't accidentally catch exceptions from later code.

Answer: B

It is a reference to the object that is calling the method. When you write obj.method(x), Python turns it into Class.method(obj, x) — the object is passed as the first parameter. The name self is only a very strong convention, not a language keyword.

Answer: D

It has no effect at runtime. Python stores the annotations in __annotations__ but doesn't check, coerce, or optimize anything. The checking is done by static analysis tools like mypy or pyright before running.

Answer: C

Because it guarantees the file gets closed no matter how the block ends — running to completion, hitting return, or raising an exception. A manual close() is skipped if an error occurs in between, leaving the file open and risking data loss for unflushed writes.

Answer: D

Pairs of (index, element). That lets you write for i, item in enumerate(items): and get both position and value without maintaining a counter yourself. The second argument changes the starting point: enumerate(items, 1) numbers from 1.

Answer: A

Django's QuerySet is lazy: filter()/exclude() only build the query, and the SQL runs only when the QuerySet is evaluated — iterating, list(), len(), slicing, or printing it. That way chaining multiple filters still costs only one query.

Answer: D

get() raises User.DoesNotExist when no record exists (and MultipleObjectsReturned when more than one matches). filter().first() returns None. Choose by semantics: the record must exist → get(); it may not exist → first().

Answer: C

From the type hints and Pydantic models declared on the endpoint. FastAPI converts them into an OpenAPI schema (available at /openapi.json), and Swagger UI reads that schema to render /docs. Since it's generated from code, the docs never drift from the API's actual behavior.

Answer: C

Via the query string (/items/5?q=abc). FastAPI's rule: a parameter whose name matches a variable in the path template ({item_id}) is a path param; any remaining parameter (simple type) becomes a query param — optional if it has a default, required otherwise.

Answer: C

It prints [1] then [1, 2]. The default value of a parameter is evaluated ONCE at def time, not on each call. acc is the same shared mutable list, so the second call still sees the first call's elements — the classic "mutable default argument" trap.

Answer: A

Prints 2, 3, True. In Python, bool is a subclass of int: True equals 1 and False equals 0. So True + True is computed as 1 + 1 = 2, and isinstance(True, int) returns True. That's why sum([True, False, True]) counts the elements that satisfy the condition.

Answer: C

Prints True then False. Python allows chained comparisons: 5 > 3 > 1 means (5 > 3) and (3 > 1), with 3 evaluated only once → True. But with parentheses (5 > 3) > 1, True is computed first (as 1) and then 1 > 1 → False. Parentheses break the chained comparison mechanism.

Answer: B

Prints [1, 2, 3, 4] then [1, 2, 3]. The assignment b = a does NOT copy the list — it just creates another name pointing to the same object, so a.append(4) also shows up through b. In contrast, c = a[:] creates an independent shallow copy, so c stays [1, 2, 3]. This is the core difference between aliasing and copy.

Answer: C

Prints [1, 2, 3] then [1, 2]. For a list, a += [3] calls __iadd__ — it extends the list IN PLACE (like extend), so the alias b also sees element 3. Meanwhile c = c + [3] creates a NEW list and rebinds c; variable d still points to the old list, so it stays [1, 2]. += and + differ in whether they mutate in place or create a new object.

Answer: C

Prints [[1, 0, 0], [1, 0, 0]]. The expression [[0] * 3] * 2 does NOT create two independent rows — it replicates a REFERENCE to the same inner list. Both rows of grid point to the same object, so assigning grid[0][0] = 1 also changes the second row. This is a trap when building a matrix with list multiplication.

Answer: A

A shallow copy (copy.copy) creates a new object at the top level, but the elements inside remain shared references with the original. A deep copy (copy.deepcopy) copies recursively through every nesting level, producing a fully independent object. For flat data (containing only immutables) the two behave the same; the difference shows up with nested lists/dicts.

Answer: A

A generator is lazy: each next() produces one element and only keeps the current state, so memory is O(1) instead of O(n) like a list comprehension that builds the whole list up front. That lets it handle very large or infinite data streams. The trade-off: a generator can only be iterated once, has no indexing, and no len().

Answer: A

A decorator is a callable that takes a function (or class) and returns a replacement callable, usually wrapping extra behavior around the original. Writing @dec right above def f is just shorthand for f = dec(f). It's used to add logging, caching, permission checks, timing... without modifying the original function body.

Answer: B

with calls __enter__() on entering the block (its return value is bound to the name after as) and __exit__(exc_type, exc, tb) on leaving the block. __exit__ is guaranteed to run even if an exception occurs — like an implicit finally — so it's used to safely close files, release locks, and close connections. If __exit__ returns a truthy value, the exception is suppressed.

Answer: B

The three differ in their implicit first parameter: an instance method takes self (works with a specific instance); @classmethod takes cls, the class itself (often used as an alternative constructor that respects inheritance); @staticmethod takes neither self nor cls — it's just a plain function placed in the class namespace to group related logic.

Answer: C

It prints 1, [2, 3, 4], 5. This is extended unpacking (PEP 3132): the normal targets (a, c) take the elements at the two ends first, and the starred target *b collects ALL the remaining elements into a list (always a list, even if empty). The * may appear at the start, middle, or end — but only one * per assignment.

Answer: D

It prints None, [1, 2, 3], True. list.sort() sorts in place and returns None — Python's convention to signal that a function mutates the object instead of creating a new one. The classic trap is writing nums = nums.sort(), which makes nums None. To keep the original list and get a sorted version, use the sorted(nums) function — it returns a NEW list.

Answer: A

LEGB is the name lookup order: Local (current function) → Enclosing (outer function) → Global (module) → Built-in; it stops at the first level where the name is found. Reading an outer variable needs no declaration, but assigning inside a function creates a local by default — to assign into an outer scope you must use global (module level) or nonlocal (nearest enclosing function). Violating this rule raises UnboundLocalError.

Answer: A

A dict and a set, respectively. Both use braces; the colon between key and value is what makes the result a dict. Without the colon, Python creates a set.

Answer: C

An iterable is an object with __iter__ that returns an iterator. An iterator has both __iter__ and __next__ and remembers its own position in the iteration. A list is an iterable but not an iterator — each call to iter(list) produces a new iterator starting from the beginning.

Answer: C

str is a sequence of Unicode characters — the unit is the code point. bytes is a sequence of integers 0–255, i.e. raw data. Converting string to bytes uses encode(encoding), the other direction decode(encoding). Python 3 does not implicitly convert between them, so mixing the two raises TypeError.

Answer: B

It formats the value as a float with exactly two decimal places, rounding as needed. The part after the colon is a format spec — the same syntax as format() — and it only produces the display string, it does not change the original variable.

Answer: A

Insertion order is preserved. This is an official language guarantee since Python 3.7 (and was already CPython 3.6's actual behavior). Iterating a dict, calling keys(), values(), or items() all follow the exact order the keys were added in.

Answer: C

When a missing key is accessed, it calls the function passed at initialization to create a default value, stores it in the dict, and returns it — instead of raising KeyError. That makes d[k].append(x) work immediately without checking whether the key already exists.

Answer: D

Because it catches BaseException too, including KeyboardInterrupt and SystemExit. The consequence is that the user presses the exit key combination but the program keeps running, and a sys.exit() call is swallowed. except Exception: catches only ordinary application errors.

Answer: D

It attaches the original exception to the __cause__ attribute, and the printed traceback explicitly states that this is the direct cause. Without from, Python still keeps the original exception in __context__ but only shows a vaguer line about an error occurring while handling another error.

Answer: A

It lets a method be called with attribute-access syntax: obj.area instead of obj.area(). That way you can turn a data field into a computed value, or add validation on assignment, without changing code at the call sites.

Answer: A

__init__, __repr__ and __eq__ — generated from the declared field list. Ordering comparison methods appear only when order=True is passed, and __hash__ is set to None by default because mutable objects shouldn't be hashable.

Answer: C

It blocks instantiation when a subclass hasn't implemented every method marked abstract — raising TypeError right at the constructor call. That way a missing implementation shows up immediately instead of waiting until that method is called.

Answer: C

Equivalent to Union[int, None], and since Python 3.10 it can be written as int | None. It says the value can be an integer or None — it does not mean "this parameter can be omitted".

Answer: A

Because the module being loaded is put into the module table right at the start, but the part below the current import line has not run yet. When the second module imports back and needs a name from that not-yet-executed part, the name does not exist yet, so an ImportError is raised.

Answer: D

from . import utils is a relative import: it looks for utils inside the package containing the current module. import utils is an absolute import: it follows Python's search path — so it may load a same-named module from somewhere else, or find nothing at all.

Answer: D

Dependency conflicts between projects. Without it, every package is installed into one shared place, so project A needing library version 1.0 and project B needing 2.0 cannot coexist. Each virtual environment has its own package directory, so the two projects stay fully independent.

Answer: D

Because it yields a flat list that mixes packages you installed deliberately with packages pulled in as dependencies. As a result you cannot tell which ones are real dependencies, removing a library leaves you unsure which of its transitive packages are still needed, and upgrades become error-prone manual work.

Answer: B

Its body can only be a single expression, with no statements. So you cannot put assignments, loops, try, or multiple lines inside it. It is also unnamed, so tracebacks only show a generic name, making debugging exceptions harder.

Answer: D

It makes every parameter after it keyword-only: f(1, b=2) is valid while f(1, 2) raises TypeError. The point is to force callers to name arguments, making the code self-documenting and allowing new parameters to be added later without breaking existing call sites.

Answer: D

False. By default == on objects uses the inherited behavior from object, which compares identity — effectively the same as is. To compare by value you must implement __eq__ yourself, or use @dataclass to have it generated automatically.

Answer: B

When the work is CPU-heavy. The GIL allows only one thread to execute Python bytecode at a time, so threading does not speed up computation. Each process has its own GIL, so multiprocessing runs in parallel across multiple cores.

Answer: A

Mainly reference counting: each object holds a counter and is freed immediately when it hits 0. Since this can't handle reference cycles, CPython adds a generational GC that runs periodically to detect and clean up groups of objects that only reference each other.

Answer: D

Iterate the file object directly: for line in f:. The file object is a line iterator that reads through an internal buffer and typically materializes only one line at a time instead of loading the whole file. read() and readlines() load everything, so they don't work with large files.

Answer: D

To set up and tear down what a test needs: sample data, database connections, temp directories, fake servers. A test just declares the fixture name as a parameter, and pytest creates it before running and cleans it up afterward.

Answer: A

Because of dynamic typing and the object model. Every addition must check both operand types at runtime before choosing how to add them, whereas C knows at compile time. Also every value, including integers, is an object with its own header, costing memory plus an extra indirection step.

Answer: D

Paths become objects with methods instead of strings passed through functions. Join with the division operator: Path("a") / "b" / "c.txt". Common operations live right on the object — .exists(), .read_text(), .stem, .suffix, .parent — so code is shorter and reads straight left to right.

Answer: A

It carries no timezone information, so the same value gets interpreted differently depending on where it runs. Comparing an aware datetime with a naive one raises TypeError, and arithmetic across a daylight saving transition gives wrong results with no warning.

Answer: A

Easier to ask forgiveness than permission: just perform the operation and catch the exception if it fails, rather than checking beforehand whether it can be done. The opposite approach is called LBYL — look before you leap — and is more familiar to people coming from C or Java.

Answer: A, B, D

select_related = SQL JOIN, for ForeignKey/OneToOne. prefetch_related = a separate query for the related table then joined in Python, for ManyToMany and reverse FK. Both serve the same goal: preloading related data to avoid N+1 queries.

Answer: A

101 queries — 1 to fetch the Book list, then each book.author fires another query because the FK isn't loaded. This is the classic N+1 problem. Fix: Book.objects.select_related("author") → down to exactly 1 query with a JOIN.

Answer: C

makemigrations compares your models with the existing migrations and generates files describing the changes; migrate applies those files to the database. Migration files must be committed because they are the shared schema history — teammates and production run migrate on the same chain of files.

Answer: C

Middleware is a chain of nested wrapper layers around the view: the request passes through each middleware in the order declared in MIDDLEWARE, reaches the view, then the response goes backwards through that same chain. A middleware can intervene in both directions.

Answer: B

Use with transaction.atomic(): wrapping both save calls. Inside that block, an error anywhere → full rollback, both wallets return to their initial state. By default Django runs in autocommit per statement — two save() calls are two separate transactions.

Answer: A

It protects against Cross-Site Request Forgery: a malicious page tricks the logged-in user's browser into sending a POST to your site (the session cookie is attached automatically). Django requires every POST to carry a csrf token matching the server-side value — a foreign site can't read the token, so the request gets 403.

Answer: B

validate_<field>(self, value) validates a single field individually (e.g. validate_email). validate(self, data) runs afterward, receiving the full data dict — used for cross-field constraints like start_date < end_date. Both raise serializers.ValidationError on failure.

Answer: A

FastAPI returns 422 Unprocessable Entity with a JSON body listing each error field (location, message, error type). The handler never runs — getting into the function means the data is guaranteed to be structurally correct and correctly typed.

Answer: D

Dependency injection: extract repeated logic across endpoints — getting the user from a token, opening a DB session, pagination — into a separate function and declare param = Depends(get_db). FastAPI calls the dependency first and passes the result to the handler; if the dependency fails (raise HTTPException), the handler doesn't run.

Answer: C

Because the default value is created once at function definition, not on each call. Every call that omits that argument shares the same object, so changes accumulate across calls.

Answer: B

It swallows every error, so real failures happen silently. A typo in a variable name, a database connection error, and a data error are all ignored alike, and the program keeps running in a wrong state with nobody knowing.