Unpacking & Star Expressions

Unpacking is assigning the elements of an iterable to multiple variables at once — like a, b, c = [1, 2, 3] — and star expressions let one variable scoop up the rest.

Learn Unpacking & Star Expressions in our free Python course — an interactive lesson with runnable examples, a practice exercise and a quick reference.

Part of the free Python course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

These destructuring tricks make code read like the data it handles: swapping values, splitting a list into head and tail, and spreading collections into function calls and merged dicts.

What You'll Learn in This Lesson

1 Basic Unpacking & the Famous Swap

Assign several variables from one iterable in a single line. The counts must match — and swapping values becomes a one-liner:

⭐ Star Expressions: Grab the Rest

A starred name scoops up however many items are left over into a list . It can go at the start, middle, or end:

Exactly one star is allowed per assignment. The starred variable always becomes a list , even when it captures a single item or nothing at all.

2 Spreading into Calls & Merging Dicts

The same star syntax works into a function call: * spreads an iterable as positional args, ** spreads a dict as keyword args:

🪆 Nested Unpacking

Unpacking patterns can mirror nested structure, pulling apart tuples inside tuples in one go:

The shape of the target on the left must match the shape of the data on the right. When it does, deeply structured data falls neatly into named variables.

🎯 Your Turn: Fill in the Blanks

Replace each ___ with the right unpacking target so the output matches.

Common Errors & How to Fix Them

✅ Match the count exactly, or use a star: a, b, *rest = [1, 2, 3] .

✅ Only one star is allowed per target. Python can't tell where one greedy group ends and the next begins.

✅ A starred target is always a list , even when unpacking a tuple. Convert with tuple(rest) if you need one.

🎯 Mini Challenge: Record Splitter

Use unpacking, stars, and a dict merge to process structured records.

📚 Keep Learning

Go deeper with the official Python documentation:

Frequently Asked Questions

Lesson complete — destructuring mastered!

You can unpack tuples and lists, swap without a temp, scoop up the rest with a star, spread *args and **kwargs into calls, merge dicts with {**d1, **d2} , and destructure nested data.

🚀 Up next: Sorting with sorted() & key — order data any way you like with a custom key function.

Practice quiz

What does do?

  • Assigns the whole list to a
  • Raises an error because you cannot unpack a list
  • Assigns 1 to a, 2 to b, and 3 to c

Answer: Assigns 1 to a, 2 to b, and 3 to c. Unpacking assigns each element of the iterable to the matching variable, as long as the counts match.

How do you swap two variables without a temporary variable?

  • a, b = b, a
  • swap(a, b)
  • a = b; b = a
  • a, b = a, b

Answer: a, b = b, a. a, b = b, a builds a tuple on the right and unpacks it on the left, swapping the values in one line.

After , what is rest?

  • (2, 3, 4, 5)
  • 5

The starred name captures all leftover items into a list, so rest is [2, 3, 4, 5] and first is 1.

What type is the starred target, even when unpacking a tuple?

  • tuple
  • list
  • set
  • str

Answer: list. A starred target is always a list — e.g. first, *rest = (1, 2, 3) makes rest the list [2, 3]. Use tuple(rest) if you need a tuple.

How many starred targets are allowed in a single unpacking assignment?

  • Exactly one
  • Up to two
  • Any number
  • Zero — stars are not allowed

Answer: Exactly one. Only one star is allowed per target; is a SyntaxError because Python cannot tell where one greedy group ends.

What does do when parts = ['Ada', 'wizard', 9]?

  • Passes the list as a single argument
  • Passes parts as keyword arguments
  • Spreads the list as positional arguments: make('Ada', 'wizard', 9)
  • Raises a TypeError

Answer: Spreads the list as positional arguments: make('Ada', 'wizard', 9). In a call, * unpacks an iterable into separate positional arguments, so make(*parts) is the same as make('Ada', 'wizard', 9).

What does do when config = {'name': 'Ben', 'role': 'knight', 'level': 5}?

  • Passes the dict as one positional argument
  • Spreads the dict as keyword arguments: make(name='Ben', role='knight', level=5)
  • Passes only the dict's keys
  • Merges config into make

Answer: Spreads the dict as keyword arguments: make(name='Ben', role='knight', level=5). In a call, ** unpacks a dict into keyword arguments, so make(**config) is make(name='Ben', role='knight', level=5).

What is the result of ?

  • {'size': 'M', 'color': 'black'}
  • size
  • M
  • L

Answer: L. When merging with **, later keys win on conflict, so the second dict's size 'L' overrides the first dict's 'M'.

What does produce?

The * spread expands each list inline, flattening them into a single list [1, 2, 3, 4].

Why does raise an error?

  • Lists cannot be unpacked, only tuples can
  • Variables must be declared first
  • Too many values to unpack — counts must match (or use a star)
  • The list is too long for memory

Answer: Too many values to unpack — counts must match (or use a star). Without a star, the number of targets must equal the number of values. Use a, b, *rest = [1, 2, 3] when lengths differ.

Continue this course