Immutability and Tuples

The One-Line Exchange

Swapping two values is a fundamental programming operation. You may need to exchange two numbers, change player positions, sort values, or rearrange data. Python provides a concise form of tuple assignment for this task: a, b = b, a. The statement makes a receive b's original value and b receive a's original value, without requiring a separately named temporary variable.

Evaluation Before Assignment

The crucial mechanism has two phases. First, Python evaluates every expression on the right side of the assignment. For a, b = b, a, it looks up the current value of b and the current value of a, producing the tuple (10, 5) when b is 10 and a is 5. Only after the right side has been fully evaluated does Python assign the values to the names on the left. This order preserves both original values before either variable changes.

Positional Matching

After the right side has been evaluated, tuple assignment matches values by position. The first value in the evaluated tuple is assigned to the first name on the left, and the second value is assigned to the second name. In the swap, the right side is (b's value, a's value), so the first position goes to a and the second position goes to b.

Preserving Both Values

The evaluated tuple acts as the preserved collection of right-side values during this assignment. In the example, (10, 5) contains b's original value followed by a's original value. Python then unpacks those positions into the left-side names. The important distinction is between creating the evaluated tuple for the assignment and changing an existing tuple: the swap relies on preserving the evaluated values while assignment takes place.

Swapping in Practice

Tuple swapping is useful whenever two related values must exchange positions. The source identifies sorting algorithms, data rearrangement, and exchanged player positions as practical settings. In each case, the same reasoning applies: evaluate both current values first, then assign them to their opposite destinations.

Mistakes During a Swap

• Treating the statement as two immediate assignments performed from left to right.

  The right side is evaluated completely before any left-side assignment occurs.

  Fix: Trace the right side first: read b, read a, form the ordered values, and then assign them by position.

• Assuming that a's original value disappears when a changes.

  The original value has already been preserved among the evaluated right-side values.

  Fix: Remember that the evaluated tuple contains (10, 5) before either name is updated.

• Using a longer temporary-variable sequence when a direct exchange is intended.

  The sequence can work, but it takes more code to express the same exchange.

  Fix: Use a, b = b, a when a concise, recognizable tuple swap fits the problem.

• Ignoring positional matching.

  Assignment matches positions: the first right-side value goes to the first left-side name.

  Fix: Map position 0 to the first left-side name and position 1 to the second.

Check Your Trace

1. A correct trace says that Python first evaluates both right-side expressions, producing the ordered values b's value and a's value. It then assigns the first value to a and the second value to b. Because both original values were available before assignment, neither is overwritten prematurely.

Key Takeaways

1. The statement a, b = b, a swaps two variable values in one line. Python evaluates all right-side expressions before changing any left-side names. The resulting tuple preserves the original values, and positional matching sends the first value to a and the second to b. This avoids the overwriting problem of poorly ordered sequential assignments and provides a concise, readable way to exchange values in sorting and data rearrangement.