Functions I: Definition, Parameters, Return

▶Today's videos

Watch each video, then work the matching sections below. Watching alone will not do it.

1Why functions exist

Three specific things — and "reusability" is only one of them.

Yesterday you wrote about sixty lines as one straight run. It worked. But to change one line of it safely you had to hold the whole thing in your head — and sixty lines is roughly where that stops being possible. Not because you are not clever enough. Because nobody can.

The problem

celsius = 21.5
fahrenheit = celsius * 9 / 5 + 32
print(f"{celsius}C = {fahrenheit}F")

celsius = 36.6
fahrenheit = celsius * 9 / 5 + 32
print(f"{celsius}C = {fahrenheit}F")

celsius = 100
fahrenheit = celsius * 9 / 5 + 32
print(f"{celsius}C = {fahrenheit}F")

The formula appears three times. If it is wrong, it is wrong three times — and you will fix two of them. That is not carelessness; it is what duplicated logic does to people.

The fix

def to_fahrenheit(celsius):
    return celsius * 9 / 5 + 32


for temperature in (21.5, 36.6, 100):
    print(f"{temperature}C = {to_fahrenheit(temperature)}F")

On job 2: celsius * 9 / 5 + 32 is an expression you must decode. to_fahrenheit(celsius) is a sentence you read at speed. In a real codebase a large fraction of functions are called exactly once — and they still earn their place, for exactly this reason.

2def, parameters, return

The mechanics — and where control actually goes.

Parameter or argument?

It rarely matters in conversation, but it makes error messages readable: "missing 1 required positional argument: 'name'" means a parameter never received an argument — so the mistake is at the call site, not in the body.

return stops the function

Which is what makes Day 3's guard clause work inside a function:

def safe_divide(top, bottom):
    if bottom == 0:
        return 0.0          # leave early — the rest never runs
    return top / bottom


print(safe_divide(10, 4))
print(safe_divide(10, 0))

No else is needed. If bottom were zero, we would not be here.

3return is not print

This is the section. If you take one thing from today, take this.

The test that settles it: can you use the answer?

Where None comes from

A function that never executes a return hands back None. Python does it silently. And print itself returns None:

def no_return():
    total = 1 + 1


print(no_return())

result = print("hi")
print(result)

Which explains the first demonstration exactly. add_print ends with a print call — but ending with a call is not returning its result. Nothing was returned, so None came back.

4Defaults and keyword arguments

Two conveniences — and one of them is really about readability.

def greet(name, greeting="Hello", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"


print(greet("Amin"))
print(greet("Amin", "Welcome"))
print(greet("Amin", punctuation="?"))
print(greet(punctuation="?", name="Amin"))

That last call passes both arguments out of order and still works, because both are named. Position only matters for arguments that are not.

The first two are SyntaxErrors — caught before anything runs. The third is a TypeError, at call time. That is Day 5's syntax-versus-runtime distinction turning up in a new place.

What keyword arguments are really for

When an argument is a bare True, False, or a number with no obvious meaning, name it. Eight characters, and the next reader never leaves the line. Values that speak for themselves — a name, a price, a filename — can stay positional.

The call errors you will actually hit

5Designing a signature

The only part of your function that other people read.

Take what you need, and no more

Three parameters is comfortable. Four is a smell. Six means an idea is missing from your design.

Local names are local

The trap that follows

count = 0

def bump():
    count = count + 1

bump()

Python scans the whole body first. Because count is assigned somewhere in bump, it is local throughout — including on the right-hand side, where it has no value yet.

There is a global keyword that makes this work. It is almost never the right answer, because a function that modifies things outside itself is one you cannot reason about, test, or move. The fix is four words:

def bump(count):
    return count + 1

count = bump(count)

6Refactoring Mini-Project 1

Same program. Same output. Ten functions.

python3 number_analyzer_old.py > before.txt
python3 number_analyzer.py     > after.txt
diff before.txt after.txt        # silence means success

Run that after every function you extract — not once at the end. Extract ten and then find a difference, and you have ten places to look. Check after each and you always have exactly one.

Finding the seams

The isolation payoff

Yesterday is_number was a variable holding True or False, buried inside a loop. Today it is a function — which makes this possible:

for text in ["12", "-3.5", "0", ".", "", "abc", "1.2.3", "--5", "+5"]:
    print(f"is_number({text!r:>8}) -> {is_number(text)}")

The shape of the result

Three things to notice. collect_numbers returns from inside the loop — return numbers_text does the job break did yesterday, and does it better. format_report returns a string; it does not print. main() has a guard clause, so everything below it can assume there is at least one number.

The traceback now tells a story

And the cost, honestly

format_report calls four counters, and every one splits the same string again. The program now walks the same data five times where the old one walked it once. That is genuinely worse along that one dimension, and you should notice it rather than be told later.

>_Python playground

A real Python interpreter running inside your browser. Nothing is installed, nothing is uploaded, nothing can break.

✓Exercise set

Checked automatically the moment you submit. Work top to bottom — each one assumes the last. Your answers are saved in this browser.