Defining functions

Making a function

This program makes a function. Predict what it prints.

def greet():
    print("Selam")

def is how you definedefineMake a function: def, its name, parentheses, a colon, then the indented lines it will run. a function: the word def, a name, parentheses, a colon, then the indented lines that belong to it (a block, like an if's). Defining a function doesn't run those lines. It makes a function and gives it the name greet, ready for later.

To run them, you callcallRun a function: its name followed by parentheses, like greet(). the function: its name, then parentheses. Each call runs the whole block again.

def greet():
    print("Selam")

greet()
greet()

The parentheses are what make it a call. Predict this one:

def greet():
    print("Selam")

greet

A function is a value, like a number or a list, and greet is a name that refers to it. print(greet) shows a description of the function object (it starts with <function greet at), not "Selam". If a function you wrote seems to do nothing, check for the missing () first.

Giving a function information

A function gets more useful when you can hand it something to work on. Put a name inside the parentheses of the def:

def greet(name):
    print(f"Selam, {name}!")

greet("Hana")
greet("Abel")

name is a parameterparameterA name in a function's def line. Each call gives it a value to work with.: a name the function uses for whatever it's given. The value in the call, "Hana", is an argumentargumentA value you pass to a function when you call it. The matching parameter refers to it during that call.. In each call, name refers to that call's argument. Now predict what happens when the value comes from a name of your own:

def greet(name):
    print(f"Selam, {name}!")

person = "Hana"
greet(person)

Selam, Hana!

Handing a value back

Printing shows a value to a person. Often you want the value itself, to give it a name or calculate with it. return hands a value back to the code that called the function. Ethiopia's standard VAT is 15%:

def vat(price):
    return price * 1.15

total = vat(250)
print(total)
print(vat(1000))

The value a call hands back is its return valuereturn valueThe value a call hands back to the code that called it, with return. The call itself becomes that value.. vat(250) becomes 287.5, just as if you'd typed 287.5 there.

Each call gets its own frameframeThe set of names that belong to one call of a function: its parameters and any names made inside it. It appears when the call starts and is gone when it ends., a set of names that belong to that call only. The diagram below draws frames as boxes of names, with arrows to the values. Line 4 shows up twice: first when the call starts (a frame for vat appears, and price refers to 250), then again when the call is over and total gets the returned value.

When the call ends, its frame and price are gone. Only the returned value is left, and total refers to it. The top frame, global, has the names made outside any function. (vat is one of them too; the diagram leaves it out until lesson 5.5.)

Keep one rule in mind: print is for people; return is for the program. print shows a value on the screen and hands nothing back. return hands a value back to the code and shows nothing. Here's why it matters. Predict:

def greet_print(name):
    print(f"Selam, {name}!")

x = greet_print("Hana")
print(x)

Selam, Hana!
None

A function without return still hands something back: NoneNonePython's value for 'nothing here'. A function that ends without return returns None., Python's value for "nothing". Printing inside a function doesn't make that value its return value. You only notice when you try to use the result:

return ends the call

Predict what this prints.

def vat(price):
    return price * 1.15
    print("VAT added")

print(vat(250))

287.5

Lines after a return in the same block never run. Put anything the function needs to do before its return.

A return inside an if ends the call only when that branch runs. Otherwise Python carries on to the lines below it, so a function can have more than one return, and the first one reached wins:

def ride_type(km):
    if km > 10:
        return "long"
    return "short"

print(ride_type(12))
print(ride_type(3))

For 12 km, the first return ends the call. For 3 km, the if is skipped and the second return runs. You'll use this shape in almost every function from now on.