Multiple Assignment

diagram a = b = [] and a, b = [], [] are not the same statement mermaid

  flowchart TD
  A["a = b = []"] --> B["ONE list is created"]
  B --> C["a and b both point at it"]
  C --> D["a.append(1)  ->  b is [1] too"]
  E["a, b = [], []"] --> F["TWO lists are created"]
  F --> G["a and b are independent"]
  G --> H["a.append(1)  ->  b is still []"]
  D --> I["fine for 0, None or a string -- they cannot be changed"]
  D --> J["a bug waiting for any mutable value"]

Chained assignment evaluates the right-hand side once and binds every name to that one object. With an immutable value nothing can go wrong. With a list, a dict or a set, both names now refer to the same container, so appending through one appears through the other.

Verified: chained assignment shares one object

python

a = b = []
a.append(1)
# a == [1]   b == [1]   a is b -> True
 
x, y = [], []
x.append(1)
# x == [1]   y == []    x is y -> False

a = b = [] reads as “make two empty lists” and does not. The right-hand side is evaluated once, and both names are bound to that single object.

It is harmless for immutable values — i = j = 0 is fine, because nothing can modify 0. It goes wrong the moment the value is a list, dict or set, and it goes wrong silently: the second variable simply starts showing changes you made through the first.

The same mechanism is behind the mutable-default-argument trap, and behind grid = [[0] * 3] * 3, where all three rows are one list — setting grid[0][0] changes every row.

Many Values to Multiple Variables

We can assign multiple values to multiple variables in one line. This is called multiple assignment.

Example:

variable.py

# Multiple assignment
a, b, c = 10, 20.5, "Hello, World!"
print(a, b, c)

Output

command

C:\Users\Your Name> python variable.py
10 20.5 Hello, World!

Caution

The number of variables on the left and the number of values on the right must be the same.

One Value to Multiple Variables

We can assign one value to multiple variables in one line. This is called one value to multiple variables.

Example:

variable.py

# One value to multiple variables
a = b = c = 10
print(a, b, c)

Output

command

C:\Users\Your Name> python variable.py
10 10 10

Multiple Values to One Variable

We can assign multiple values to one variable in one line. This is called multiple values to one variable.

Example:

variable.py

# Multiple values to one variable
a = 10, 20, 30
print(a)

Output

command

C:\Users\Your Name> python variable.py
(10, 20, 30)

In this case, the variable a is a tuple.

Unpacking a Tuple

We can unpack a tuple in multiple variables. This is called unpacking a tuple.

Example:

variable.py

# Unpacking a tuple
a = 10, 20, 30
x, y, z = a
print(x, y, z)

Output

command

C:\Users\Your Name> python variable.py
10 20 30

Unpacking a List

We can unpack a list in multiple variables. This is called unpacking a list.

Example:

variable.py

# Unpacking a list
a = [10, 20, 30]
x, y, z = a
print(x, y, z)

Output

command

C:\Users\Your Name> python variable.py
10 20 30

Extended Unpacking with *

When you do not know (or do not care) how many items are in the middle, a starred variable * captures the rest as a list. This is called extended unpacking.

star_unpack.py

numbers = [1, 2, 3, 4, 5]
 
first, *rest = numbers
print(first, rest)        # 1 [2, 3, 4, 5]
 
first, *middle, last = numbers
print(first, middle, last)  # 1 [2, 3, 4] 5

Swapping Variables

Multiple assignment gives Python an elegant one-line swap — no temporary variable needed. The right-hand side is built into a tuple first, then unpacked.

swap.py

a, b = 5, 10
a, b = b, a
print(a, b)   # 10 5

Caution

The count must match (unless you use *). Too few or too many values raises a ValueError:

mismatch.py

x, y = 1, 2, 3   # ValueError: too many values to unpack (expected 2)

---

sketch a = b = [] makes one list, not two p5.js Pause Restart

The right-hand side is evaluated once, and every name in the chain is bound to that single object. Append through one name and the other shows it, because there is nothing else to show. Compare it with the tuple-unpacking form, which evaluates the brackets twice and really does make two lists.

Check yourself

pch.quizTag pch.quizDefaultTitle

1. `a = b = []` then `a.append(1)`. What is `b`?

   A `[]` B `[1]` C `None` D It raises
   pch.quizShowAnswer

   B — `[1]` — The right-hand side is evaluated once and both names are bound to that single list. Measured: `a is b` is True. `x, y = [], []` creates two lists instead.

2. Why is `i = j = 0` harmless while `a = b = []` is a trap?

   A Integers are copied on assignment B `0` cannot be modified, so sharing it can never be observed C Small integers are cached D It is not — both are traps
   pch.quizShowAnswer

   B — `0` cannot be modified, so sharing it can never be observed — Sharing only matters when the shared object can change. Immutable values — numbers, strings, tuples — are safe to share because nothing can mutate them.

3. `grid = [[0] * 3] * 3` then `grid[0][0] = 9`. What is `grid`?

   A `[[9,0,0], [0,0,0], [0,0,0]]` B `[[9,0,0], [9,0,0], [9,0,0]]` C It raises D `[[9,0,0], [0,0,0], [9,0,0]]`
   pch.quizShowAnswer

   B — `[[9,0,0], [9,0,0], [9,0,0]]` — Verified. `* 3` repeats the reference, not the row, so all three names point at one list. Build it with a comprehension instead: `[[0]*3 for _ in range(3)]`.

4. Which statement creates two independent lists?

   A `a = b = []` B `a, b = [], []` C `a = b = list()` D `a = []; b = a`
   pch.quizShowAnswer

   B — `a, b = [], []` — Only the tuple-unpacking form evaluates `[]` twice. The others all bind one object to two names.

Try it: Multiple Assignment Exercises

Exercise 1 – Assign Same Value to Multiple Variables

pch.exerciseTag pch.exerciseTitle

Exercise 2 – Tuple Unpacking

pch.exerciseTag pch.exerciseTitle

Exercise 3 – Assign from a List

pch.exerciseTag pch.exerciseTitle