Summary  
This chapter covers using the `*` operator to pack multiple values into a single iterable and to unpack sequences into individual variables or into function arguments, enabling concise assignments and flexible function calls.

General domain of usage  
Function argument passing

Packing and unpacking with the `*` operator is a powerful feature in Python that allows you to write concise and flexible code, especially when working with lists and tuples. **Packing** refers to collecting multiple values into a single variable, while **unpacking** breaks a collection apart into individual variables or elements. This approach not only makes your code cleaner but also enables you to handle dynamic numbers of values in assignments and function calls. Using the `*` operator, you can easily expand or combine sequences, making your code both readable and efficient.

This code demonstrates how to unpack a tuple into variables and pack multiple values into a tuple using the `*` operator.
Unpacking assigns each element of a tuple to a separate variable, while packing collects remaining elements into a list.


# Unpacking a tuple into variables
coordinates = (10, 20)
coord_x, coord_y = coordinates
print("x:", coord_x)  
print("y:", coord_y)  

# Packing multiple values into a tuple
first_val, second_val, *rest = (1, 2, 3, 4, 5)
print("first_val:", first_val)      
print("second_val:", second_val)     
print("rest:", rest)  

Code unpacks a list into individual arguments when calling a function.
This allows you to pass a sequence as separate arguments, making function calls more flexible.

# Using * to unpack a list into a function call
def add_three_numbers(a, b, c):
    return a + b + c

numbers = [2, 4, 6]
result = add_three_numbers(*numbers)
print(result)  

What does the `*` operator do when used in a function call with a list?

Which of the following is a correct way to unpack a tuple of three elements into three variables in Python?

Master packing/unpacking, flexible function arguments, higher-order functions, lambdas, variable scope, closures, iterators and decorators. Designed for learners who have completed an introductory Python course and want to write more efficient, expressive, and powerful code.

Explore the art of packing and unpacking lists, tuples, and dictionaries to write more expressive and efficient Python code.

Delve into the world of higher-order functions, passing functions as arguments, and writing concise anonymous functions with lambda.

Unravel the mysteries of variable scope, and learn how nested functions and closures enable powerful encapsulation.

Delve into Python's iteration protocol, custom iterators, and generator functions for efficient data processing.

Packing and Unpacking Lists and Tuples

1. What does the `*` operator do when used in a function call with a list?

2. Which of the following is a correct way to unpack a tuple of three elements into three variables in Python?

Packing and Unpacking Lists and Tuples

1. What does the * operator do when used in a function call with a list?

2. Which of the following is a correct way to unpack a tuple of three elements into three variables in Python?

1. What does the `*` operator do when used in a function call with a list?