How Do Variables Reference Objects in Python?

In Python a variable is a name that is bound to an object. Assigning to a name creates or rebinds that binding, and it never copies the object. Two names that are bound to the same list are simply two labels on one single object.

first = [1, 2, 3]
second = first
second.append(4)

print(first)            # [1, 2, 3, 4]
print(first is second)  # True, one object and two names

third = first
third = [9]             # this rebinds the NAME and creates a new list

print(first)            # [1, 2, 3, 4], untouched
print(third)            # [9]
print(first is third)   # False

The two operations are worth naming separately, because they are different verbs in Python. Mutating an object, which means using append(), extend(), update() or item assignment, changes what every name bound to that object sees. Rebinding a name, which means a plain assignment, changes only that one name, and the object that it used to point at keeps existing for whoever else refers to it.

The third line is the one that trips people up. The names first, second and third all start out bound to one list, but the last assignment moves third onto a brand new list, and first and second carry on pointing at the original one.

This is also why you never need to write a manual copy. If you want an independent copy of a list, then slice it or call list() on it. If you want a copy of a nested structure, then you need copy.deepcopy, because a shallow copy still shares the inner objects.

id() returns the memory address of an object, and it is the quickest way to show that two different names can point at the same object. Pay attention to the order of the output below, because the two ids are identical for the two names that are bound to one object, and they are different for a copy.

number = 42
alias = number
print('same object:', alias is number)
print('ids:', id(number), id(alias))

items = [1, 2]
copy = items[:]
print('slice is a new object:', copy is not items)
print('but equal in value:', copy == items)

The "same object" line prints True and the two ids match exactly. The slice line prints True for the identity check and True for the equality check, and that is the whole distinction in one place. The copy is equal to items because they hold the same values, but it is not items because it is a different list object with its own storage.

The id() values themselves are an implementation detail. They are memory addresses today, they can be reused after an object has been freed, and nothing in Python guarantees that they stay unique for the whole life of the program. That is exactly why the is operator exists. It compares identity without exposing the address, and it is the only correct way to test whether two names refer to the same object.

For an interview, the phrasing to use is that a Python variable is a name bound to an object, where the object owns the data and the name is only a reference. Try to avoid saying that a variable stores a value, because that invites the wrong mental model and the wrong answers about aliasing.

The copy model is wrong because Python works out the right-hand side into an object and then binds the name to that object. No copy is made at the moment of assignment. When you write b = a and a holds a list, then b becomes another name for the same list, and the number of references to that list goes up by one.

That single fact explains the whole family of aliasing bugs. A function that appends to its list argument is not filling a private copy, it is filling the caller's list, because the function received a reference to the same object. A class instance that stores a list attribute shares that list with anybody it was handed. A default argument of [] is created once when the function is defined, so every call that changes it sees the state that has built up over time.

The distinction also explains why some operations surprise you. The plus operator on two lists builds a brand new list, so a = a + [4] rebinds a, while a.append(4) changes the shared object in place. The augmented assignment form a += [4] is a rebind and not a mutation, even though it looks like one. In the same way, list.sort() and list.reverse() change the list in place and give back None, while sorted() and reversed() give you a new list.

The interview-ready conclusion is that variables in Python are references, that mutation is shared, and that copying has to be asked for explicitly. Say that, and then follow it with copy.copy for a shallow copy and copy.deepcopy for a nested one, and you have answered the question properly.