Summary
This chapter covers how to pass arguments to functions by their position and how to unpack dictionaries into function parameters using ** to match arguments by name instead of order.

General domain of usage
user interaction

In Python, **positional arguments** are function arguments passed to a function based on their position or order. When defining a function, you can specify the parameters it expects. When calling the function, you provide the corresponding arguments in the same order as the parameters.

```python
def function_name(argument1, argument2):
    ...
```

In previous chapters, you used positional arguments by placing them in parentheses `()` and calling the function with arguments in the correct order.

### Unpacking Dictionaries as Keyword Arguments
While you can pass arguments individually, Python also allows you to deliver a collection of arguments stored inside a **dictionary**. By prefixing the dictionary with double asterisks () when calling a function, you unpack its key-value pairs directly into the function as keyword arguments.
```python
def function_name(argument1, argument2):
    ...
    
args = {
    'argument1': value1,
    'argument2': value2
}
function_name(**args)
```


The `**` operator will be explained in a later chapter.


Note


Python translates dictionary under the hood into standard keyword arguments. Because this technique uses keyword matching rather than position matching, the order of the keys in your dictionary does not matter. Python will successfully map the dictionary values to the correct function parameters as long as the dictionary keys exactly match the parameter names.

# Function with two positional arguments
def greet(name, age):
    print(f'Hello, {name}! You are {age} years old.')

# Calling the `greet()` function using dictionary
greet(age=25, name='Alex')

# Calling the `greet()` function using ordered values
greet('Alex', 25)

This method of setting arguments is preferable because it enhances the readability and interpretability of the code.

Which statements are true about the function calls?

Gain a solid understanding of how functions shape Python programming. Master defining and calling functions, working with arguments, handling return values, and creating flexible, efficient code using recursion and lambda expressions.

Explore what functions are and why they're essential in Python. Learn how to create functions, define arguments, handle return values, and use built-in functions effectively.

Learn how positional and optional arguments work in Python. Build adaptable functions that handle different inputs and improve flexibility in your code.

Understand how to work with arbitrary and keyword arguments to handle variable input sizes. Learn how these techniques make your functions more dynamic and organized.

Discover how return values represent a function's output. Learn to return single or multiple values, use None, and explore generators for more advanced data flow control.

Unlock advanced function concepts with recursion and lambda functions. Learn how recursion solves repetitive problems and how lambda expressions create concise, one-line functions.

Positional Arguments

Unpacking Dictionaries as Keyword Arguments