Functions

Imagine you calculate an average in five places in your program, copying the same three lines each time. Then you find a mistake in the calculation — and now you have to fix it in five places! Functions solve this problem: you write the code once, give it a name and call it as often as you like. print(), len() and sum() are functions you already know — now you will create your own.

Defining and calling a function

A function is defined with the word def, followed by the function's name, its parameters in parentheses and a colon. The body of the function is the indented block. Defining a function does nothing by itself; it only runs when you call it by name.

def greet(name):
    print(f'Hello, {name}!')

greet('Aysel')
greet('Murad')

Hello, Aysel!
Hello, Murad!

return: giving back a result

Usually we want a function to produce a result. return stops the function and sends a value back to the place where it was called. You can store that value in a variable, use it in another calculation or print it. The first line in triple quotes is a docstring: it briefly explains what the function does.

def rectangle_area(width, height):
    """Return the area of a rectangle."""
    return width * height

room = rectangle_area(4, 3.5)
print('Room area:', room)
print('Two rooms:', rectangle_area(4, 3.5) + rectangle_area(3, 3))

Room area: 14.0
Two rooms: 23.0

Beginners often mix up print and return. print only writes a value on the screen, while return hands it back to the program. A function without return returns None by default:

def add_print(a, b):
    print(a + b)

def add_return(a, b):
    return a + b

x = add_print(2, 3)
y = add_return(2, 3)
print('x =', x)
print('y =', y)

5
x = None
y = 5

def celsius_to_fahrenheit(c):
    return c * 9 / 5 + 32

for t in (0, 25, 100):
    print(f'{t} °C = {celsius_to_fahrenheit(t)} °F')

0 °C = 32.0 °F
25 °C = 77.0 °F
100 °C = 212.0 °F

Default values and keyword arguments

A parameter can have a default value: if no argument is given in the call, that value is used. You can also pass arguments by name — then their order does not matter and the code is easier to read.

def final_price(price, discount=0):
    return price - price * discount / 100

print(final_price(80))
print(final_price(80, 25))
print(final_price(discount=10, price=50))

80.0
60.0
45.0

A function can give back several results at once by returning a tuple. When calling it, we unpack the tuple straight into variables:

def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([12, 5, 27, 9])
print(low, high)

5 27

Variable scope

A variable created inside a function is local: it exists only while the function runs and cannot be seen from outside. A variable created outside any function is global. Assigning to a variable with the same name inside a function does not change the global one — it creates a new local variable.

x = 10

def change():
    x = 5
    print('inside:', x)

change()
print('outside:', x)

inside: 5
outside: 10

# define average(numbers) here

print(average([4, 5, 3, 5]))
print(average([10, 20]))

4.25
15.0

# define check(score, pass_mark=50) here

print(check(72))
print(check(45))
print(check(45, 40))

passed
failed
passed