04 Functions, Scoping, and Abstraction (Chapter 4)

Pricing three orders with the discount written once

Here are the two runs the story is about, and then the same job written so that the change cannot be half finished. First the copied version, with the discount at 10 per cent:

# orders.py
price = 240.0
count = 3
total = price * count
if total > 500:
    total = total * 0.90
print('Order 1:', format(total, '.2f'))

price = 89.5
count = 2
total = price * count
if total > 500:
    total = total * 0.90
print('Order 2:', format(total, '.2f'))

price = 1200.0
count = 1
total = price * count
if total > 500:
    total = total * 0.90
print('Order 3:', format(total, '.2f'))

Sample Run:

Order 1: 648.00
Order 2: 179.00
Order 3: 1080.00

Now the same file after the edit, with two of the three copies changed to 15 per cent:

# orders.py, after the discount was raised to 15 per cent
price = 240.0
count = 3
total = price * count
if total > 500:
    total = total * 0.85
print('Order 1:', format(total, '.2f'))

price = 89.5
count = 2
total = price * count
if total > 500:
    total = total * 0.85
print('Order 2:', format(total, '.2f'))

price = 1200.0
count = 1
total = price * count
if total > 500:
    total = total * 0.90
print('Order 3:', format(total, '.2f'))

Sample Run:

Order 1: 612.00
Order 2: 179.00
Order 3: 1080.00

And the version where the rule has one home. Write a function that multiplies the price by the count and takes 15 per cent off any total over 500, then call it three times:

# orders.py, with the rule in one place
def order_total(price, count):
    """Assumes price is a float and count is an int greater than 0.
    Returns the amount to pay, with the bulk discount applied when the
    order is over 500.
    """
    total = price * count
    if total > 500:
        total = total * 0.85
    return total

print('Order 1:', format(order_total(240.0, 3), '.2f'))
print('Order 2:', format(order_total(89.5, 2), '.2f'))
print('Order 3:', format(order_total(1200.0, 1), '.2f'))

Sample Run:

Order 1: 612.00
Order 2: 179.00
Order 3: 1020.00

Drawing a block of flats from one drawing function

The lecture draws buildings to make this point, so here it is in characters. Three tiny functions draw a roof, a flat and the ground. Write a fourth that draws a building with any number of flats, and use it for a one flat house and a three flat block.

def draw_roof():
    print('  .-----.')

def draw_flat():
    print('  | o o |')

def draw_ground():
    print('  =======')

def draw_apartment(flat_count):
    """Assumes flat_count is an int greater than 0.
    Draws a roof, that many identical flats, and the ground.
    """
    draw_roof()
    for i in range(flat_count):
        draw_flat()
    draw_ground()

draw_apartment(1)
draw_apartment(3)

Sample Run:

  .-----.
  | o o |
  =======
  .-----.
  | o o |
  | o o |
  | o o |
  =======

Before, inside and after one call

Put a print on either side of a call and one inside the body, so that the order of the four steps is visible on the screen.

def greet(name):
    print('inside greet, name is', name)
    return 'hello ' + name

print('before the call')
answer = greet('Ada')
print('after the call, answer is', answer)

Sample Run:

before the call
inside greet, name is Ada
after the call, answer is hello Ada

The cost of painting a wall, and then four of them

Write a function for the area of a square, and a second function that uses it to price the painting of a square wall. Then use the second one twice in a single expression.

def area(side):
    """Assumes side is a number. Returns the area of a square with that side."""
    return side * side

def paint_cost(side, price_per_square_metre):
    """Assumes both arguments are numbers.
    Returns the cost of painting one square wall of that side.
    """
    return area(side) * price_per_square_metre

print('one wall:', format(paint_cost(3.0, 45.0), '.2f'))
print('four walls:', format(4 * paint_cost(3.0, 45.0), '.2f'))

Sample Run:

one wall: 405.00
four walls: 1620.00

The same even test, once printed and once returned

Write the even number test twice, once so that it reports on the screen and once so that it hands an answer back, and look at what the caller holds in each case.

def even_shown(value):
    if value % 2 == 0:
        print('even')
    else:
        print('odd')

def even_returned(value):
    return value % 2 == 0

a = even_shown(4)
print('a is', a, 'of type', type(a))
b = even_returned(4)
print('b is', b, 'of type', type(b))

Sample Run:

even
a is None of type <class 'NoneType'>
b is True of type <class 'bool'>

The smallest divisor, and the return that leaves the loop

Write a function that gives back the smallest divisor of n above 1, which is n itself when n is prime. Then compare it with the same function written using break, to see what each of the two actually leaves.

def first_divisor(n):
    """Assumes n is an int greater than 1.
    Returns the smallest divisor of n above 1, which is n itself when n is prime.
    """
    d = 2
    while d < n:
        if n % d == 0:
            return d
        d = d + 1
    return n

print(first_divisor(91))
print(first_divisor(97))

Sample Run:

7
97

Now the same job with break instead:

def first_divisor_with_break(n):
    d = 2
    answer = n
    while d < n:
        if n % d == 0:
            answer = d
            break
        d = d + 1
    print('the function is still running, d is', d)
    return answer

print(first_divisor_with_break(91))

Sample Run:

the function is still running, d is 7
7

Ten added inside, and the seven that stayed outside

The same name is used inside and outside on purpose, which is the case the exam likes. Trace it and say what each of the three prints is looking at.

def step(x):
    x = x + 10
    print('inside step, x is', x)
    return x

x = 7
y = step(x)
print('outside, x is', x)
print('outside, y is', y)

Sample Run:

inside step, x is 17
outside, x is 7
outside, y is 17

A running total that refuses to be added to

Here is the natural way to keep a running total in a module level name and add to it from inside a function. It does not run at all, and the error message is worth reading carefully.

# counter.py
total = 0

def add_to_total(amount):
    total = total + amount
    return total

print(add_to_total(5))

What the screen shows:

Traceback (most recent call last):
  File "counter.py", line 8, in <module>
    print(add_to_total(5))
          ^^^^^^^^^^^^^^^
  File "counter.py", line 5, in add_to_total
    total = total + amount
            ^^^^^
UnboundLocalError: cannot access local variable 'total' where it is not associated with a value

The same job, written so that the function only reads and returns:

total = 0

def added_to(old, amount):
    return old + amount

total = added_to(total, 5)
total = added_to(total, 8)
print(total)

Sample Run:

13

One label function, four calls, two outputs

Write a function that prints a course label in a long or a short form, with the long form as the usual case. Then call it four ways that differ only in how the arguments are written.

def label(code, number, short=False):
    """Assumes code is a string, number an int and short a bool.
    Prints the course label, in the short form when short is True.
    """
    if short:
        print(code + str(number))
    else:
        print(code, number, 'section')

label('CS', 115)
label('CS', 115, True)
label('CS', number=115, short=True)
label(number=115, code='CS', short=False)

Sample Run:

CS 115 section
CS115
CS115
CS 115 section

A default that was fixed when the def line ran

A default can be written using another name. This program changes that name after the definition and then calls the function twice, once with the default and once with the new value passed by hand.

STEP = 5

def move(position, by=STEP):
    return position + by

STEP = 100
print(move(0))
print(move(0, STEP))

Sample Run:

5
100

One function that applies whichever converter it is given

Write a function that takes a value and a conversion function, applies the second to the first, and defaults to the int conversion when no function is passed. This is the shape the past midterm used, with our own values.

def apply_to(value, how=int):
    """Assumes value is a number and how is a function that takes one number.
    Returns whatever how gives back for value.
    """
    return how(value)

print(apply_to(7.6))
print(apply_to(7.6, round))
print(apply_to(-7.6, abs))
print(apply_to(0, bool))

Sample Run:

7
8
7.6
False

A function that chooses a function

Now the other direction: a function whose return value is itself a function, picked by a number. The caller then calls what it was given.

def picker(choice):
    """Assumes choice is an int.
    Returns a conversion function: int for 1, abs for 2, str for anything else.
    """
    if choice == 1:
        return int
    if choice == 2:
        return abs
    return str

f = picker(2)
print(f(-14.6))
g = picker(1)
print(g('42') + 1)
h = picker(9)
print(h(7) + '!')

Sample Run:

14.6
43
7!

Four functions for one clock

A time arrives as a string like '14:35'. Write the functions needed to say how many minutes have passed since midnight, and how many minutes lie between two times. The last call breaks the stated assumption on purpose.

def hour_of(clock):
    """Assumes clock is a string in the form HH:MM, such as 14:35.
    Returns the hour as an int.
    """
    colon = clock.find(':')
    return int(clock[:colon])

def minute_of(clock):
    """Assumes clock is a string in the form HH:MM.
    Returns the minutes past the hour as an int.
    """
    colon = clock.find(':')
    return int(clock[colon + 1:])

def minutes_since_midnight(clock):
    """Assumes clock is a string in the form HH:MM.
    Returns how many minutes have passed since 00:00.
    """
    return hour_of(clock) * 60 + minute_of(clock)

def minutes_between(start, end):
    """Assumes start and end are strings in the form HH:MM, and that
    start is not after end on the same day.
    Returns the number of minutes from start to end.
    """
    return minutes_since_midnight(end) - minutes_since_midnight(start)

print(minutes_since_midnight('14:35'))
print(minutes_between('09:15', '14:35'))
print(minutes_between('23:50', '00:10'))

Sample Run:

875
320
-1420

An exercise in lab shape: are these letters in order

This is what a lab question looks like once it is written out: a named function with a stated contract, a script that uses it, and a sample run given character for character. Write a function that says whether the letters of a word are in alphabetical order, ignoring case, then a script that reads a word and reports.

def is_ordered(text):
    """Assumes text is a string of letters.
    Returns True when the letters are in alphabetical order, ignoring case.
    """
    low = text.lower()
    for i in range(1, len(low)):
        if low[i] < low[i - 1]:
            return False
    return True

word = input('Enter a word: ')
if is_ordered(word):
    print('The letters of', word, 'are in alphabetical order')
else:
    print('The letters of', word, 'are not in alphabetical order')

Sample Run:

Enter a word: adept
The letters of adept are in alphabetical order

Sample Run, with a word that is not in order:

Enter a word: Bilkent
The letters of Bilkent are not in alphabetical order