[MUSIC]

Hi again, welcome to the final stage of functions, packing and unpacking.

We've talked a lot about the functions part of this course so far,

how are you feeling?

Do you feel confident in writing basic functions, passing arguments and

receiving returns?

If so, then keep moving forward to learn about packing and unpacking.

If not, then before moving on, try to review to content in the course so far.

Check out the Treehouse community, and practice by writing your own functions and

calling them to see how things work.

So what's packing?

Well, in the last section, we talked about passing multiple arguments to a function,

and how we receive each of those arguments into it's own parameter, or variable.

Packing expands on this concept and let's us do something potentially more useful,

and certainly more cool, let's dive in.

The basic concept of packing is compressing multiple values into

one tubal.

You can do this anywhere in your Python code,

but it's very commonly used when passing multiple arguments to a function.

Your function receives the multiple arguments and

packs them up into a single parameter.

This parameter now references a tuple where the elements of the tuple

are the many arguments passed to the function, kind of random right?

Well not so much, there are definitely going to be times in your python career

when you want to write a function that receives data, but

you're not sure what that data will look like ahead of time.

There's also going to be times when receiving all of your

arguments into one tuple, cuts down on the amount of code you need to write, or

drastically simplifies future steps.

Let's take a look, for now just follow along with what I'm doing,

don't worry about trying to code along with me.

So here we have a function called packer that receives multiple arguments,

packer prints each argument onto it's own line.

This is a pretty basic and pointless function but humor me,

we're just using it for demonstration purposes.

So I'm gonna write a call to this packer function where each argument is a string.

Now I'm gonna run this, just so

you can get a picture of what it looks like without packing.

Each argument has been received into its own parameter and

then it's printed out on its own line.

Now, if we wanted to take advantage of packing in Python and

pass these four arguments into one tuple,

we'd change our function definition to look more like this.

We'll get rid of each of these arguments,

and only use one, and then we can print args on its own.

Our function call is gonna remain exactly the same.

Now, when we run this, we'll see that each of our four individual arguments have been

converted to a tuple and are printed as such, let's take a look.

So what did we do here?

The secret is in the asterisk,

the little star at the beginning of the parameter name.

This star tells Python that we intend to pack all the arguments sent the function

into whatever parameter immediately follows the star.

This means when packer is called, and those four arguments are passed,

the function will receive them all into one table stored in parameter args.

args can then be used in the body of the function, just like any other parameter.

And because pupils are iterable if we still wanted each argument print on its

own line, we can still do that, but we'll use a loop instead.

Now I'll save, I'll come back down to my terminal.

I'll clear this out to leave a little more room, okay, so

when I run the file again, Cool.

As we iterate over args each element in the two ball is printed to its own line.

The parameter args with the asterisk before it is a very common pattern in

Python, you'll see the lot.

Let's dive into args a little more in the next video with a more practical example.