460 Python Developer Interview Questions & Answers

None is the single Python object used to represent the absence of a value. It is different from False, zero, an empty string, and an empty collection, even though all of them are treated as false in a condition. I compare a value with None by using is or is not because the check is about whether the value refers to the exact None object.

Use None when a value is missing, unknown, not provided, or has no useful result. None is the only instance of NoneType, so every reference to None points to the same object.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

None is not equal to False, zero, an empty string, or an empty collection. These values are all false in a truth value test, but they can still contain valid information. For example, zero can be a valid count, and an empty list can be a valid result with no items.

Compare a value with None by writing value is None or value is not None. The is operator checks object identity. Writing value == None may call custom equality behavior defined by the value's class, so it is less clear and can produce unexpected behavior.

A function that reaches its end without an explicit return statement returns None. A return statement with no expression also returns None.

The identity check takes constant time and does not create another None object. Python reuses the singleton. In production, None is commonly used for optional arguments, missing database values, cache misses, and operations that do not return useful data. Use a direct None check when other false values are valid.

A common mistake is writing value == None instead of value is None. Another mistake is assuming that None is the same as False, zero, an empty string, or an empty collection. Developers also sometimes write if not value when they only want to detect None. That condition also matches every other false value. Another mistake is forgetting that a function without an explicit returned expression produces None. It is also incorrect to use None as a default argument when the application must distinguish an omitted argument from an argument explicitly set to None.

Start by saying that None represents the absence of a value and is the only instance of NoneType. Then separate it from other false values and state the comparison rule clearly: use is None or is not None.

The pass statement performs no action. It is mainly used as a valid placeholder when Python requires a statement inside a block, but no behavior is needed yet. Execution continues with the next statement. Unlike continue, pass does not skip the rest of a loop iteration. Unlike break, it does not end the loop.

The pass statement performs no action. When Python reaches it, execution continues with the next statement.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

Python requires at least one statement inside an indented block. For example, a function, class, loop, condition, or exception handler cannot have a completely empty body. Pass can fill that body while keeping the code syntactically valid.

A developer may use pass while defining an unfinished function, creating an empty class, keeping one condition intentionally empty, or temporarily leaving a loop body blank. It can also appear in an exception handler when a specific and expected exception should be ignored. That use requires care because ignoring an exception can hide a real problem.

Pass does not change control flow. In a loop, continue skips the remaining statements in the current iteration and starts the next iteration. Break exits the nearest loop. Pass does neither, so later statements in the same block still run.

Pass does not copy values or create an application data structure. Its performance and memory effect are normally insignificant. Its main value is providing a valid statement where Python syntax requires one.

A common mistake is believing that pass skips the current loop iteration. Continue does that. Another mistake is believing that pass exits a loop. Break does that. Developers may also leave pass inside an unfinished function and accidentally release code with missing behavior. Using pass in a broad exception handler is another mistake because it can hide unexpected errors without logging or handling them.

Begin by saying that pass performs no action and is used as a valid placeholder. Then explain that execution continues normally. Finish by comparing it with continue, which skips an iteration, and break, which exits a loop.

The main rule is that break exits the nearest loop, continue skips the rest of the current iteration, and a loop else clause runs only when the loop finishes without break. Continue does not prevent else from running because it does not end the loop. This is useful for searches where break handles a found result and else handles the case where every item was checked without finding a match.

Use break to stop the nearest loop. Use continue to skip the rest of the current iteration. Use a loop else clause for work that should happen only when the loop finishes without break.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

In a for loop, else runs after all items are exhausted. In a while loop, else runs when the condition becomes false. It also runs when the loop has zero iterations. Continue does not skip else because it does not end the loop. The else clause is skipped when break runs. It is also not reached when return or an exception leaves the loop before normal completion.

This pattern is useful for a search. The loop checks each user name. Empty names are skipped with continue. A match prints the result and uses break. If no match is found, else reports that every item was checked.

For a list of n items, the worst case time is O of n because every item may be checked. Break can stop earlier. The loop uses O of one extra memory because it does not copy the list or create another collection. Use loop else when it makes the no match path clear. Avoid it when the control flow may confuse readers.

The example searches a list of user names. An empty name is skipped with continue, so the loop moves to the next item. When the requested name is found, break exits the loop and the else clause is skipped. When no matching name exists, the for loop reaches the end of the list without break, so the else clause runs. The function checks at most every item, creates no copy of the list, and uses only a small fixed amount of extra memory.

A common mistake is thinking that loop else runs whenever the loop condition is false during an iteration. It runs once after normal completion without break. Another mistake is thinking that continue skips the else clause. Continue only skips the remaining statements in the current iteration. Break also exits only the nearest loop, not every nested loop. In a while loop, placing continue before the statement that updates the loop condition can cause an infinite loop. Developers may also forget that else runs when a for loop receives an empty collection because no break occurred.

State the three rules first. Break exits the nearest loop. Continue skips the rest of the current iteration. Else runs only when the loop finishes without break. Then give a small search example and mention that continue does not prevent else from running.

Use list.sort() when I want to change an existing list. It sorts that list in place and returns None. Use sorted() when I want a new sorted list or need to sort another iterable such as a tuple, set, dictionary, or generator. Both accept key for choosing the comparison value and reverse for controlling the sort direction.

The practical choice is simple. Use list.sort() when changing the existing list is acceptable. Use sorted() when the original data must remain unchanged or the input is not a list.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

The sort() method exists only on lists. It rearranges the items inside the same list object and returns None. Returning None helps show that the method performs a change instead of creating a result value.

The sorted() function accepts any iterable. This includes lists, tuples, sets, dictionaries, and generators. It reads the iterable and returns a new list. For a dictionary, it sorts the keys unless another iterable is provided.

Both forms accept key and reverse. Python calls key once for each item and sorts using the returned values. Setting reverse=True produces descending order. Python sorting is stable, so items with equal key values keep their original relative order.

Sorting is usually O(n log n), but already ordered data can be closer to O(n). sorted() needs O(n) memory for its new list. list.sort() avoids that second result list, but the sorting process can still use temporary memory. Items must also have values that Python can compare.

The example uses one employee list as the shared source data. sorted() creates a new list ordered by score and leaves the source list unchanged. A separate copy is then sorted with list.sort(), which changes that copy directly and returns None. Both operations use the score field as the key and reverse=True to place higher scores first.

A common mistake is writing result = values.sort() and expecting result to contain the sorted list. The result is None because sort() changes values directly. Another mistake is calling sort() on a tuple, set, dictionary, or generator. Only lists provide this method. Use sorted() for other iterables. Developers may also forget that sorted() always returns a list, even when the input is another type. The key function does not replace the items. It only provides the comparison value. Sorting values that cannot be compared can raise TypeError. A key function should return values that are mutually comparable. Finally, calling sort() on a shared list can change what other parts of the program observe.

Begin with the main difference. Say that list.sort() changes one list and returns None, while sorted() accepts any iterable and returns a new list. Then mention key, reverse, stable ordering, comparable values, and the memory tradeoff.

F strings are usually the most readable way to place Python values and expressions inside text. I add the letter f before the opening quote and put each expression inside braces. Python evaluates the expressions when that line runs and builds a new string from their formatted results. I can use conversion flags such as !r, a format specification after a colon, and the equals debugging syntax. I keep expensive work outside the f string and do not treat formatted output as automatically safe for SQL, HTML, or shell commands.

F strings place evaluated Python expressions inside text. Add the letter f before the opening quote and put an expression inside braces. For example, f"{name} owes ${balance:.2f}" inserts a name and displays a number with two decimal places.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

Python evaluates each expression when the statement runs. The result is converted and added to a newly created string. A conversion flag controls the first conversion step. !s uses str, !r uses repr, and !a uses ascii. A format specification follows a colon and controls details such as width, alignment, decimal places, percentage display, or date formatting when the value supports that rule.

The equals debugging syntax, such as f"{balance=}", includes the expression text and its value. Literal braces must be doubled as {{ and }}.

F strings are preferred when developers control the format because the value and its display rule stay close together. They do not make data safe for SQL, HTML, or shell commands. Their runtime cost includes evaluating every expression and creating the result string. Memory use mainly depends on the final text size and any temporary objects created by the expressions.

The example uses the same customer name and balance throughout. The first f string inserts both values and formats the balance with two decimal places. The second uses !r to show the representation of the name. The third uses the equals debugging syntax to include the expression name and value. The fourth doubles the outer braces so they appear as literal text. Every statement creates a new result string after evaluating its expressions.

Common mistakes include forgetting the letter f, using single braces when literal braces are required, placing a conversion flag after the format specification, and applying a format rule that the value does not support. Another mistake is hiding slow function calls or expressions with side effects inside braces. Developers may also assume that an f string escapes values for SQL, HTML, URLs, or shell commands. It does not. Using eval on untrusted text to create dynamic f string behavior is also unsafe because it can execute Python code.

Begin by saying that an f string evaluates expressions inside braces when the statement runs and creates a new string. Show one small example. Then explain conversion flags, the colon format specification, the equals debugging syntax, and doubled literal braces. Finish with the allocation cost and the fact that formatting does not provide security escaping.

Python strings are immutable, so their character sequence cannot change after creation. Operations such as replace, upper, slicing, and concatenation return a string value instead of changing the original object. This makes strings safe to share and suitable as dictionary keys, but repeated concatenation can create extra copying and temporary string objects.

Python strings are immutable. This means the sequence of characters inside a string object cannot change after Python creates it. Code cannot replace a character by assigning to an index.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

Operations that appear to modify a string return a string value instead. For example, replace, upper, slicing, and concatenation leave the original value unchanged. When the result is assigned to the same variable, the variable is rebound. It now refers to the result rather than changing the old object.

This behavior makes strings safe to share. Several variables can refer to the same string without one part of the program changing the value seen by another part. A string also keeps the same value and hash during its lifetime. This allows it to be used as a dictionary key or set member.

The main performance concern appears when many pieces are added repeatedly. Each concatenation may allocate another string and copy characters. Some Python implementations can optimize certain simple cases, but code should not depend on that optimization. For many pieces, store them in a list and call join once. Join usually reduces repeated copying and temporary allocations.

A common mistake is saying that assigning a new value to the same variable changes the original string. The assignment only rebinds the variable. Another mistake is trying to assign to a string index, which raises a TypeError. Developers may also build a large string with repeated concatenation inside a loop and overlook the possible copying and temporary allocations. Another mistake is using is to compare string values. Value comparison should use == because Python may reuse some string objects, but object identity is not guaranteed.

Begin by saying that the characters inside a string object cannot change. Then explain that apparent modifications return a string value and may rebind the variable. Finish with the practical effects: safe sharing, stable hashing, and possible copying during repeated concatenation.

append adds one object to the end of a list. extend takes an iterable and adds each item from it to the end. insert takes an index and one object, then places that object before the element currently at that position. All three methods change the existing list and return None. I use append for one object, extend for several items, and insert when a specific position is required.

The practical rule is to use append for one object, extend for every item from an iterable, and insert for one object at a chosen position.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

append accepts one object and adds it to the end. Appending [3, 4] to [1, 2] produces [1, 2, [3, 4]]. The added list remains one nested object.

extend accepts one iterable. Python reads that iterable and adds each item separately. Extending [1, 2] with [3, 4] produces [1, 2, 3, 4]. A non iterable value raises TypeError. Extending with a string adds its characters separately.

insert accepts an index and one object. It places the object before the element at that position. A large positive index places it at the end. A very small negative index places it at the beginning.

All three methods modify the same list and return None. They store references to objects rather than copying the objects themselves. The list may allocate more internal space as it grows. append is usually constant time on average. extend takes time based on the number of added items. insert may take time based on the list size because existing references may need to move.

A common mistake is using append when each item from another iterable should be added separately. This creates one nested element instead of adding the items individually. Another mistake is writing values = values.append(3). append returns None, so values then refers to None. The same return behavior applies to extend and insert. Developers may also forget that extend with a string adds separate characters. Another mistake is expecting these methods to copy mutable objects. They add object references, so later changes to a shared mutable object can be visible through the list. Repeated insert calls near the beginning of a large list can also create unnecessary performance cost.

Start with the decision rule. Say that append adds one object, extend adds each item from an iterable, and insert adds one object at a chosen index. Then use the same small list example to show that append can create a nested list while extend adds separate items. Finish by stating that all three methods modify the original list and return None.

Use remove when you know the value, pop when you know the index and need the removed value, and del when you want to delete an item, a slice, or a variable name. remove deletes the first matching value and returns None. pop removes and returns an item, using the last item when no index is given. del is a statement, so it does not return a value.

The practical choice depends on what you know and whether you need the removed value. list.remove(value) searches from the start of the list and deletes the first item that compares equal to the value. It returns None. If no match exists, Python raises ValueError. Use it when the value matters more than its position.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

list.pop(index) removes and returns the item at that index. With no index, it removes the final item. A missing item in an empty list or an index outside the valid range raises IndexError. Negative indexes are allowed when they refer to a valid position.

del is a Python statement. del items[index] removes one item. del items[start:stop] removes a slice. del name removes that name from its current scope. It does not directly destroy the object if other references still point to it.

All list removal operations change the original list. remove may scan many items before finding a match. Removing from the front or middle also shifts later items left. pop() from the end is amortized constant time in normal Python list use. These operations usually do not create a new list, although Python manages the internal list storage and may keep some allocated capacity.

A common mistake is expecting remove to return the deleted item. It returns None. Another mistake is assuming remove deletes every matching value. It deletes only the first match. Developers may also call pop on an empty list or use an invalid index without handling IndexError. Another error is treating del like a function or expression that returns a value. del is a statement. It is also incorrect to assume del name always destroys the object immediately. It removes one name binding, but other references may still keep the object alive. Removing items while iterating over the same list can also skip values or produce confusing results because indexes change.

Start with the decision rule. Say remove is by value, pop is by index and returns the item, and del deletes an item, slice, or name without returning anything. Then mention the main exceptions and explain that removing from the middle of a list requires later items to shift.

split breaks one string into a new list of smaller strings. join combines an iterable of strings into one new string and places a separator between the items. For example, "red,green,blue".split(",") returns ["red", "green", "blue"], and ",".join(["red", "green", "blue"]) returns "red,green,blue". Every item passed to join must be a string, or Python raises TypeError.

Use split when you need to break one string into parts. Use join when you need to combine strings with a separator.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

For example, "red,green,blue".split(",") returns a new list containing "red", "green", and "blue". When a separator is provided, Python cuts at each occurrence of that exact separator. Repeated separators can create empty strings. For example, "red,,blue".split(",") returns ["red", "", "blue"]. An empty separator is invalid and raises ValueError.

When split is called without a separator, Python treats runs of whitespace as one separator and ignores whitespace at both ends. This differs from split(" "), which uses one exact space and can produce empty strings.

join works in the opposite direction. The separator calls the method. For example, ",".join(["red", "green", "blue"]) returns "red,green,blue". Every item must be a string. A non string item causes TypeError.

Strings are immutable, so neither method changes the original string. split creates a new list and new substring results. join creates a new result string. Time and memory use grow with the total amount of text processed.

The first example starts with the string "red,green,blue". split uses a comma as the separator and returns the list ["red", "green", "blue"]. join then uses the same comma separator and produces "red,green,blue". The second example contains integers. Each integer is converted to a string before join because join accepts string items only.

A common mistake is calling join on the iterable, such as values.join(","). The separator must call join, so the correct form is ",".join(values). Another mistake is passing integers, bytes, or other non string items directly to join, which raises TypeError. Developers may also assume split() and split(" ") behave the same, but repeated whitespace is handled differently. Other mistakes include using an empty separator, which raises ValueError, forgetting that repeated explicit separators can create empty strings, and using simple split for structured formats such as CSV that have quoting rules.

Explain split and join as opposite operations. State that split returns a new list, join returns a new string, the separator calls join, and every joined item must be a string. Then mention one edge case, such as repeated separators or whitespace handling.

enumerate() lets me loop over an iterable while receiving both a counter and the current value. It yields pairs containing the counter and the item. The counter starts at zero by default, but the start argument can change its first value. It is usually clearer and safer than maintaining a separate counter.

Use enumerate() when a loop needs both a counter and the current item. It accepts an iterable, such as a list, tuple, string, or generator, and returns an enumerate iterator. As the loop requests values, the iterator yields tuples containing the current counter and the next item.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

For example, enumerate(["red", "blue"]) yields (0, "red") and then (1, "blue"). A loop can unpack each tuple into two names, such as position and color.

The counter starts at zero unless start is provided. enumerate(values, start=1) pairs the first item with one. The start argument does not skip items and does not change the original iterable.

enumerate() is usually better than a manual counter because it removes extra state. A manual counter can become incorrect when the loop changes, especially when continue causes an update statement to be skipped.

enumerate() works lazily. It does not create every pair in advance. Creating the iterator uses constant extra memory, and processing all items takes linear time. The iterator is consumed as it is read, so reuse requires creating a new enumerate object.

A common mistake is assuming that the counter is always the real index of a sequence. When start is not zero, the counter and the actual index differ. Another mistake is expecting start to skip items. It changes only the counter. Developers may also convert enumerate() to a list without needing every pair in memory, reuse an already consumed enumerate iterator, or maintain a separate counter when enumerate() would be clearer.

Explain three points clearly: enumerate() yields counter and value pairs, the default counter starts at zero, and start changes the counter without skipping items. Then mention that it avoids the extra state of a manual counter.