Functions — notes

A function is a named block of statements that performs one task and runs only when called. Functions give reuse, modularity and readability, and make programs easier to test.

• Built-in: always available, e.g. len(), print(), max(), round(), type(), int().
• From modules: need import first, e.g. math.sqrt(), random.randint(), statistics.mean().
• User-defined: written with def.

import math then call math.name(); or from math import sqrt and call sqrt() directly.

• math: sqrt(), pow(), fabs() return floats; ceil() rounds up and floor() rounds down (towards minus infinity); math.pi.
• random: random() gives 0.0 ≤ x < 1.0; randint(a, b) includes both a and b; randrange(start, stop, step) excludes stop.
• statistics: mean(), median(), mode().

import math
from statistics import mean
print(math.floor(-2.5), math.ceil(-2.5), mean([3, 4, 8]))

Output: -3 -2 5

Header: def name(parameters):, then an indented body. A function must be defined before it is called (else NameError). return sends a value back and ends the call; a function may have several returns, but only one runs. Without return, the call gives None.

def show_sq(n):
    print(n * n)

def get_sq(n):
    return n * n

a = show_sq(4)
b = get_sq(4)
print(a, b)

Output:

16
None 16

Parameters (formal) are the names in the header; arguments (actual) are the values in the call.

• Positional: matched by position.
• Default: def f(a, b=5); used when the argument is left out; defaults must come after non-defaults.
• Keyword: f(b=2, a=1); matched by name, any order; must come after positional arguments.

def fee(days, rate=50, late=0):
    return days * rate + late

print(fee(3), fee(3, 60), fee(3, late=25))

Output: 150 180 175

return a, b, c returns one tuple; receive it whole or unpack it: x, y, z = f().

Flow of execution: def statements are read first but their bodies run only when called; execution starts at the first statement outside functions; a call jumps into the body and control returns to the point of call when the function ends.

def split_time(m):
    return m // 60, m % 60

t = split_time(200)
h, m = split_time(200)
print(t, h, m)

Output: (3, 20) 3 20

• Local: created inside a function (parameters too); exists only during the call.
• Global: created at the top level; can be read inside functions.
• To assign to a global inside a function, write global name first; otherwise an assignment creates a local name (reading it first gives UnboundLocalError).
• Immutable arguments (int, float, str, tuple) cannot be changed by the function; mutable ones (list, dict) can be changed in place and the caller sees the change. Rebinding a parameter (L = []) never affects the caller.

def update(n, L):
    n = n + 1
    L.append(n)
num = 7
lst = [7]
update(num, lst)
print(num, lst)

Output: 7 [7, 8]