Extended Unpacking with the Asterisk Operator

One Sequence, Several Names

Unpacking lets one statement assign several variables from the elements of a sequence. Instead of retrieving each element separately by index, you place several receiving names on the left side of the assignment. Python then matches those names with the sequence elements.

How the Starred Name Collects Elements

Extended unpacking adds an asterisk before one receiving name. The names before and after the starred name receive their corresponding elements, while the starred name collects the remaining elements between them. This is useful when the sequence has more elements than the fixed names can receive individually.

values = [10, 20, 30, 40]
first, *middle, last = values

first is 10, middle is [20, 30], and last is 40.

Unpacking as Indexed Assignment

Unpacking is syntactic sugar for index-based assignment. In other words, the compact unpacking statement represents the same element-by-element relationship that you could express by selecting sequence elements by their indexes. The unpacking form emphasizes the order of the values without writing each index separately.

items = [10, 20, 30] first, second, third = items

Matching Names to Elements

Without a starred receiving name, the number of variables must exactly match the number of elements in the sequence. Too few or too many names creates a mismatch, and the mismatch causes a ValueError. A starred name changes this rule by receiving the remaining elements, so the fixed names do not each need a one-to-one match with every element.

• Using fewer names than sequence elements without a starred name

  There are three elements but only two receiving names, so the counts do not match.

  Fix: Use three receiving names, or use a starred name when one variable should collect the remaining elements.

• Using more names than sequence elements

  The sequence does not contain enough elements to supply every receiving name.

  Fix: Make the number of names match the number of elements, or redesign the assignment with a starred name where appropriate.

• Forgetting that order controls the assignment

  The first name receives the first element and the last name receives the last element; the starred name receives the elements between them.

  Fix: Read the receiving names from left to right and identify which name is intended to collect the remaining elements.

Tuples, Lists, and Strings

The same unpacking idea works with tuples, lists, strings, and any sequence type. What changes is the sequence being unpacked; the assignment pattern remains the same. With a string, the sequence elements are its characters, so each receiving name is assigned a character according to its position.

point = (3, 4)
x, y = point

letters = "CAT"
first, *middle, last = letters

x is 3, y is 4, first is "C", middle contains ["A"], and last is "T".

Practice the Pattern

Reliable Unpacking Habits

• Count the sequence elements and receiving names before using ordinary unpacking.
• Use a starred receiving name when one variable should collect the remaining elements.
• Read the assignment from left to right so each fixed name is connected with the intended sequence position.
• Remember that the same unpacking pattern can be applied to tuples, lists, strings, and other sequence types.
• When debugging a ValueError, first check whether the number of variables exactly matches the number of elements or whether a starred name is needed.

1. Unpacking assigns multiple variables from a sequence in one statement. Ordinary unpacking requires an exact match between receiving names and sequence elements. Extended unpacking uses an asterisk before one receiving name so that name collects the remaining elements. The pattern works across tuples, lists, strings, and other sequence types, and it represents the same positional relationship as index-based assignment.