Functions: Arguments, Scope & Small Programs

Discussion prompt

Before we open Functions: Arguments, Scope & Small Programs: without looking back, what was the main idea of Dictionaries: Mapping Colors to Actions, and what could you do by the end of it that you could not do before?

Hint: One sentence for the idea, one for the skill. If the second one is blank, that is the part to revisit.

Discussion prompt

Real programs aren't one long script. They're several small functions working together - which is exactly how the camp's robot code is organized.

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Match the pairs

From Today's roadmap — match each one to what it actually does. The descriptions have been shuffled.

• c1. Arguments
• c2. Scope
• c3. Functions + loops
• c4. Robo-Battle

• b1. Positional vs keyword, and default order.
• b2. What stays inside a function, and what doesn't.
• b3. Call helpers inside a loop to run a program.
• b4. Two robots, decide(hp), a turn loop.

Why: Arguments, Scope, Functions + loops, Robo-Battle are easy to tell apart while they are sitting next to their descriptions and much harder afterwards, which is what this checks.

Comparison matrix

From One function, several call styles: refill the speed, direction, power column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain Why keyword arguments help by analogy to something with no Python in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Sort into buckets

Every line below is part of the definition of keyword argument or of default value — one or the other, never both. Put each where it belongs.

keyword argument

An argument passed by name, like direction="left".; It goes to that exact parameter, so you can skip earlier ones that have defaults.

default value

A fallback written as name=value in the def.; Required (no-default) parameters must be listed before any defaulted ones.

b1

An argument passed by name, like direction="left". It goes to that exact parameter, so you can skip earlier ones that have defaults.

b2

A fallback written as name=value in the def. Required (no-default) parameters must be listed before any defaulted ones.

Comparison matrix

From Mixing positional and keyword in one call: every row here is a choice with a cost. Fill the returns column, then say which row you would actually pick and what you give up for it.

Predict first

A student writes this, and it looks reasonable:

Once you go keyword, you can't drop back to positional.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: After speed=10 (keyword), the bare "left" is positional again.

Keep positionals first, then keywords - or go all keyword.

Why: After speed=10 (keyword), the bare "left" is positional again.

Put in order

These are the steps of Calling a function cleanly, scrambled. Put them back in order before the next slide shows you.

1. Positionals first, in the same order as the def.
2. Then keywords (name=value) - never a positional after a keyword.
3. Use keywords to skip middle defaults or to make the call readable.
4. In the def itself, put required parameters before defaulted ones.

Why: This is the order the recipe itself gives. Recalling the sequence without the slide in front of you is the difference between recognising the method and being able to run it — most of what goes wrong in practice is a step done out of turn.

Discussion prompt

Calling a function cleanly works on the cases you have just seen. Push it to the edge: what is the most degenerate input it still handles — empty, zero, one item, everything equal — and what is the first case where it stops being true? Name the case, not just "it breaks".

Hint: Try the smallest legal input, then the largest, then the one where two things collide. Methods are specified at their edges; the middle takes care of itself.

Check your understanding

What does move(10, power=9) return?

• A. (10, 'forward', 9) (correct)
• B. (10, 9, 5)
• C. (10, 'forward', 5)
• D. An error

Answer: A

Why: speed=10 fills positionally, direction keeps its default 'forward', and power=9 sets power by name. Result: (10, 'forward', 9).

Why B tempts people

power=9 sets the parameter named power, not the next positional slot (direction). direction keeps its default, it doesn't become 9.

Why C tempts people

The keyword power=9 does override the default 5 - it isn't ignored, so power is 9, not 5.

Why D tempts people

Skipping a middle default by using a keyword is allowed, so this call is valid - no error.

Discussion prompt

Explain Local vs global to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Discussion prompt

Read the picture before the words. What is this showing, and what is the one thing it is built to make obvious? Commit to an answer, then read on.

Hint: Name the parts, then say what changes between them — and if nothing changes, say what is being held still.

Predict first

A student writes this, and it looks reasonable:

Calling a function and expecting your variable to update on its own.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: Inside, b = b - 5 changes only the local copy b.

Catch the return value back into your variable.

Why: Inside, b = b - 5 changes only the local copy b.

Discussion prompt

The rule this trap just fixed:

The function hands the new value out; you store it back in battery.

Now break it on purpose. Build a case that violates it and follow the consequences until something visibly fails. Where does the failure first show up — and would you have noticed it if you had not been looking?

Hint: The dangerous rules are the ones whose violation still produces an answer. If yours fails loudly, try to find one that fails quietly.

Predict first

A student writes this, and it looks reasonable:

Even a correct return is wasted if you don't catch it.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: It computes 15 and hands it back - but nothing catches it, so it vanishes.

Assign the result back into your variable.

Why: It computes 15 and hands it back - but nothing catches it, so it vanishes.

Sort into buckets

Some of these hold up and some are the exact mistakes this lesson is built to prevent. Sort them.

Holds up

Real programs aren't one long script. They're several small functions working together - which is exactly how the camp's robot code is organized.; Four ideas, then you build a whole game out of them:; Compare set_motor(1, 0, 1) with set_motor(left=1, right=0, brake=1). Same call - but the second one reads like a sentence.

Breaks

Once you go keyword, you can't drop back to positional.; Calling a function and expecting your variable to update on its own.

sound

These are stated as this lesson states them — each one survives the edge cases Functions: Arguments, Scope & Small Programs puts it through.

flawed

Each of these is lifted from a trap in this deck: reasonable-sounding, and wrong in a way that only shows up once you rely on it.

Eliminate the wrong options

What happens? def f(): x = 5 f() print(x)

3 of these 4 are wrong. Strike them one at a time, and say what rules each one out before you strike the next. The survivor is the answer.

• A. Error: x is not defined
• B. 5
• C. 0
• D. None

Survives elimination: A

Why: x is created inside f(), so it is local - it stops existing when f() ends. print(x) outside raises NameError: name 'x' is not defined.

Check your understanding

What happens?

def f():
x = 5

f()
print(x)

• A. Error: x is not defined (correct)
• B. 5
• C. 0
• D. None

Answer: A

Why: x is created inside f(), so it is local - it stops existing when f() ends. print(x) outside raises NameError: name 'x' is not defined.

Why B tempts people

Assumes a variable made inside a function is visible outside. Locals stay local; x is gone once f() returns.

Why C tempts people

There is no x outside the function at all - it isn't 0, it simply doesn't exist.

Why D tempts people

An undefined name raises a NameError; it doesn't quietly become None.

Step through it

Step through decide() inside a for loop one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: pass is 1
2. Step 2: pass is 2
3. Step 3: pass is 3

Sort into buckets

These are the pieces of Functions: Arguments, Scope & Small Programs, out of order. Put each one back under the part of the lesson it belongs to.

Arguments, Up Close

Positional vs keyword arguments; One function, several call styles; Why keyword arguments help

Scope

Local vs global; Scope is a room with no windows; A local doesn't leak out

Functions Inside Loops

Call a helper on every pass; decide() inside a for loop; The accumulator pattern

s1

Arguments, Up Close is where Functions: Arguments, Scope & Small Programs puts Positional vs keyword arguments, One function, several call styles, Why keyword arguments help. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

s2

Scope is where Functions: Arguments, Scope & Small Programs puts Local vs global, Scope is a room with no windows, A local doesn't leak out. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

s3

Functions Inside Loops is where Functions: Arguments, Scope & Small Programs puts Call a helper on every pass, decide() inside a for loop, The accumulator pattern. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

Step through it

Step through Draining the battery over a loop one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: pass is start
2. Step 2: pass is 1
3. Step 3: pass is 2
4. Step 4: pass is 3

Predict first

def decide(color): if color == "red": return "turn" return "forward" for c in ["red", "red", "green"]: print(decide(c)) What prints?

Answer it in your own words, now, with nothing to choose from. The options are on the next slide — and picking the right one off a list is an easier skill than producing it.

Correct: turn, turn, forward

Why: decide is called each pass: 'red' -> turn, 'red' -> turn, 'green' -> forward. return ends the function call, not the loop, so all three lines print.

Check your understanding

def decide(color):
if color == "red":
return "turn"
return "forward"

for c in ["red", "red", "green"]:
print(decide(c))

What prints?

• A. turn, turn, forward (correct)
• B. turn, forward, forward
• C. just turn
• D. red, red, green

Answer: A

Why: decide is called each pass: 'red' -> turn, 'red' -> turn, 'green' -> forward. return ends the function call, not the loop, so all three lines print.

Why B tempts people

Miscounts the list - there are two 'red's before 'green', so the first two are both turn.

Why C tempts people

return ends the function call, not the for loop. The loop runs three times and prints three lines.

Why D tempts people

print(decide(c)) prints the returned action, not the color c itself.

Discussion prompt

Read the picture before the words. What is this showing, and what is the one thing it is built to make obvious? Commit to an answer, then read on.

Hint: Name the parts, then say what changes between them — and if nothing changes, say what is being held still.

Comparison matrix

From A two-function mini program: refill the returns column from what you know. The rest of the table is as it appeared.

Match the pairs

Match each term to the definition this lesson gave it — not the one you would guess from the word.

• t1. keyword argument
• t2. default value
• t3. scope
• t4. accumulator
• t5. random.randint(a, b)

• d1. An argument passed by name, like direction="left". It goes to that exact parameter, so you can skip earlier ones that have defaults.
• d2. A fallback written as name=value in the def. Required (no-default) parameters must be listed before any defaulted ones.
• d3. Where a name is visible. Names made inside a function live in that function's local scope only; names at the top level are global.
• d4. A variable that holds a running result across a loop, updated each pass - here, battery = drain(battery, cost).
• d5. Returns a random integer N with a <= N <= b. Unlike range(), the top value b CAN come up.

Why: These are the working definitions of keyword argument, default value, scope, accumulator, random.randint(a, b) as Functions: Arguments, Scope & Small Programs uses them. Pairing them correctly is the test of whether you could state each one with the slide switched off.

Step through it

Step through Repeatable randomness with seed one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: roll is 1
2. Step 2: roll is 2
3. Step 3: roll is 3
4. Step 4: roll is 4
5. Step 5: roll is 5

Discussion prompt

Explain Why seed first to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Predict first

random.randint(1, 6) can return which values?

Answer it in your own words, now, with nothing to choose from. The options are on the next slide — and picking the right one off a list is an easier skill than producing it.

Correct: 1, 2, 3, 4, 5, or 6

Why: random.randint(a, b) includes BOTH ends, so 1 through 6 - exactly like rolling a die.

Check your understanding

random.randint(1, 6) can return which values?

• A. 1, 2, 3, 4, 5, or 6 (correct)
• B. 1, 2, 3, 4, or 5
• C. 0, 1, 2, 3, 4, 5, or 6
• D. 0, 1, 2, 3, 4, or 5

Answer: A

Why: random.randint(a, b) includes BOTH ends, so 1 through 6 - exactly like rolling a die.

Why B tempts people

That's range()/slicing thinking, where the end is excluded. randint includes the top value 6.

Why C tempts people

The low end is 1 (the first argument), not 0 - randint doesn't start below a.

Why D tempts people

Both ends are wrong: randint(1, 6) starts at 1 and includes 6.

Discussion prompt

Explain The build: two robots, taking turns by analogy to something with no Python in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Comparison matrix

From Put it together: Robo-Battle: every row here is a choice with a cost. Fill the move column, then say which row you would actually pick and what you give up for it.

Eliminate the wrong options

Both robots start at hp 20 and A goes first. On turn 1, what does A do, and what is B's hp right after?

3 of these 4 are wrong. Strike them one at a time, and say what rules each one out before you strike the next. The survivor is the answer.

• A. A attacks; B drops to 14
• B. A defends; B drops to 18
• C. A attacks; B drops to 16
• D. Nothing yet - the loop hasn't started

Survives elimination: A

Why: hp_a is 20, which is not < 10, so decide returns 'attack'. An attack does 6, so B goes 20 - 6 = 14.

Check your understanding

Both robots start at hp 20 and A goes first. On turn 1, what does A do, and what is B's hp right after?

• A. A attacks; B drops to 14 (correct)
• B. A defends; B drops to 18
• C. A attacks; B drops to 16
• D. Nothing yet - the loop hasn't started

Answer: A

Why: hp_a is 20, which is not < 10, so decide returns 'attack'. An attack does 6, so B goes 20 - 6 = 14.

Why B tempts people

The threshold is hp < 10. At 20 the robot attacks - it only defends once its own hp is below 10.

Why C tempts people

An attack does 6 damage (defend does 2). 20 - 6 = 14, not 16.

Why D tempts people

The while loop runs while both are above 0; both start at 20, so round one runs immediately.

Comparison matrix

From Stretch — random damage with a seed: refill the result column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain your program out loud, in function terms:

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Draw it

One page, no notation unless you need it: draw how these connect — Arguments, Up Close · Scope · Functions Inside Loops · Designing a Small Program · A Pinch of Randomness · Build It: Robo-Battle. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.