I agree with the first two. The third case I'm not sure. In that code snippet format....which is a function, a built-in...** and some dicts is unpacking as in 1.before an argument when calling up a function.

This is for Austin....

#This is the profile database, it consist of 2 dictionaries
profile = [{"name": "Michelangelo", "food": "PIZZA"}, {"name": "Garfield", "food": "lasagna"}]

#This is the script sentence, you take the name & the food from the dictionaries above, and put it in this sentence
template = "Hi, I'm {name} and I love to eat {food}!"

#This function will be in charge of extracting the name & food from profile dictionaries
def string_factory(values):

 #This new list will contain the newly made sentences, after you extract the name and food and put plug it into template sentence
  new_list = []

 #Since in the profile dictionary, there are actually 2 dictionaries, so you have to loop through them   to extract the information for one dictionary at a time
  for each_dict in values:
    new_list.append(template.format(**each_dict))

  #instead of returning the new_list like the exercise ask you, I'm printing the new_list dictionary to demonstrate the result of the function

for line in (new_list):
    print(line)

string_factory(profile)

#********************************************************
#This is the product of the string_factory function
#Hi, I'm Michelangelo and I love to eat PIZZA!
#Hi, I'm Garfield and I love to eat lasagna!

#See how using the template sentence, you put in the name and what food the person likes to eat.  

"So where should we use the 2 stars to unpack dictionaries? When you call up the function or the parameters of the function?"

I hope this helps. I also had a bear of a time with this. As you go through the course be sure to have another way to get over a hump. I have a book and some good youtube channels. For when you don't get it from the lesson.

The input to the function at the moment it is called is the ARGUMENT. foo(args_here) The input to the function as it is defined is the PARAMETER. def foo(parms_here):

** in the arguments will unpack a dictionary. The function is called with a dictionary argument.What the function is passed are a bunch of keyword pairs.

**kwargs in the parameters will catch any and all incoming keyword pairs and hold them in a dictionary. You deal with them in your function definition using code along the lines of: def foo(**kwargs): for item in kwargs.items(): print(item) You still have all your keyword pairs there but they're in a dictionary (kwargs) and you deal with them as such.

There's also the whole *args thing he didn't mention. Works same but for non keyword items. Unpacking in arguments packing in parameters. *args will unpack a tuple into singles, unpack a string into chars, a list into items etc. *args in the parms will catch any number of (non keyword) args and stash them in a tuple.