Packing & Unpacking: Flexible Python Assignment Guide

Packing and unpacking are two sides of the same coin. Packing lets you group several values into a single variable; unpacking lets you pull them apart into individual variables in one line. Together they eliminate temporary variables, make your intent explicit, and unlock the expressive style Python is known for.

Tuple Packing

When you assign multiple comma-separated values to a single variable, Python automatically groups them into a tuple — no parentheses required. This is called packing.

# Python creates a tuple behind the scenes
person = "Alice", 25, "Engineer"

print(person)        # ('Alice', 25, 'Engineer')
print(type(person))  # <class 'tuple'>

Parentheses are optional but often added for clarity:

coordinates = (37.7749, -122.4194)   # latitude, longitude

Basic Unpacking

Unpacking is the reverse: you extract every element of a collection and assign each one to its own variable, all in a single statement.

person = ("Alice", 25, "Engineer")

name, age, profession = person

print(name)        # Alice
print(age)         # 25
print(profession)  # Engineer

This works with any iterable — lists, tuples, strings, and more:

first, second, third = [10, 20, 30]
a, b, c = "XYZ"

print(first, second, third)  # 10 20 30
print(a, b, c)               # X Y Z

The number of variables on the left must exactly match the number of elements on the right. A mismatch raises a ValueError.

x, y = (1, 2, 3)   # ValueError: too many values to unpack
a, b, c = (1, 2)   # ValueError: not enough values to unpack

Star Unpacking with `*rest`

Real data rarely has a fixed length. The * (star) operator lets you capture any number of remaining elements into a list, freeing you from counting elements manually.

numbers = [1, 2, 3, 4, 5]

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

You can place the starred variable anywhere — beginning, middle, or end:

# Capture the last element
*body, last = [10, 20, 30, 40]
print(body)   # [10, 20, 30]
print(last)   # 40

# Capture the middle
head, *middle, tail = "Python"
print(head)    # P
print(middle)  # ['y', 't', 'h', 'o']
print(tail)    # n

You can only use one starred expression per assignment. Using two raises a SyntaxError:

*a, b, *c = [1, 2, 3, 4]  # SyntaxError

Ignoring Values

Use _ to discard elements you don’t need:

first, _, third = (10, 99, 30)   # ignore the middle value
name, *_, last_score = ("Alice", 88, 91, 74, 65)  # ignore middle scores
print(name, last_score)  # Alice 65

Practical Use Cases

Swapping Variables

The classic swap — no temporary variable needed:

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

This works because Python evaluates the right-hand side completely before assigning.

Returning Multiple Values from a Function

Functions can return multiple values as a tuple, and callers can unpack them immediately:

def stats(numbers):
    return min(numbers), max(numbers), sum(numbers) / len(numbers)

low, high, avg = stats([4, 8, 15, 16, 23, 42])
print(f"Min: {low}, Max: {high}, Avg: {avg:.1f}")
# Min: 4, Max: 42, Avg: 18.0

Spreading a List into a Function Call

Use * to unpack a list as positional arguments:

def greet(first, middle, last):
    print(f"Hello, {first} {middle} {last}!")

parts = ["John", "Michael", "Doe"]
greet(*parts)  # Hello, John Michael Doe!

Use ** to unpack a dictionary as keyword arguments:

def create_user(name, age, role):
    print(f"{name} ({age}) — {role}")

config = {"name": "Alice", "age": 25, "role": "admin"}
create_user(**config)  # Alice (25) — admin

Merging Dictionaries

The ** operator also merges dictionaries:

defaults = {"theme": "light", "lang": "en", "debug": False}
overrides = {"theme": "dark", "debug": True}

settings = {**defaults, **overrides}
print(settings)
# {'theme': 'dark', 'lang': 'en', 'debug': True}

Later keys override earlier ones, so put your defaults first.

`*args` in Function Definitions

When you define a function, *args collects any number of extra positional arguments into a tuple:

def total(*amounts):
    return sum(amounts)

print(total(10, 20))           # 30
print(total(5, 15, 25, 45))   # 90

You can mix regular parameters with *args:

def log(level, *messages):
    for msg in messages:
        print(f"[{level}] {msg}")

log("INFO", "Server started", "Listening on port 8000")
# [INFO] Server started
# [INFO] Listening on port 8000

`**kwargs` in Function Definitions

**kwargs collects any number of extra keyword arguments into a dictionary:

def display_profile(**details):
    for key, value in details.items():
        print(f"  {key}: {value}")

display_profile(name="Alice", age=25, role="admin")
# name: Alice
# age: 25
# role: admin

Combining `*args` and `**kwargs`

A function that accepts any combination of arguments:

def flexible(required, *args, **kwargs):
    print(f"Required: {required}")
    print(f"Extra positional: {args}")
    print(f"Keyword args: {kwargs}")

flexible("hello", 1, 2, 3, color="red", size=10)
# Required: hello
# Extra positional: (1, 2, 3)
# Keyword args: {'color': 'red', 'size': 10}

Unpacking in Loops

Unpacking inside a for loop makes iterating over structured data clean and self-documenting:

# List of (name, score) pairs
results = [("Alice", 91), ("Bob", 74), ("Carol", 88)]

for name, score in results:
    print(f"{name}: {score}")

# With enumerate — get both index and value
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# Iterating a dictionary
ages = {"Alice": 25, "Bob": 30}
for name, age in ages.items():
    print(f"{name} is {age} years old")

Common Errors and Fixes

ValueError: too many values to unpack

More elements than variables on the left side.

# Wrong
a, b = (1, 2, 3)

# Fix: add more variables or use * to capture the rest
a, b, c  = (1, 2, 3)
a, b, *_ = (1, 2, 3)

ValueError: not enough values to unpack

More variables than elements on the right side.

# Wrong
a, b, c = (1, 2)

# Fix: match the number of variables to elements
a, b = (1, 2)

SyntaxError: multiple starred expressions

Only one * is allowed per unpacking assignment.

# Wrong
*a, b, *c = [1, 2, 3, 4]

# Fix: use one * only
*a, b = [1, 2, 3, 4]

End-to-End Example

The following function parses a CSV line and uses star unpacking to separate the header from the data:

def parse_record(csv_line):
    """Parse a CSV line into a (name, scores) tuple."""
    parts = csv_line.split(",")
    name, *score_strings = parts
    scores = [int(s.strip()) for s in score_strings]
    return name.strip(), scores


line = "Alice, 88, 92, 79, 95"
student, scores = parse_record(line)

best, *rest = sorted(scores, reverse=True)
print(f"Student : {student}")
print(f"Top score: {best}")
print(f"Average  : {sum(scores) / len(scores):.1f}")

Output:

Student : Alice
Top score: 95
Average  : 88.5

Core Python

Advanced Python

Pydantic

Packing & Unpacking: Flexible Python Assignment Guide

Tuple Packing

Basic Unpacking

Star Unpacking with `*rest`

Ignoring Values

Practical Use Cases

Swapping Variables

Returning Multiple Values from a Function

Spreading a List into a Function Call

Merging Dictionaries

`*args` in Function Definitions

`**kwargs` in Function Definitions

Combining `*args` and `**kwargs`

Unpacking in Loops

Common Errors and Fixes

End-to-End Example

​Tuple Packing

​Basic Unpacking

​Star Unpacking with *rest

​Ignoring Values

​Practical Use Cases

​Swapping Variables

​Returning Multiple Values from a Function

​Spreading a List into a Function Call

​Merging Dictionaries

​*args in Function Definitions

​**kwargs in Function Definitions

​Combining *args and **kwargs

​Unpacking in Loops

​Common Errors and Fixes

​End-to-End Example

Tuple Packing

Basic Unpacking

Star Unpacking with `*rest`

Ignoring Values

Practical Use Cases

Swapping Variables

Returning Multiple Values from a Function

Spreading a List into a Function Call

Merging Dictionaries

`*args` in Function Definitions

`**kwargs` in Function Definitions

Combining `*args` and `**kwargs`

Unpacking in Loops

Common Errors and Fixes

End-to-End Example