Functions: def, parameters and return

Instead of writing the same calculation in five places of a program, you can write it once as a function and call it five times. In DİM tasks functions play two roles: either the main character (one function calls another, f(i) stands in a while condition) or a helper that computes a digit, a prime test or a reversed number and is applied to every element of a list. In both cases the key skill is the same: follow which call happens when and which value comes back.

Writing a function: def and return

def square(n):
    return n * n

print(square(4))
print(square(3) + square(4))
x = square(square(2))
print(x)

16
25
16

• The def line ends with a colon; the body is indented by the same number of spaces.
• Python reads the def blocks and remembers them but does not run them; the program starts at the first unindented line after the functions.
• return ends the function at once: the lines after it are not executed.
• A function without return returns None.
• A call can stand inside an expression: square(3) + square(4), square(square(2)).

def f1(n):
    print(n * 2)

def f2(n):
    return n * 2
    print('never')

a = f1(5)
b = f2(5)
print(a, b)

10
None 10

Formal and actual parameters, local variables

def f(m):
    m = m * 2
    k = m + 1
    return k

m = 5
k = 100
print(f(m), m, k)

def zero_first(a):
    a[0] = 0

b = [7, 8, 9]
zero_first(b)
print(b)

11 5 100
[0, 8, 9]

Inside the function, m and k are local: m becomes 10 and k 11, but m = 5 and k = 100 in the main program stay untouched. A list behaves differently: the function receives the list itself, not a copy, so a[0] = 0 also changes b in the main program. In short: if a number parameter changes inside a function, nothing changes outside; if an element of a list changes, the change is visible outside.

def f(a, b):
    a = a - b
    return a * 10 + b

a = 3
b = 7
print(f(b, a), a, b)

43 3 7

One function calls another: the order of calls

1. 1
   Find the start

   Skip the def blocks and start at the first line of the main program.

2. 2
   Write the parameters

   At every call copy the actual values into the formal parameters by position; one row of a table: function, parameters, local variables.

3. 3
   Inside out

   If there is another call inside the function, pause the current one, finish the inner call and continue with the value it returns. In f(g(x)), g(x) is computed first.

4. 4
   Go back

   After return, go back to the place of the call and replace the call by the returned value.

5. 5
   Count

   Note how many times each function is called — a missed call is the most common mistake.

def g(x):
    return x % 10 + x // 10

def f(n):
    p = g(n) * 3
    q = g(p) + g(n + 5)
    return p + q

print(f(47))

46

def g(k):
    k = k + 3
    return k * 2

def f(m):
    m = g(m) - m
    n = g(m) + m
    return n

a = 4
print(f(a) + a)

40

Helper functions: over lists and in loop conditions

The most common helper functions in DİM programs are small algorithms: returning a digit (n // 10 % 10 is the tens digit), a prime test by counting divisors, reversing a number, the digit sum. They work in three places: on every element of a list as in a[i] = k(a[i]), as a filter as in if f(x) != 0: b.append(x), and in a loop condition as in while f(i) < g(k):. The digit algorithms themselves are explained in the lesson “Working with numbers: digits, divisors and primes”; here we “pack” them into functions.

def d(n):
    k = 0
    for i in range(1, n + 1):
        if n % i == 0:
            k = k + 1
    return k

a = [9, 11, 15, 2, 21, 29, 1]
for i in range(0, len(a)):
    if d(a[i]) != 2:
        a[i] = d(a[i])
print(a)

[3, 11, 4, 2, 4, 29, 1]

d(n) returns the number of divisors. Primes have exactly two divisors (1 and themselves), so 11, 2, 29 stay, while 9, 15, 21 are replaced by their numbers of divisors — 3, 4, 4. The number 1 has only one divisor: 1 is not a prime, and since d(1) = 1 the element stays 1.

def rev(n):
    r = 0
    while n > 0:
        r = r * 10 + n % 10
        n = n // 10
    return r

def tens(n):
    return n // 10 % 10

for x in [123, 450, 707, 81]:
    print(x, rev(x), tens(x), x == rev(x))

123 321 2 False
450 54 5 False
707 707 0 True
81 18 8 False

def digit_sum(n):
    s = 0
    # add the digits of n to s
    return s

a = [12, 45, 71, 303, 58, 999]

12
45
303
999
4

def is_prime(n):
    k = 0
    # count the divisors of n
    return k == 2

a = [15, 7, 22, 13, 1, 9, 31, 4]

3
31

This completes the module's “toolbox”: variables, conditions, loops, strings, lists and functions. In the next lesson, “Writing programs: the written tasks”, we combine them and write the exam's written tasks as complete programs. Reverse tasks of the while f(i) … type, where you find the input from the output, are in the lesson “Analysing programs: from the output back to the input”, and extras such as default parameters are in the Python course lesson “Functions”.