Sadly Python dictionaries can't help us with travel.

I know, I know I said packing and unpacking and you got all excited.

I know I did when I first learned about it.

If you haven't heard of this idea before though, it's all about expanding and

compressing variables.

When we talk about packing, we're taking multiple inputs like multiple values and

combining them into a single variable.

Each value is still represented in the final variable so

this isn't like adding two numbers together.

When I'm talking about unpacking though, as you can probably guess,

it's the opposite action unpacking takes the values in a variable and

makes a bunch of new variables from it.

Both of these actions are amazingly useful in coding, learn to use them well and

you'll be glad you did and

find yourself feeling a bit more powerful in your programming life.

That's going to work spaces and explore both of these concepts.

Most of the time, you'll encounter dictionary packing and

unpacking only in relationship to functions.

This is mainly because this is where it's the most useful.

But, just because it's most useful in a particular situation doesn't mean it's not

useful in other situations too.

So first, let's look at how we can pack a dictionary.

Might do this in a file called luggage.pi,

because you know you pack and unpack luggage.

Okay, so let's make a function named packer, and

it's going to take a new argument that you probably,

you might have seen this style before and you might not have.

But it's gonna take (**kwargs): or asterisk asterisk kwargs.

And all I'm gonna do is I'm gonna print out kwargs.

So, just print it out to see what's there.

And then down here, I want to call packer and

I'm gonna pass in some variables, some keyword arguments rather.

So the name is going to be equal to Kenneth.

The num gonna be equal to 42 and

spanish inquisition is gonna be equal to None and I'm wanna save that.

Now this might look a little weird to you probably haven't seen the double

asterisk used in programming outside of

maybe being used to create exponents like five to the power of two.

In Python,

when you use double asterisks like this on a parameter in a function Python will pack

whatever keyword arguments come into the function Into a dictionary.

Because you're packing keyword arguments, you'll see this name, kwargs, for

keyword arguments, quite often, right?

So let's run the script and let's see what it does.

So python luggage.py, and it prints out a dictionary.

num, 42, name, Kenneth, spanish_inquisition, None.

That's pretty much what we passed in here isn't it.

When the function prints out the kwarg's variable we can see that it's a dictionary

and each one of the keyword arguments that we gave to the function ends up as a key

in the dict and the value of the argument ends up as the value of the key in the dict.

So great It's fairly straightforward and it's very reliable but does this catch

all keyword arguments or could I have some that are explicitly defined and

then have a catch all for any others.

So let's say here that name is equal to none and then the rest are kwargs.

So let's go and run this again.

And I just have numb and Spanish inquisition, so now our name variable

isn't in the cards dictionary because it's explicitly caught outside of the packing.

So packing a dictionary takes a bunch of key value pairs and

turns them into a dictionary's keys and values.

So now let's see about unpacking.

I'm gonna start by making a new function.

And I'm gonna call this function unpacker.

And it's gonna take a first name which is equal to none, and

it's gonna take a last name which is equal to none.

And or gonna say if first name and last nam, so both of those things are there.

Then we're gonna print Hi something, something.

And we'll call .format with first name, last name.

And we need another closing parenthesis on that and

then else, we're going to print, hi no name, cuz we don't have a name.

So our function is looking for two keyword parameters, right?

First name and last name.

If it gets them both it'll print out a greeting with the names.

Otherwise, it says hi to someone named no name.

Now this isn't using packing or

unpacking I'll call it though with the power of unpacking.

Let's do this down here below packer.

We'll say unpacker, and I'm gonna do start star, and then a dictionary,

last name is gonna be Love, and first name, is gonna be Kenneth.

Close my parentheses.

Okay, let's run this again.

And now I got Hi Kenneth Love.

So, I've called the function and give it a single dictionary, right here,

one single dictionary as the only argument right?

And I didn't even name it, so it's not a keyword argument.

But because of these two asterisks that are here in front, python took each key

from the dict and its value and sent them as keyword arguments to the function.

Now you might be thinking but they're out of order, but

that's fine because keyword parameters on a function don't have to show up

in a particular order as a bit of a behind the scenes peek.

That's because they're actually a dictionary, when the function is processed

and dictionary keys don't have an order anyway.

One very important note about star star kwargs.

It has to be the last parameter in your function definition.

Python will tell you when you forget this rule though so

you don't really have to memorize it at least not right away.

Unpacking and packing dictionaries is one of the areas that often trips up

a lot of new Python programmers.

It's a handy but strange bit of Python, and

one that doesn't show up in a lot of the languages.

I heavily heavily suggest you practice as much as you can with these two approaches.

Dictionaries are one of the most powerful data types in python.

They can be used as impromptu objects, developed function arguments and

just as a good way to collect data like all of the other collection types in this

course they can be iterated over but it might not work the way that you expect.