Writing Functions

Break programs down into functions to make them easier to understand

• Human beings can only keep a few items in working memory at a time.
• Understand larger/more complicated ideas by understanding and combining pieces.

  • Components in a machine.
  • Lemmas when proving theorems.
• Functions serve the same purpose in programs.

  • Encapsulate complexity so that we can treat it as a single "thing".
• Also enables re-use.

  • Write one time, use many times.

Define a function using def with a name, parameters, and a block of code

• Begin the definition of a new function with def.
• Followed by the name of the function.

  • Must obey the same rules as variable names.
• Then parameters in parentheses.

  • Empty parentheses if the function doesn't take any inputs.
  • We will discuss this in detail in a moment.
• Then a colon.
• Then an indented block of code.

Copy
def print_greeting():
    print('Hello!')

Defining a function does not run it

• Defining a function does not run it.

  • Like assigning a value to a variable.
• Must call the function to execute the code it contains.

Copy
print_greeting()

Copy
Hello!

Arguments in call are matched to parameters in definition

• Functions are most useful when they can operate on different data.
• Specify parameters when defining a function.

  • These become variables when the function is executed.
  • Are assigned the arguments in the call (i.e., the values passed to the function).
  • If you don't name the arguments when using them in the call, the arguments will be matched to parameters in the order the parameters are defined in the function.

Copy
def print_date(year, month, day):
    joined = str(year) + '/' + str(month) + '/' + str(day)
    print(joined)

print_date(1871, 3, 19)

Copy
1871/3/19

Copy
print_date(month=3, day=19, year=1871)

Copy
1871/3/19

• Arguments matched by their position are called positional arguments.
• Arguments matched by their name, like month=3, are called keyword arguments (or named arguments).

Functions may return a result to their caller using return

• Use return ... to give a value back to the caller.
• May occur anywhere in the function.
• But functions are easier to understand if return occurs:

  • At the start to handle special cases.
  • At the very end, with a final result.

Copy
def average(values):
    if len(values) == 0:
        return None
    return sum(values) / len(values)

Copy
a = average([1, 3, 4])
print('average of actual values:', a)

Copy
average of actual values: 2.6666666666666665

Copy
print('average of empty list:', average([]))

Copy
average of empty list: None

• Remember: every function returns something.
• A function that doesn't explicitly return a value automatically returns None.

Copy
result = print_date(1871, 3, 19)
print('result of call is:', result)

Copy
1871/3/19
result of call is: None

Parameters can have default values

• Give a parameter a default value in the definition with name=value.
• If the caller doesn't pass that argument, the default is used.
• Parameters with defaults must come after parameters without them.

Copy
def say_hello(name='World'):
    return 'Hello, ' + name + '!'

print(say_hello())
print(say_hello('Ada'))
print(say_hello(name='Grace'))

Copy
Hello, World!
Hello, Ada!
Hello, Grace!

• Defaults are useful for options that usually have a sensible value, but that callers sometimes want to change.
• Built-in functions use them too: help(round) shows round(number, ndigits=None).
• When you mix the two kinds of argument in a call, positional arguments must come first.

Copy
print(say_hello(name='Ada', 'Grace'))

Copy
SyntaxError: positional argument follows keyword argument

Copy
def say_hello(greeting='Hello', name='World'):
    return greeting + ', ' + name + '!'

print(say_hello())                                # both defaults
print(say_hello('Hi'))                            # one positional
print(say_hello(name='Ada'))                      # one keyword
print(say_hello('Hi', 'Ada'))                     # both positional
print(say_hello('Hi', name='Ada'))                # positional, then keyword
print(say_hello(name='Ada', greeting='Hi'))       # both keyword, in any order

Functions can call other functions

• A function hides how a calculation is done, so other code can use it without worrying about the details.
• That includes other functions: build bigger functions out of smaller ones. This is called composition.
• For example, converting Fahrenheit to Kelvin goes through Celsius:

Copy
def fahr_to_cels(fahr):
    cels = (fahr - 32) * (5 / 9)
    return cels

def fahr_to_kelv(fahr):
    cels = (fahr - 32) * (5 / 9)
    kelv = cels + 273.15
    return kelv

print(fahr_to_kelv(32))
print(fahr_to_kelv(212))

Copy
273.15
373.15

• The Fahrenheit-to-Celsius formula appears twice. If we found a typo in one copy, we'd have to remember to fix the other.
• Call fahr_to_cels from fahr_to_kelv instead, so the formula lives in one place:

Copy
def fahr_to_cels(fahr):
    return (fahr - 32) * (5 / 9)

def fahr_to_kelv(fahr):
    return fahr_to_cels(fahr) + 273.15

print(fahr_to_kelv(212))

Copy
373.15

• Each function now does one small job, which makes it easier to read and to check.

Copy
def fence(original, wrapper):
    return wrapper + original + wrapper

def double_fence(original, inner, outer):
    return fence(fence(original, inner), outer)

print(double_fence('name', '-', '*'))

Copy
*-name-*

Copy
def another_function
  print("Syntax errors are annoying.")
   print("But at least python tells us about them!")
  print("So they are usually not too hard to fix.")

Copy
def another_function():
    print("Syntax errors are annoying.")
    print("But at least Python tells us about them!")
    print("So they are usually not too hard to fix.")

Copy
def report(pressure):
    print('pressure is', pressure)

print('calling', report, 22.5)

Copy
calling <function report at 0x7fd128ff1bf8> 22.5

Copy
print("calling")
report(22.5)

Copy
calling
pressure is 22.5

Copy
def first_negative(values):
    for v in ____:
        if ____:
            return ____

Copy
def first_negative(values):
    for v in values:
        if v<0:
            return v

Copy
my_list = []
print(first_negative(my_list))

Copy
None

Copy
def print_date(year, month, day):
    joined = str(year) + '/' + str(month) + '/' + str(day)
    print(joined)

Copy
print_date(day=1, month=2, year=2003)

Copy
import random
for i in range(10):

    # simulating the mass of a chicken egg
    # the (random) mass will be 70 +/- 20 grams
    mass = 70 + 20.0 * (2.0 * random.random() - 1.0)

    print(mass)
    # egg sizing machinery prints a label
    if mass >= 85:
        print("jumbo")
    elif mass >= 70:
        print("large")
    elif mass < 70 and mass >= 55:
        print("medium")
    else:
        print("small")

Copy
# revised version
import random
for i in range(10):

    # simulating the mass of a chicken egg
    # the (random) mass will be 70 +/- 20 grams
    mass = 70 + 20.0 * (2.0 * random.random() - 1.0)

    print(mass, print_egg_label(mass))

Copy
def print_egg_label(mass):
    # egg sizing machinery prints a label
    if mass >= 90:
        return "warning: egg might be dirty"
    elif mass >= 85:
        return "jumbo"
    elif mass >= 70:
        return "large"
    elif mass < 70 and mass >= 55:
        return "medium"
    elif mass < 50:
        return "too light, probably spoiled"
    else:
        return "small"