Python Basics: Unpacking

• • Learning Objectives 🎯
• • Master<span>basic unpacking</span>, <span>extended unpacking</span>, <span>dictionary unpacking</span>, and other operations
• • Understand the operation of<span>function parameter unpacking</span>
• • Comprehend its practical applications in data processing

1. Knowledge Points Detailed 📚

1.1 Basic Concept of Unpacking

Unpacking is a powerful and practical feature in Python that allows us to decompose elements from container types (such as lists, tuples, dictionaries, etc.) into independent variables or parameters, thereby simplifying code and enhancing readability.

1.1.1 Basic Unpacking

Definition: Assigning elements from an iterable object (list, tuple, string, etc.) to multiple variables in order.

# List unpacking
colors = ['red', 'blue', 'green']
red, blue, green = colors
print(red)   # 'red'
print(blue)  # 'blue'

# Tuple unpacking
x, y = (10, 20)
print(x)  # 10
print(y)  # 20

# String unpacking
a, b, c = "abc"
print(b)  # 'b'

Notes:

• • The number of variables must match the number of elements, otherwise a<span>ValueError</span> will be raised
• • Supports all iterable objects (lists, tuples, strings, sets, etc.)

1.1.2 Extended Unpacking

Definition: Using the<span>*</span> operator to capture excess elements, handling variable-length sequences.

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

# Handle sequences of arbitrary length
a, *b = [10]
print(a)  # 10
print(b)  # []  # empty list

Features:

• • <span>*</span> variables always return a list, even if there are no elements
• • <span>*</span> can be placed in any position to collect remaining elements
• • Can ignore unwanted elements:<span>a, *_, c = (1, 2, 3)</span>
• • Supports multi-level nested unpacking:

data = [1, [2, 3, 4], (5, 6)]
a, (b, *c), d = data
print(c)  # [3, 4]  # nested list unpacking

1.2 Practical Tips for Unpacking

1.2.1 Dictionary Unpacking

Definition: Dictionary unpacking defaults to unpacking keys, not values

# Dictionary key unpacking
person = {'name': 'Zhang San', 'age': 25}
key1, key2 = person
print(key1)  # 'name'
print(key2)  # 'age'

# Dictionary key-value pair unpacking
for key, value in person.items():
    print(f"{key}: {value}")

1.2.2 Simultaneous Assignment to Multiple Variables

Definition: Using unpacking to swap variables or perform bulk assignments

# Variable swapping (no temporary variable needed)
x, y = 5, 10
x, y = y, x
print(x, y)  # 10 5

# Bulk assignment
(a, b), c = (1, 2), 3
print(b)  # 2

1.2.3 Unpacking in Loops

Definition: Directly unpacking elements from an iterator

# Iterating over a list of tuples
points = [(1, 2), (3, 4), (5, 6)]
for x, y in points:
    print(f"Coordinates: ({x}, {y})")

# Iterating over dictionary items
user_info = {"name": "Xiao Shuai", "age": 30}
for key, value in user_info.items():
    print(f"{key}: {value}")

1.3 Safe Unpacking and Common Errors

1.3.1 Safe Unpacking

Method: Use default values or conditional checks to handle mismatches

# Use *_ to ignore excess elements
data = [1, 2, 3, 4, 5]
a, b, *_ = data  # only take the first two, ignore the rest

# Default value handling
values = [10, 20]
x, y, *rest = values
z = rest[0] if rest else None

1.3.2 Common Errors

1. 1. Element count mismatch:

a, b = [1, 2, 3]  # ValueError: too many values to unpack

1. 2. Unpacking non-iterable objects:

a, b = 100  # TypeError: cannot unpack non-iterable int object

1.4 Comprehensive Application Scenarios

1.4.1 Data Merging

# Merging multiple lists
list1 = [1, 2]
list2 = [3, 4]
combined = [*list1, *list2]  # [1, 2, 3, 4]

# Merging multiple dictionaries
dict1 = {"x": 1}
dict2 = {"y": 2}
merged = {**dict1, **dict2}  # {'x':1, 'y':2}

1.4.2 Data Processing

# Extracting first and last elements
numbers = [10, 20, 30, 40]
first, *_, last = numbers
print(first, last)  # 10 40

1.5 Function Parameter Unpacking (Preliminary Understanding)

Note: This section will be explained in detail in the subsequent function knowledge part, here is just a brief introduction

1.5.1 Basic Concept

Function parameter unpacking allows sequences or dictionaries to be passed as parameters to functions:

• • <span>*</span> is used to unpack sequences (lists/tuples) as positional parameters
• • <span>**</span> is used to unpack dictionaries as keyword parameters

1.5.2 Simple Example

# Positional parameter unpacking
def sum_values(a, b, c):
    return a + b + c

values = [1, 2, 3]
print(sum_values(*values))  # 6

# Keyword parameter unpacking
params = {'a': 10, 'b': 20, 'c': 30}
print(sum_values(**params))  # 60

Notes:

• • The number of parameters must match during unpacking
• • Dictionary unpacking requires key names to match parameter names

2. Example Explanation 🖥️

a, b, c = [1, 2, 3]   #  List unpacking
x, y, z = (4, 5, 6)   #  Tuple unpacking
print(a, b, c)   #  Output: 1 2 3

# Star (*) unpacking
first, *middle, last = [1, 2, 3, 4, 5]
print(middle)  # Output: [2, 3, 4]

# Swapping variable values
a, b = 1, 2
a, b = b, a  # Essentially tuple unpacking

#  Dictionary unpacking
#  Key unpacking
d = {'a': 1, 'b': 2}
k1, k2 = d  # Output: 'a' 'b'
# Key-value pair unpacking
for k, v in d.items():
    print(k, v)  # Output key-value pairs
# Double star (**) unpacking: unpacking dictionary as keyword parameters    
def func(a, b):
    print(a + b)
func(**{'a': 1, 'b': 2})  # Output: 3

3. Exercises ✍️

1. 1. Basic Unpacking Unpack the string<span>"Python"</span> into variables<span>a, b, c, d, e, f</span>, and output the value of<span>d</span>.
2. 2. Extended Unpacking Extract the first and last elements from the list<span>[1, 2, 3, 4, 5]</span>, storing the middle part in<span>mid</span>.
3. 3. Dictionary Merging Merge<span>dict_a = {"x": 1}</span> and <span>dict_b = {"y": 2}</span>, outputting<span>{"x":1, "y":2}</span>.
4. 4. Nested Unpacking Unpack the nested structure<span>[1, [2, 3], 4]</span>, so that the variables<span>a=1, b=2, c=3, d=4</span>

4. Learning Summary 📝

Operation Type	Syntax Example	Core Purpose
Basic Unpacking	<span>a, b = (1, 2)</span>	Multi-variable assignment, variable swapping
Extended Unpacking	<span>first, *rest = [1,2,3,4]</span>	Handling variable-length data
Dictionary Unpacking	<span>key1, key2 = {'a':1, 'b':2}</span>	Accessing dictionary keys or key-value pairs
Loop Unpacking	<span>for k, v in dict.items()</span>	Iterating over key-value pairs
Function Unpacking (Understand)	<span>func(*args, **kwargs)</span>	Dynamic parameter passing (to be detailed later)

5. Reference Answers ✅

# Exercise 1
a, b, c, d, e, f = "Python"
print(d)  # Output: 'h'

# Exercise 2
first, *mid, last = [1, 2, 3, 4, 5]
print(first)  # 1
print(mid)    # [2, 3, 4]
print(last)   # 5

# Exercise 3
dict_a = {"x": 1}
dict_b = {"y": 2}
merged = {**dict_a, **dict_b}
print(merged)  # {'x': 1, 'y': 2}

# Exercise 4
a, (b, c), d = [1, [2, 3], 4]
print(a, b, c, d)  # 1 2 3 4

6. Extended Knowledge 📌

6.1 Packing and Unpacking

• • Packing: Combining multiple values into a tuple

packed = 1, 2, 3  # Automatically packed into tuple (1, 2, 3)

• • Unpacking: Splitting a tuple or list into multiple variables

6.2 Special Symbol<span>_</span> Usage

• • Used to ignore unwanted values:

data = (1, 2, 3, 4)
a, b, _, _ = data  # Only take the first two values

Knowledge Point Assessment Question

a, *b = '123'
c, *d = '123',
a, b = a + c, b + d
print(a, b)

What is the output of the above code? ( ) ❓

• • A. <span>'11' '2323'</span>
• • B. <span>'1123' ['2', '3']</span>
• • C. <span>'11' ['2', '3', '2', '3']</span>
• • D. <span>Error</span>