How Do You Swap Variables in Python?

Python can swap two names in a single statement, because the whole right-hand side is worked out before any name on the left is bound again.

a, b = 1, 2
a, b = b, a
print(a, b)          # 2 and 1

# The same trick works with any two values.
x, y = 'hello', 'world'
x, y = y, x
print(x, y)          # world and hello

# It also works with list items addressed by index.
items = ['a', 'b', 'c']
items[0], items[2] = items[2], items[0]
print(items)         # ['c', 'b', 'a']

The mechanism is a tuple on the right-hand side and a tuple pattern on the left. The interpreter builds the tuple (2, 1) and then unpacks it into the two names, so a ends up with the old value of b and b ends up with the old value of a. Because the swap is one single statement, there is never a moment in the middle where both names hold the same value.

The version that uses indexes follows the same rule with subscript targets instead of plain names. Python reads both right-hand subscripts from the original list before it performs either assignment, and that is why the swap comes out correct instead of overwriting items[0] before it has been read.

Two variations are worth knowing. The starred form lets you swap one variable against the rest of a sequence, so first, *rest = items takes the head of the list and leaves the remainder in rest, while head, *tail = items does the opposite. And for reversing a whole list, a, b = b, a is the manual version, while items.reverse() and items[::-1] are the built-in ones.

Because an assignment statement in Python works in two phases. The compiler emits code that works out the entire right-hand side first and pushes the results onto a stack, and only then does it bind those values to the targets on the left. Unpacking a tuple into several names is part of that second phase. So in a, b = b, a the values of b and a are both captured before either name changes, and there is no window in which the old value of a has been overwritten and lost.

The multiple assignment also goes beyond two names. x, y, z = 1, 2, 3 unpacks three values, and if the counts do not match you get a ValueError that says how many values were expected. A starred target lets you take a variable number of them, so head, *middle, tail = [1, 2, 3, 4, 5] gives head the value 1, tail the value 5, and middle the list [2, 3, 4].

A temporary variable is clearer in a few situations. If the swap is one step inside a longer algorithm, then naming the intermediate value reads more like the sequence of steps, and it gives you somewhere to put a comment. It is also the only option when you need to keep a copy of one of the values for later, because the tuple form throws the old values away. And when a reader is not sure whether a multiple assignment hides a side effect, the explicit version removes all doubt.

The honest guidance for an interview is short. Use the tuple form for a simple two-value swap, and reach for a named temporary when the surrounding code needs the value to be visible or when the step needs to be explained.