Python Developer interview questions

Lists, tuples, and sets serve different purposes based on order, mutability, and uniqueness.

• A list is an ordered, mutable sequence.
• A tuple is ordered and immutable, so it can be a dictionary key when its contents are hashable, unlike a list.
• A set is an unordered collection of unique, hashable elements that provides automatic deduplication and average O(1) membership tests.

Mutability determines whether an object can change after it is created and affects how it can be used.

• Lists, dictionaries, and sets are mutable, while integers, floats, strings, tuples, and frozensets are immutable.
• Two variables can refer to the same mutable list, so a change made through one name is visible through the other.
• Immutability makes a value hashable and suitable for use as a dictionary key or set element.

A Python dictionary is a hash table with fast key-based access.

• It uses a key's hash to locate its value, giving average O(1) lookup, insertion, and deletion.
• Keys must be hashable, such as strings, numbers, or tuples of immutable values; lists and dictionaries cannot be keys.
• Since Python 3.7, dictionaries preserve insertion order, but that behavior should not replace explicit sorting.

Slicing extracts part of a sequence with the sequence[start:stop:step] syntax.

• The start index is inclusive, the stop index is exclusive, and any component can be omitted.
• Negative indices count from the end, so items[-3:] gets the last three elements and items[::-1] reverses the sequence.
• Slicing a list creates a new list, which makes items[:] a quick shallow copy.

A list comprehension is best for a simple, readable transformation or filter that produces a list.

• The expression [x * 2 for x in nums if x > 0] transforms and filters values in one line.
• This form is the Pythonic choice while the transform-and-filter logic remains easy to read.
• A regular loop is clearer when the logic needs multiple statements, side effects, or deep nesting.

Python supports dictionary and set comprehensions as well as lazy generator expressions.

• A dictionary comprehension can look like {u.id: u.name for u in users}, and a set comprehension like {x % 10 for x in nums}.
• A generator expression, such as sum(x * x for x in nums), produces values lazily without building an intermediate list.
• The choice depends mainly on whether the complete result must exist in memory at once.

The *args and **kwargs syntax lets functions receive or forward a flexible set of arguments.

• *args collects additional positional arguments into a tuple.
• **kwargs collects additional keyword arguments into a dictionary.
• In a call, func(*items, **options) unpacks a sequence and a dictionary, which is useful in wrappers and decorators that forward arguments unchanged.

A mutable default argument is shared across calls and can preserve unexpected state.

• In def add_item(item, items=[]), the list is created once when the function is defined, not for each call.
• Calls that omit items mutate the same list, so a later call can contain values left by an earlier one.
• Use items=None as the default and create items = [] inside the function when items is None.

Python resolves names through Local, Enclosing, Global, and Built-in scopes in that order.

• Reading a variable from an outer scope works without an extra declaration.
• Assigning to a name inside a function creates a local variable unless global or nonlocal is declared.
• This is why mutating a global list can work while rebinding a global counter without global raises UnboundLocalError.

Python uses pass by assignment, meaning a function receives a reference to the same object.

• This model is neither classic pass by value nor classic pass by reference.
• Mutating a passed list inside the function changes the caller's list because both refer to the same object.
• Rebinding the parameter to a new object affects only the local name and leaves the caller unchanged.

The operators == and is compare value equality and object identity, respectively.

• The == operator calls __eq__ to compare values.
• The is operator checks whether two names point to exactly the same object, so two equal lists can satisfy == but not is.
• Identity comparison is idiomatic for singletons, especially x is None, because only one None object exists.

Shallow and deep copies differ in whether nested objects remain shared with the original.

• A shallow copy creates a new outer container but keeps references to the same inner objects.
• list(data) and data[:] therefore still share nested lists, so changing a nested dictionary can also change the original.
• copy.deepcopy recursively clones the contents and produces a fully independent structure.

F-strings are the preferred general-purpose string formatting syntax because they are direct, readable, and fast.

• They embed expressions directly, as in f'{user.name} has {count} items', and support format specifications such as f'{price:.2f}'.
• Since Python 3.8, f'{value=}' prints both the expression and its value for quick debugging.
• Percent formatting and str.format still appear in legacy code, while logging deliberately uses lazy percent formatting.

Repeated string concatenation with + inside a large loop is inefficient because strings are immutable.

• Every += creates a new string and copies all previous content, which can make the loop quadratic on large inputs.
• The idiomatic alternative is to collect parts in a list and call ''.join(parts) once.
• For only a few concatenations the difference is negligible, so this concern mainly applies to loops over many items.

The try, except, else, and finally blocks separate protected code, error handling, successful continuation, and cleanup.

• Code in try runs first, and a matching except block handles an exception.
• The else block runs only when try completes without an exception, keeping the successful path separate from protected code.
• The finally block always runs and is suitable for cleanup such as closing resources not managed by with.

A bare except is dangerous because it can hide genuine bugs and control-flow exceptions.

• It catches KeyboardInterrupt, SystemExit, and mistakes such as NameError, allowing the program to continue in a broken state.
• Code should catch the most specific exception it can handle, such as FileNotFoundError or ValueError.
• A necessary top-level broad handler should catch Exception, log the full traceback, and then re-raise or fail visibly.

Exceptions should report invalid input or an unrecoverable state as close to the cause as possible.

• A function can reject input explicitly, for example with raise ValueError('amount must be positive').
• A custom Exception subclass such as PaymentDeclinedError lets callers catch failures specific to that code without catching unrelated ValueErrors.
• Raising early with a clear message is safer than returning None and allowing a failure far from its cause.

The iterator protocol gives Python a uniform way to traverse lists, files, generators, dictionaries, and other iterable objects.

• An iterable returns an iterator when iter() is called.
• An iterator implements __next__ and produces values until it raises StopIteration.
• A for loop calls iter() once, repeatedly calls next(), and stops when it receives StopIteration.

A generator produces values one at a time, making it suitable for large or infinite sequences.

• A generator function uses yield and suspends its execution between produced values.
• Processing a large log file line by line uses constant memory, whereas returning a list would load the full result.
• A generator can be consumed only once and does not provide len().

range() returns a lazy sequence object rather than a prebuilt list.

• It computes values on demand, so even range(10**9) uses almost no memory.
• A range supports len(), indexing, and fast integer membership tests.
• Use list(range(n)) only when an actual list is required; loops benefit from the lazy range object directly.