Layer 1 Session 09 Python Foundations

Unpacking and *args/**kwargs

Python has compact syntax for pulling values out of collections, and for functions that accept a flexible number of arguments. Both patterns appear constantly in real code.

One collection, split into several named pieces.

Estimated time: 35–40 minutes · Pre-quiz → Concept → Lab → Commit → Post-quiz

1. Learning Objective

By the end of this session you will be able to:

Unpack values from a tuple or list into named variables
Unpack selected keys from a dictionary
Use * to collect "the rest" of a sequence during unpacking
Write a function that accepts *args and **kwargs and explain what each collects
Use ** to spread a dictionary into a function call as keyword arguments

2. Pre-Coding Quiz

Answer these before reading the concept explanation or writing any code. It is fine to get these wrong — that is the point. You need 4/5 to proceed to the lab.

Question 1 of 5

Given name, region = "Kenya", "Africa", what is region?

"Kenya" "Africa" A tuple ("Kenya", "Africa") An error — you cannot assign two variables at once

Python unpacks the right-hand tuple ("Kenya", "Africa") into the two names on the left, in order. name gets "Kenya", region gets "Africa".

Question 2 of 5

Given first, *rest = [1, 2, 3, 4], what is rest?

2 [2, 3, 4] [1, 2, 3, 4] A TypeError — you cannot mix a name and a star

The * collects "everything else" into a list. first takes the first item (1), and rest takes everything remaining as a list: [2, 3, 4].

Question 3 of 5

Given def total(*args): return sum(args), what does total(1, 2, 3) return, and what is args inside the function?

Returns 6; args is the tuple (1, 2, 3) Returns 6; args is the list [1, 2, 3] Returns an error because args was not defined by the caller Returns 1, only using the first argument

*args collects any number of positional arguments into a tuple named args inside the function. sum((1, 2, 3)) is 6.

Question 4 of 5

Given def describe(**kwargs): return kwargs, what does describe(name="Kenya", region="Africa") return?

("Kenya", "Africa") ["Kenya", "Africa"] {"name": "Kenya", "region": "Africa"} A TypeError — kwargs requires positional arguments

**kwargs collects any number of keyword arguments into a dictionary. The keys are the argument names, the values are what was passed.

Question 5 of 5

You have data = {"name": "Kenya", "region": "Africa"} and a function def show(name, region): .... Which call passes both dict values as the correct named arguments?

show(data) show(*data) show(**data) show(data.name, data.region)

**data spreads the dictionary's key-value pairs as keyword arguments — equivalent to show(name="Kenya", region="Africa"). *data would instead iterate over the dict's keys, which is not what we want here.

3. The Concept — Unpacking and *args / **kwargs

*args gathers positional extras into a tuple; **kwargs gathers keyword extras into a dict.

Unpacking a tuple or list

You can assign multiple variables from a sequence in one line, as long as the number of names matches the number of values.

name, region = "Kenya", "Africa"
print(name)    # "Kenya"
print(region)  # "Africa"

# Works with lists too, and with more than 2 values
first, second, third = [10, 20, 30]
print(second)  # 20

Collecting the rest with *

A single starred name absorbs however many values are left over, always as a list.

first, *rest = [1, 2, 3, 4]
print(first)  # 1
print(rest)   # [2, 3, 4]

first, *middle, last = [1, 2, 3, 4, 5]
print(middle)  # [2, 3, 4]
print(last)    # 5

Unpacking selected keys from a dictionary

You cannot unpack a dict positionally like a tuple, but you can pull out specific values using .get() or bracket access — this is how you'll turn a raw dict into named locals in later sessions.

country = {"name": "Kenya", "region": "Africa", "population": 54000000}
name = country["name"]
region = country["region"]
print(name, region)  # Kenya Africa

*args — a function that accepts any number of positional arguments

Inside the function, args is a tuple containing everything the caller passed positionally.

def total(*args):
    print(type(args), args)
    return sum(args)

print(total(1, 2, 3))     # <class 'tuple'> (1, 2, 3)  -> 6
print(total(10, 20))       # <class 'tuple'> (10, 20)   -> 30

**kwargs — a function that accepts any number of keyword arguments

Inside the function, kwargs is a dictionary of every keyword argument the caller passed.

def describe(**kwargs):
    print(type(kwargs), kwargs)
    return kwargs

describe(name="Kenya", region="Africa")
# <class 'dict'> {'name': 'Kenya', 'region': 'Africa'}

Spreading a dict into a call with **

Going the other direction: if you have a dictionary and a function that expects named parameters, ** unpacks it into matching keyword arguments.

def show(name, region):
    print(f"{name} is in {region}")

data = {"name": "Kenya", "region": "Africa"}
show(**data)  # equivalent to show(name="Kenya", region="Africa")

4. Lab

Lab objective: Practice unpacking, *rest collection, and write functions using *args and **kwargs, including spreading a dict into a call.

What you will build

A file called unpacking_lab.py.

Step-by-step instructions

Create the file and unpack a country tuple

# unpacking_lab.py
country_tuple = ("Kenya", "Africa", 54000000)
name, region, population = country_tuple
print(name, region, population)

Use * to split a list of country names into first and rest

names = ["Kenya", "Ghana", "Peru", "Japan"]
first, *rest = names
print("First:", first)
print("Rest:", rest)

Write a total_population function using *args

Call it with 2 numbers and then with 4, proving it works with any count.

def total_population(*populations):
    return sum(populations)

print(total_population(54000000, 31000000))
print(total_population(54000000, 31000000, 33000000, 125000000))

Write a build_country function using **kwargs

Print the kwargs dict, then return it.

def build_country(**fields):
    print("Received fields:", fields)
    return fields

country = build_country(name="Kenya", region="Africa", population=54000000)
print(country["name"])

Spread a dict into a function call

Write a plain function with named parameters and call it using ** on a dict.

def summarize(name, region, population):
    return f"{name} ({region}) — pop. {population:,}"

data = {"name": "Kenya", "region": "Africa", "population": 54000000}
print(summarize(**data))

5. Expected Files Changed

File	Action	Why
`unpacking_lab.py`	Created	Demonstrates unpacking, rest, args, kwargs, and spreading.
`docs/sessions/session-09/index.html`	Created	This session document.

If you find yourself editing any other file, stop. This session touches exactly 2 files.

6. Commit Checkpoint

Once the lab is complete and you can explain every line, make this exact commit:

git add unpacking_lab.py docs/sessions/session-09/index.html
git commit -m "session-09: unpack sequences and use *args/**kwargs for flexible functions"

Do not commit until you can answer out loud: "What is the type of args inside a function that uses *args, and what is the type of kwargs inside one that uses **kwargs?"

7. Code Review Checklist

Go through your code line by line and check each item:

A tuple is unpacked into three named variables

The * "rest" pattern is used and prints a list

A function using *args is defined and called with two different argument counts

A function using **kwargs is defined and its dict contents are printed

** is used to spread a dictionary into a function call with named parameters

I can explain every line without looking at the concept section

8. Post-Coding Quiz

Same 5 questions. Take it again now that you have written and run the code. You need 4/5 to mark this session complete.