Why does unpacking two values fail when my list has three items?

In an assignment like this, Python expects the iterable on the right to have exactly as many items as there are targets on the left. Here there are two targets (first and second) but three items, so unpacking fails rather than silently discarding a value. The same mismatch happens if there are too few items. [S1]

If you want the first two values and intentionally want the remaining items grouped separately, make that explicit with a starred target:

first, second, *rest = [10, 20, 30]

Now first is 10, second is 20, and rest is [30]. The starred target collects the items not assigned to the other targets into a list. [S1]

Keeping them is exactly what the starred target does: it receives the remaining items as a list. For the common case where the first two items have specific meanings and anything after them should be grouped together, put the star at the end:

name, score, *notes = ["Rina", 8, "late arrival", "needs review"]

For this input, name becomes "Rina", score becomes 8, and notes becomes ["late arrival", "needs review"].

The starred target can also appear in the middle, with targets after it. For example:

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

Here first gets 10, last gets 40, and middle gets [20, 30]. An unpacking assignment can have one starred target, and the iterable must still have enough items for the targets outside the star. [S1]

With two values, this is valid:

first, second, *rest = [10, 20]

first is 10, second is 20, and rest is []. The starred target can collect an empty list; it does not need to receive an extra item. [S1]

To investigate an unpacking error, count the targets and the items in the value at the moment the assignment runs. Check whether you intended an exact match or meant to collect extras. If a function sometimes returns different numbers of values, decide how each value should be handled instead of assuming Python will discard an extra one. A starred target handles extra items, but the iterable still needs enough items to fill the targets before and after the star. [S1]

Use exact unpacking when the number of items is part of what your code expects. Use a starred target when a variable number of remaining items is intentional and you want them grouped in a list. For example, if the first two entries have defined roles and later entries are optional:

label, value, *extras = ["item", 7]

Here extras is []; if more entries follow, they go into that list. The rule applies to iterable unpacking in assignment statements. It does not tell you what a particular function or data source is supposed to return, so check that separately if the values are unexpected. [S1]