Learn about using the Python 3 unpacking operators (`*` & `**`) to create flexible function arguments and much more! 

Function Arguments

In Python, there are three common types of function arguments: 

- Positional arguments: arguments that are called by their position in the function definition.
- Keyword arguments: arguments that are called by their name.
- Default arguments: arguments that are given default values.

To recap, here is what each of these argument types looks like: 

- Positional Arguments
  ```py
  def print_name(first_name, last_name): 
    print(first_name, last_name)

  print_name('Jiho', 'Baggins')
  ```
  Here, `first_name` will be mapped to `'Jiho'` while `last_name` will be mapped to `'Baggins'` due 
  to the position of the arguments when calling the function. 

- Keyword Arguments 
  ```py
  def print_name(first_name, last_name): 
    print(first_name, last_name)

  print_name(last_name='Baggins', first_name='Jiho')
  ```
  Here, we are using the parameter names `first_name` and `last_name` as keyword arguments in the function call. 
  Notice the order of the arguments does not matter since they are assigned a specific name.

- Default arguments 
  ```py
  def print_name(first_name='Jiho', last_name='Baggins'): 
    print(first_name, last_name)

  print_name()
  ```
  Here, in the function definition, we assign default values to the parameters. This means we can call our 
  function without providing any arguments because they will have a value to fall back onto.  

While these are the most common argument types, in this lesson, we will explore what happens when we want to make our function arguments more flexible by taking a varying number of arguments.

Before we jump into learning more about variable argument types, let's review the most common types to get warmed up.

Function Arguments: A Recap 

Working with `**kwargs` looks very similar to its `*args` counterpart. Since `**` generates a standard dictionary, we can use iteration just like we did earlier by taking advantage of the `.values()` method. Here is an example:  
```py
def print_data(**data):
  for arg in data.values():
    print(arg)

print_data(a='arg1', b=True, c=100)
```

Would output: 
```
arg1
True
100
```

We can also combine our use of `**` with regular positional arguments. However, Python requires that all positional arguments come first in our function definition. Let's examine how this works: 
```py
def print_data(positional_arg, **data):
  print(positional_arg)
  for arg in data.values():
    print(arg)

print_data('position 1', a='arg1', b=True, c=100)
```
Would output: 
```
position 1
arg1
True
100
```
If we were to switch the position of `positional_arg` to come after `**data`, we would be met with a `SyntaxError`.

Let's expand our restaurant application from the previous exercises to apply the flexibility of using `**kwargs` in our functions. 

Working with **kwargs

We covered a lot of ground in this lesson! We learned all about how functions can accept different arguments and different styles in which we can pass those arguments in. We learned:

* How to pack positional arguments in a function with `*args`.
* How to work with `*args` using iteration and other positional arguments.
* How to pack keyword arguments in a function with `**kwargs`.
* How to work with `**kwargs` using iteration and other keyword arguments.
* How to combine all different types of arguments to gain the most flexibility in our function declarations.
* How to use an unpacking operator (`*` or `**`) to unpack arguments in a function call.
* How to use an unpacking operator (`*` or `**`) on iterables. 

We should now be able to read many different styles of function writing in Python and come up with ways to call those functions with style and clarity.

Review

Now that we have seen the basics of working with positional argument unpacking let's examine how to use it in a more meaningful way. 

Say we wanted to build a function that works similarly to our trusty `print()` statement but instead prints all of the arguments in uppercase form. Using our knowledge of iteration, combined with the power of the unpacking operator, our solution might look like this: 

```py
def shout_strings(*args):
  for argument in args:
    print(argument.upper())

shout_strings('Working on', 'learning', 'argument unpacking!')
```

Would output: 
```bash
WORKING ON
LEARNING
ARGUMENT UNPACKING!
```

In our function `shout_strings()`, we use a `for` loop (although we could use any iterator) to iterate through each element of the tuple that exists inside of `args`. Then we use the built-in function `.upper()` to capitalize each argument.

The unpacking operator is not limited to being used alone, but rather it can be combined with other positional arguments. Let's examine a function that truncates (cuts off) sentences based on a provided length: 

```py
def truncate_sentences(length, *sentences):
  for sentence in sentences:
    print(sentence[:length])

truncate_sentences(8, "What's going on here", "Looks like we've been cut off")
```

Would output: 
```bash
What's g
Looks li
```

Let's break this down: 

- We have two parameters that our function `truncate_sentences()` defines. The first is a `length` parameter that will specify how many characters we want to keep. The second is a parameter called `sentences` that is paired with the unpacking operator, signifying it will take a variable number of arguments. 

- On each iteration of the function, we are looping through the tuple created by the `sentences` argument (because it is paired with the unpacking operator) and performing a slice on the sentence based on the provided `length` argument. This forces every value in the `sentences` tuple to be cut down in length.
	
Utilizing iteration and other positional arguments are two common ways we can increase the utility of our functions when using the unpacking operator (*). Let's practice using these techniques to see how powerful they are!

Working with *args

So far we have seen how both `*args` and `**kwargs` can be combined with standard arguments. This is useful, but in some cases, we may want to use all three types together! Thankfully Python allows us to do so as long as we follow the correct order in our function definition. The order is as follows:  

1. Standard positional arguments
2. `*args`
3. Standard keyword arguments
4. `**kwargs`

As an example, this is what our function definition might look like if we wanted a function that printed animals utilizing all three types: 

```py
def print_animals(animal1, animal2, *args, animal4, **kwargs):
  print(animal1, animal2)
  print(args)
  print(animal4)
  print(kwargs)
```

We could call our function like so: 
```py
print_animals('Snake', 'Fish', 'Guinea Pig', 'Owl', animal4='Cat', animal5='Dog')
```

And our result would be: 
```bash
Snake Fish
('Guinea Pig', 'Owl')
Cat
{'animal5': 'Dog'}
```

That is a whole lot of arguments! Let's break it down: 

- The first two arguments that our function accepts will take the form of standard positional arguments. When we call the function, the first two values provided will map to `animal1` and `animal2`. Thus, the first line of output is `Snake Fish`

- The non-keyword arguments that follow after `Snake` and `Fish` in our function call are all mapped to the `args` tuple. Thus, our result is `('Guinea Pig', 'Owl')`

- Then we transition to regular keyword arguments. Since we called `animal4` as a keyword, our result for the print statement is `Cat`

- Lastly, we have one more keyword argument that is mapped to `**kwargs`. Thus, our last line of output is `{'animal_5': 'Dog'}`

Let's practice putting it all together in our restaurant application for Jiho! 

All together now! 

Python doesn’t stop at allowing us to accept unlimited positional arguments; it also gives us the power to define functions with unlimited keyword arguments. The syntax is very similar but uses two asterisks `**` instead of one. We typically call these `kwargs` as a shorthand for keyword arguments.

Let's examine a function that prints out some useful information about `kwargs` to see it in action: 
```py
def arbitrary_keyword_args(**kwargs):
  print(type(kwargs))
  print(kwargs)
  # See if there's an 'anything_goes' keyword arg and print it
  print(kwargs.get('anything_goes'))

arbitrary_keyword_args(this_arg='wowzers', anything_goes=101)
```

Would output: 

```bash
<class 'dict'>
{'this_arg': 'wowzers', 'anything_goes': 101}
101
```

We can observe two things: 

- `**kwargs` takes the form of a dictionary with all the keyword argument values passed to `arbitrary_keyword_args`. Since `**kwargs` is a dictionary, we can use standard dictionary functions like `.get()` to retrieve values. 

- Just as we saw with `*args`, the name of `kwargs`  is completely arbitrary, and this example works exactly the same with the name becoming `data`: 

  ```py
  def arbitrary_keyword_args(**data):
    # ...
  ```

Let's practice using `**kwargs` to get a feel of how it works in a function! 


Variable number of arguments: **kwargs 

To start exploring variable argument lengths in Python functions, let's take a look at a familiar function we have been using for a long time: 

```py
print('This', 'is', 'the', 'print', 'function')
```

Notice how the `print()` function does not care how many arguments we pass to it. It has no expectation that we are going to pass in one argument or even a million! So the question is, how does `print()` accomplish this?  

Well, in Python, there is an additional operator called the _unpacking operator_ (*). The unpacking operator allows us to give our functions a variable number of arguments by performing what's known as _positional argument packing_. 

Let's explore how it works by examining a basic function that utilizes the unpacking operator: 
```py
def my_function(*args):
  print(args)
```

If we called this function with random arguments: 
```py
my_function('Arg1', 245, False)
```

Our output would show us what is inside of `*args`: 
```bash
('Arg1', 245, False)
```

Notice two things: 

- In our `print()` call, we simply use the name of `args` with the unpacking operator omitted. The name of `args` is completely arbitrary, and this example works just the same: 
  ```py
  def my_function(*randomname):
    print(randomname)
  ```

- Whatever name follows the unpacking operator (*) will store the arguments passed into the function in the form of a tuple. This allows our functions to accept any number of arguments just like the `print()` function we examined earlier. In this case, `args` has three values inside, but it can have many more (or fewer).

Let's practice using the unpacking operator for positional arguments in a function! 

Variable number of arguments: *args

Hopefully, by now, we have started to see the power of using the `*` and `**` operators in our function definitions. However, Python doesn't stop there! Not only can we use the operators when defining parameters, but we can also use them in function calls. 

Let's imagine we want to sum a few numbers together: 
```py
def sum(num1, num2, num3):
  print(num1 + num2 + num3)
```

Right now, our function forces us to pass in an individual argument for `num1`, `num2`, and `num3`. This isn't a big issue if we have separate variables or know our numbers in advance. However, what if we wanted to use a list like `[3, 6, 9]` instead? Well, that is where the unpacking operator comes to the rescue. 

Let's observe: 
```py
my_num_list = [3, 6, 9]

def sum(num1, num2, num3):
  print(num1 + num2 + num3)

sum(*my_num_list)
```

Would output: 
```bash
18
```

So what's happening here? Well, by using the unpacking operator (*) we are spreading the contents of our list `my_num_list` into the individual arguments in our function definition. We are immediately saved the hassle of writing loops and are given the flexibility to use any iterable with three elements. 

This way of using the `*` in a function call also applies to our keyword operator `**`. As long as the keywords match the function parameter names, we can accomplish the same goal: 

```py
numbers  = {'num1': 3, 'num2': 6, 'num3': 9}

def sum(num1, num2, num3):
  print(num1 + num2 + num3)

sum(**numbers)
```

Would output: 
```bash
18
```

We can even use the operators inside of built-in functions. For example, instead of manually providing the `range()` built-in function with a start and stop value, we can unpack a list directly into it. Let's take a look: 

```py
start_and_stop = [3, 6]

range_values = range(*start_and_stop)
print(list(range_values))
```

Would output:
```bash
[3, 4, 5]
```

The possibilities of using the `*` and `**` operators are endless. Observe some more clever use cases: 

- Unpacking parts of an iterable
  ```py
   a, *b, c = [3, 6, 9, 12, 15]
   print(b)
  ```
  Would output: 
  ```bash
  [6, 9, 12]
  ```

- Merging iterables
  ```py
  my_tuple = (3, 6, 9)
  merged_tuple = (0, *my_tuple, 12)
  print(merged_tuple)
  ```
  Would output: 
  ```bash
  (0, 3, 6, 9, 12)
  ```
- Combining unpacking and packing
  ```py
  num_collection = [3, 6, 9]

  def power_two(*nums): 
    for num in nums:
      print(num**2)
  
  power_two(*num_collection)
  ```
  Would output: 
  ```bash
  9 
  36
  81
  ```

Let's see how we can apply some of these use cases to make Jiho's restaurant application better!