If you write Python code, you've probably worked with lists countless times. Lists are incredibly versatile and one of the most popular data structures in Python, whether you're managing collections of items or cooking up complex algorithms. But A large number of Python developers—even the seasoned ones—miss out on a smart trick with lists that can minimize bugs, save time, and make your code more elegant: The unpacking operator (*) in function arguments and assignments.
How People Typically Use Lists
You probably recognize this pattern:
scores = [1, 2, 3, 4, 5]
first_score = scores[0]
second_score = scores[1]
remaining_scores = scores[2:]
Or even:
first, second, third, fourth, fifth = scores
This works fine, but what if you don't know how many items the list will have, or you're only interested in the first item? This is where the unpacking trick shines.
The Magic of the Asterisk (*) Operator
Python allows you to easily unpack list elements into variables using the * operator. It's elegant, flexible, and often easier to understand.
Basic Unpacking Examples
temperatures = [10, 20, 30, 40, 50]
first_temp, *remaining_temps = temperatures
print(first_temp) # Output: 10
print(remaining_temps) # Output: [20, 30, 40, 50]
We can also get only the last item:
*initial_temps, last_temp = temperatures
print(initial_temps) # Output: [10, 20, 30, 40]
print(last_temp) # Output: 50
Both *initial_temps and *remaining_temps hold the "rest" of the list in a new list.
Real-World Applications
1. Handle Variable Number of Function Arguments
def process_values(primary, *additional):
print("Primary:", primary)
print("Additional:", additional)
process_values(1, 2, 3, 4)
Output:
Primary: 1
Additional: (2, 3, 4)
This is perfect for when you can't predict how many arguments will be supplied.
2. Split a List into First, Middle, and Last Parts
def split_sequence(items):
first_item, *middle_items, last_item = items
return first_item, middle_items, last_item
split_result = split_sequence([1, 2, 3, 4, 5])
print(split_result)
Output:
(1, [2, 3, 4], 5)
Without this, you'd need extra logic and slicing.
3. Extract the Last Item from Each Tuple
coordinates = [(1, 2), (3, 4), (5, 6)]
for *x_values, y_value in coordinates:
print("X values:", x_values, "Y value:", y_value)
This is handy when tuples have varying structures but you're interested only in the last element.
Merge Multiple Lists Together
The * operator also helps in merging lists in a clean style:
fruits = [1, 2]
vegetables = [3, 4]
all_items = [*fruits, *vegetables]
print(all_items) # Output: [1, 2, 3, 4]
Dictionary Unpacking with **
While * works with iterables, its cousin ** unpacks dictionaries:
defaults = {'color': 'blue', 'size': 'medium'}
custom = {'color': 'red', 'weight': 10}
merged = {**defaults, **custom}
print(merged) # Output: {'color': 'red', 'size': 'medium', 'weight': 10}
Creating Copies and Extending Lists
The * operator provides a clean way to create shallow copies:
original = [1, 2, 3]
copy = [*original]
extended = [0, *original, 4, 5]
print(copy) # Output: [1, 2, 3]
print(extended) # Output: [0, 1, 2, 3, 4, 5]
Unpacking in Set and Tuple Literals
The operator works with other data structures too:
list1 = [1, 2, 3]
list2 = [3, 4, 5]
combined_set = {*list1, *list2}
combined_tuple = (*list1, *list2)
print(combined_set) # Output: {1, 2, 3, 4, 5}
print(combined_tuple) # Output: (1, 2, 3, 3, 4, 5)
Ignoring Values with * and _
When you don't need certain values, combine * with _:
data = [1, 2, 3, 4, 5, 6, 7]
first, second, *_, last = data
print(first) # Output: 1
print(second) # Output: 2
print(last) # Output: 7
Unpacking Nested Structures
The * operator can handle complex nested unpacking:
nested = [[1, 2], [3, 4], [5, 6]]
flattened = [*nested[0], *nested[1], *nested[2]]
print(flattened) # Output: [1, 2, 3, 4, 5, 6]
# Or with a comprehension
flattened = [item for sublist in nested for item in sublist]
Conclusion
The unpacking operator (*) is a small but mighty feature that can transform how you work with lists in Python. It eliminates verbose indexing, handles variable-length data gracefully, and makes your code more readable. Next time you find yourself manually slicing lists or writing complex logic to extract elements, remember this simple trick. Start using it today, and you'll wonder how you ever coded without it!