Question 1

Show that a function can mutate a list passed to it, but cannot rebind the caller's name to something else.

Accepted Answer

Both halves of the answer are visible in two small functions.
PythonTry itCopydef append_item(items):
    items.append('added')
    return len(items)

def replace_items(items):
    items = ['new']
    return items

original = ['a']
print(append_item(original))    # 2
print(original)                 # ['a', 'added'] - changed in place

original = ['a']
print(replace_items(original))  # ['new']
print(original)                 # ['a'] - the caller's list is untouched
The first function changes the list that the caller owns, because the function received a reference to that same list object and then changed it. The second function rebinds its own parameter name to a brand new list, which changes nothing outside the function, so the caller's name still refers to the original list.
The reason is that a parameter is a local name inside the function, exactly like any other local. Assigning to it creates a new binding in the function's own scope. The important distinction is between changing an object, which everybody who holds a reference sees, and rebinding a name, which only affects the scope where the rebinding happens.
That is also why the practical advice is to copy the data before you pass it if the function should not be able to modify it. A shallow copy with list(items) or items.copy() is enough for a flat list. For nested structures you need copy.deepcopy, because a shallow copy still shares the inner objects. Alternatively, pass an immutable value such as a tuple, or make

Question 2

Is Python pass-by-value or pass-by-reference, and how do you explain the behaviour accurately?

Accepted Answer

The accurate answer is neither of the two. Python uses pass-by-object-reference. The function receives a reference to the same object that the caller has, and the binding of that reference into the function's local scope is what you observe as an argument.
Both of the popular descriptions fail in one direction. Call it pass-by-value and you get the mutation case wrong, because a list that is passed to a function really does come back changed. Call it pass-by-reference and you get the rebinding case wrong, because a function that assigns to its parameter does not change the caller's variable.
The way to explain it precisely is to separate two different operations. Changing an object, which means appending to a list, setting a dictionary key, or modifying a bytearray, is visible everywhere, because every reference points at the same object. Rebinding a name, which means a plain assignment inside the function, only changes that name, and only inside the function's scope, because the parameter is just a local name.
One more consequence is worth mentioning, and it applies to the return value as well. A function returns a reference to an object and not a copy of it, so if it returns a list that you passed in, then the caller now shares that list with everything else that holds a reference to it.
For an interview, the sentence to land is this one: Python passes objects by reference and rebinds names locally, so changing an argument is visible to the caller but reassigning it is not.