7. Functions

We have been using functions all along. In fact, the Hello, world! example used the print() function to print to the terminal. Here, we take an in-depth look at how to create functions. Remember, functions are just verbs or actions, they do something. The basic syntax for defining a function is as follows.

def <function_name>(<parameters:optional>):
   # perform logic
   # optional return

The <function_name> is the name of the function, and the <parameters:optional> denote variables that are passed into the function. A function may or may not return data. In the case where something is returned back to the caller, a return command must be used, followed by what is being returned back. The print() function is an example of a function that does not return anything.

Note

Naming things is hard in computer science. Typically, variables should be nouny and functions should be verby. Meaning, variable names should look like nouns and function names should look like verbs.

Note

The values, variables, parameters or arguments that are passed into a function are called inputs while the item being passed back out through the return statement is called the output. Typically, a function can have any number of inputs, but only one output. In the case where multiple outputs are required, such outputs are stored in a single data structure such as a list, set, tuple or dictionary.

7.1. Basic function

Your most basic function could just print Hello, world!. Notice that there are no variables passed to the function (thare are no variables defined inside the parentheses). Also, nothing is returned from this function (there is no return statement).

def say_hello():
   print('Hello, world!')

To use this function, we simply type in the name followed by parentheses say_hello(). Functions are a way to group logic that can be reused. If we want to reuse the function, simply call it again. When we call a function, this usage is sometimes referred to as invoking the function. When we say use, call or invoke the function, we mean the same thing.

def say_hello():
   print('Hello, world!')

# call the function above twice
say_hello()
say_hello()

# call the function above 10 times using a loop
# note we use the range() function which generates a range of numbers
# from zero up to (and excluding) the specified number
for _ in range(10):
   say_hello()

Now, we want to modify say_hello() to accept an argument name and invoke it 10 times.

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

# invoke the function once
say_hello('Sarah')

# invoke the function many times using a loop
names = ['John', 'Jack', 'Sam', 'Jeff']

for name in names:
   say_hello(name)

What if we want to say hello to a person using their first and last name?

def say_hello(first_name, last_name):
   print(f'Hello, {first_name} {last_name}!')

# invoke the function once
say_hello('Sarah', 'Smith')

# invoke the function many times using a loop
names = [('John', 'Smith'), ('Jack', 'Johnson'), ('Sam', 'Smith'), ('Jeff', 'Johnson')]

for fname, lname in names:
   say_hello(fname, lname)

7.1.1. Exercise

Write a function called say_bye() that prints Bye, world!. Call this function once and then call this function 20 times.

Solution.

def say_bye():
   print('Bye, world!')

say_bye()

for _ in range(20):
   say_bye()

7.1.2. Exercise

Write a function to characterize the weather qualitatively based on the temperature (the temperature is a required parameter).

• if the temperature is less than or equal to 60, print cold

• else if the temperature is less than or equal to 80, print cool

• else if the temperature is less than or equal to 90, print warm

• else print hot

Solution.

def describe_weather(temperature):
   if temperature <= 60.0:
      print(f'{temperature} is cold')
   elif temperature <= 80.0:
      print(f'{temperature} is cool')
   elif temperature <= 90.0:
      print(f'{temperature} is warm')
   else:
      print(f'{temperature} is hot')

# invoke the function once
describe_weather(77.7)

# invoke the function many times using a loop
temperatures = [30.2, 77.5, 80.2, 101.1]

for temperature in temperatures:
   describe_weather(temperature)

7.2. Function with one arguments

Here are two functions add_one() and minus_one(). Each of these functions take in a parameter, argument or variable named num. While add_one() adds one to the passed in integer and returns that result, subtract_one() subtracts one from the passed in integer and returns that result.

def add_one(num):
    return num + 1


def minus_one(num):
    return num - 1;


x = 10

y = add_one(x)
z = minus_one(x)

7.2.1. Exercise

Write two functions.

• times_two(num) should multiply the passed in number by 2 and return the result

• divide_by_two(num) should divide the passed in number by 2 and return the result

Invoke these functions for a variety of numbers.

Solution.

def times_two(num):
   return num * 2

def divide_by_two(num):
   return num / 2

numbers = [32, 17, 8, 5, 18]

for number in numbers:
   result_1 = times_two(number)
   result_2 = divide_by_two(number)

   print(f'results of passing in {number} to functions are {result_1} and {result_2}')

7.2.2. Exercise

Write a function to characterize the weather qualitatively based on the temperature (the temperature is a required parameter).

• if the temperature is less than or equal to 60, return cold

• else if the temperature is less than or equal to 80, return cool

• else if the temperature is less than or equal to 90, return warm

• else return hot

Convert the list of quantitative temperatures below to one of qualitative values using the new function defined.

temperatures = [30.2, 77.5, 80.2, 101.1]

Solution.

def describe_weather(temperature):
   if temperature <= 60.0:
      return 'cold'
   elif temperature <= 80.0:
      return 'cool'
   elif temperature <= 90.0:
      return 'warm'
   else:
      return 'hot'

# use a list comprehension
temperatures = [30.2, 77.5, 80.2, 101.1]
conditions = [describe_weather(t) for t in temperatures]
print(conditions)

7.2.3. Exercise

Write a functions to compute compute the area and perimeter of a square e.g. get_area(side) and get_perimeter(side).

• area = side x side

• perimeter = side x 4

Compute the areas and perimeters for the following squares (represented by integers) in the list.

squares = [10, 5, 88, 3, 4, 3]

Solution.

def get_area(side):
   return side * side

def get_perimeter(side):
   return side * 4

squares = [10, 5, 88, 3, 4, 3]

for side in squares:
   area = get_area(side)
   perimeter = get_perimeter(side)

   s = f'side={side} | area = {area} | perimeter = {perimeter}'
   print(s)

7.2.4. Exercise

Write a functions to compute compute the area and circumference of a circle e.g. get_area(radius) and get_circumference(radius).

• area = 3.14 x radius x radius

• circumference = 2 x 3.14 x radius

Compute the areas and perimeters for the following circles (represented by integers) in the list.

circles = [10, 5, 88, 3, 4, 3]

Solution.

def get_area(radius):
   return 3.14 * radius ** 2

def get_circumference(radius):
   return 2 * 3.14 * radius

circles = [10, 5, 88, 3, 4, 3]

for radius in circles:
   area = get_area(radius)
   circumference = get_circumference(radius)

   s = f'radius={radius} | area = {area} | circumference = {circumference}'
   print(s)

7.3. Function with two arguments

Here is a demonstration of a function with two arguments and a return value.

# function with 2 arguments
def multiply(a, b):
    return a * b


x = 10
y = 8

z = multiply(x, y)

7.3.1. Exercise

Create the following functions.

• add(a, b) should add a and b and return the result

• minus(a, b) should subtract a from b and return the result

• times(a, b) should multiply a and b and return the result

• divide(a, b) should divide b by a and return the result

Invoke these functions for a variety of pairs of numbers and print the results.

pairs = [(10, 2), (13, 4), (16, 5), (88, 7)]

Solution.

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

def minus(a, b):
   return b - a

def times(a, b):
   return a * b

def divide(a, b):
   return b / a

pairs = [(10, 2), (13, 4), (16, 5), (88, 7)]

for a, b in pairs:
   s = """
   {a} + {b} = {add(a, b)}
   {a} - {b} = {minus(a, b)}
   {a} * {b} = {times(a, b)}
   {a} / {b} = {divide(a, b)}
   """.strip()

   print(s)
   print('')

7.3.2. Exercise

Write a functions to compute compute the area and perimeter of a rectangle e.g. get_area(width, length) and get_perimeter(width, length).

• area = width x length

• perimeter = 2 x width + 2 x length

Compute the areas and perimeters for the following rectangles (represented by tuples) in the list.

rectangles = [(10, 5), (88, 3), (4, 3)]

Solution.

def get_area(width, length):
   return width * length

def get_perimeter(width, length):
   return 2 * width + 2 * length

rectangles = [(10, 5), (88, 3), (4, 3)]

for width, length in rectangles:
   area = get_area(width, length)
   perimeter = get_perimeter(width, length)

   s = f'width={width}, length={length} | area = {area} | perimeter = {perimeter}'
   print(s)

7.3.3. Exercise

Write a functions to compute compute the area of a triangle e.g. get_area(base, height).

• area = 0.5 x base x height

Compute the areas for the following triangles (represented by tuples) in the list.

triangles = [(10, 5), (88, 3), (4, 3)]

Solution.

def get_area(base, height):
   return 0.5 * base * height

triangles = [(10, 5), (88, 3), (4, 3)]

for base, height in triangles:
   area = get_area(base, height)

   s = f'base={base}, height={height} | area = {area}'
   print(s)

7.4. Function with three arguments

Here is an example of a function with 3 arguments as inputs, and the output is the product of the inputs.

# function with 3 arguments
def multiply(a, b, c):
    return a * b * c


w = 10
x = 8
y = 4

z = multiply(w, x, y)

7.4.1. Exercise

Write a function that takes in 3 integer arguments compute(x, y, z). The function return the result of x + y * z.

Solution.

def compute(x, y, z):
   return x + y * z

print(compute(10, 5, 8))

7.5. Function with a list argument

A function can accept anything as input, including other other functions! Here, concat() accepts a list of strings as input and returns the concatenation of the strings in the list using the join() function.

# function with list argument
def concat(names):
    return ','.join(names)


first_names = ['John', 'Jack', 'Joe']
s = concat(first_names)

7.5.1. Exercise

Python has many built-in functions for math operations. The sum() function takes in a collection of numbers and returns the sum across all the values. The len() function takes in a collection of numbers and returns the number of elements in that collection. Write a function get_average(numbers) that returns the expected value of a list of numbers. Remember, the expected value is the sum of the numbers divided by the total number of elements.

numbers = [5, 18, 29, 787, 2, 3, 88]

Solution.

def get_average(numbers):
   total = sum(numbers)
   n = len(numbers)
   average = total / n
   return average

numbers = [5, 18, 29, 787, 2, 3, 88]
average = get_average(numbers)
print(f'The average is {average:.5f}')

7.5.2. Exercise

Write a function to compute the sample variance of a list of numbers.

• the variance \(\sigma^2\) is defined as \(\sigma^2 = \frac{\sum (x_i - \bar x)^2}{n - 1}\)

numbers = [5, 18, 29, 787, 2, 3, 88]

Solution.

def get_average(numbers):
   total = sum(numbers)
   n = len(numbers)
   average = total / n
   return average

def get_variance(numbers):
   avg = get_average(numbers)
   n = len(numbers)
   variance = sum([(n - avg)**2 for n in numbers]) / (n - 1)
   return variance

numbers = [5, 18, 29, 787, 2, 3, 88]
variance = get_variance(numbers)
print(f'The variance is {variance:.5f}')

7.6. Function with default value argument

The inputs required by a function can be set to default values. Note that if an input has a default value, it must always come last! Below, we pass in a list of strings and want to join them. The default delimiter is a comma, but the user can choose to override that delimiter when they invoke the function.

# function with list argument
def concat(names, separator=','):
    return separator.join(names)


first_names = ['John', 'Jack', 'Joe']

s = concat(first_names)
print(s)

s = concat(first_names, separator='|')
print(s)

7.6.1. Exercise

Write a function that takes in two integer a and b as well as a math operation (+, -, *, /). The math operation should be set to + by default. Depending on the math operation, apply such operation to a and b and return the result.

a = 14
b = 8

Solution.

def do_operation(a, b, op='+'):
   if '+' == op:
      return a + b
   elif '-' == op:
      return a - b
   elif '*' == op:
      return a * b
   else:
      return a / b

a = 14
b = 8

ops = ['+', '-', '*', '/']

for op in ops:
   result = do_operation(a, b)
   s = f'{a} {op} {b} = {result}'
   print(s)

7.7. Non-keyworded, variable-length argument

If you require any number of inputs to a function, but do not know what these inputs will look like or how many of them there will be, you can define the inputs as a non-keyworded, variable-length argument. Such argument is conventionally defined as *args and must always come after all keyworded arguments are defined.

# non-keyworded, variable-length argument
def do_print(*args):
    for arg in args:
        print(arg)


def do_special_print(symbol, *args):
    for arg in args:
        print(symbol, arg)


names = ['John', 'Jack', 'Joe']

# use *, the unpacking operator
# * returns an iterable that is a tuple
do_print(*names)

do_special_print('*', *names)

Note

You can pretty much achieve the same effect of a non-keyworded, variable-length argument with an argument that is a list. What do you think is the difference between a function defined as do_it(*args) vs do_it(args=[])?

7.7.1. Exercise

Write a function to calculate the price of a pizza based on the toppings added to the pizza. The pizza itself cost $10.50. The topping costs are as follows.

• mushroom: $3.50

• suasage: $4.40

• olives: $1.25

• pepperoni: $2.00

• cheese: $1.25

• anchovy: $3.25

The function should specify a non-keyworded, variable-length argument to represent the toppings.

Solution.

def compute_cost(*toppings):
   prices = {
      'mushroom': 3.50,
      'suasage': 4.40,
      'olives': 1.25,
      'pepperoni': 2.00,
      'cheese': 1.25,
      'anchovy': 3.25
   }
   cost = sum([prices[topping] for topping in toppings if topping in prices])
   cost += 10.50
   return cost

print(compute_cost(*['mushroom', 'suasage']))
print(compute_cost(*['olives', 'pepperoni']))
print(compute_cost(*['cheese', 'pepperoni']))
print(compute_cost(*['mushroom', 'suasage', 'olives', 'pepperoni', 'cheese', 'anchovy']))

7.8. Keyworded, variable-length argument

In the case when you require any number of inputs to a function, but want the caller of the function to supply keywords associated with each of the inputs, you can define the inputs as a keyworded, variable-length argument. Such argument is conventionally defined as **kwargs and must come as the very last argument when defining a function.

# keyworded, variable-length argument
def do_print(**kwargs):
    for key, val in kwargs.items():
        print(key, val)


def do_special_print(symbol, **kwargs):
    for key, val in kwargs.items():
        print(symbol, key, val)


# use a dictionary
# use ** unpacking operating
data = {
    'name': 'John Doe',
    'age': 18
}

do_print(**data)

# inline keyworded argument
do_print(name='John Doe', age=18)

do_special_print('*', **data)

do_special_print('*', name='John Doe', age='18')

Note

You can also pretty much achieve the same effect of a keyworded, variable-length argument with an argument that is a dictionary. What do you think is the difference between a function defined as do_it(**kwargs) vs do_it(kwargs=dict())?

7.8.1. Exercise

We have students who are left- or right-handed as shown below. Write a function to get the average age of the left- and right-handed individuals. Return the results. Make sure you use a keyworded, variable-length argument function.

students = {
   'john': {'hand': 'left', 'age': 17},
   'jack': {'hand': 'right', 'age': 18},
   'jane': {'hand': 'left', 'age': 14},
   'mary': {'hand': 'right', 'age': 13},
   'joe': {'hand': 'left', 'age': 17},
   'james': {'hand': 'right', 'age': 14},
   'nancy': {'hand': 'left', 'age': 12},
   'norah': {'hand': 'right', 'age': 19},
}

Solution.

def get_average_ages(**persons):
   left_hand_ages = [data['age'] for _, data in persons.items() if data['hand'] == 'left']
   right_hand_ages = [data['age'] for _, data in persons.items() if data['hand'] == 'right']

   left_avg_age = sum(left_hand_ages) / len(left_hand_ages)
   right_avg_age = sum(right_hand_ages) / len(right_hand_ages)

   return {
      'left': left_avg_age,
      'right': right_avg_age
   }

students = {
   'john': {'hand': 'left', 'age': 17},
   'jack': {'hand': 'right', 'age': 18},
   'jane': {'hand': 'left', 'age': 14},
   'mary': {'hand': 'right', 'age': 13},
   'joe': {'hand': 'left', 'age': 17},
   'james': {'hand': 'right', 'age': 14},
   'nancy': {'hand': 'left', 'age': 12},
   'norah': {'hand': 'right', 'age': 19},
}

results = get_average_ages(**students)
print(results)

7.9. Mixed arguments

Here’s an example of a function with mixed argument/input types.

# mixed arguments: standard + *args + **kwargs
def do_print(a, b, *args, **kwargs):
    print(f'standard args: {a}, {b}')

    for arg in args:
        print(f'*args: {arg}')

    for key, val in kwargs.items():
        print(f'**kwargs: {key} => {val}')


do_print(1, 2, *[3, 4, 5], **{'name': 'John Doe', 'age': 18})

7.10. Required keyword arguments

You can enforce keyword arguments by using an asterisk before the arguments you want to force as keyword arguments.

def print_name(*, first_name, last_name):
   print(f'{first_name} {last_name}')

# print_name('john', 'doe') will not work
print_name(first_name='john', last_name='doe')

7.11. Unpacking tuple return type

We have already seen how to unpack tuples, here, we show how we can unpack a tuple returned from a function.

def get_names():
    return 'John', 'Joe', 'Jack'


# bad way of acquiring tuple elements
t = get_names()
name1 = t[0]
name2 = t[1]
name3 = t[2]

# better way of acquiring tuple elements
name1, name2, name3 = get_names()

7.12. Lambda

A lambda is a function, however, lambda functions are strictly defined as one line logic or one-liners. Take the say_hello() function below. This function can have multiple lines of statement, although, in this case, it only has one statement which is to print hello.

def say_hello():
   print('hello')

# call the function
say_hello()

Now, look at this function re-defined as a lambda.

say_hello = lambda: print('hello')

# call the lambda
say_hello()

It seems lambdas are suited for very simple logic (one-liners), and if you have complicated logic, you are better off using a function. Lambdas can also take in parameters/arguments.

# lambda with 1 argument
say_hello = lambda name: print(f'hello, {name}')

# call lambda
say_hello('John')
say_hello('Mary')

# lambda with 2 arguments
say_bye = lambda fname, lname: print(f'bye, {fname} {lname}')

# call lambda
say_bye('John', 'Doe')
say_bye('Mary', 'Smith')

Lambdas can return values.

# define lambdas
add_one = lambda x: x + 1
minus_one = lambda x: x - 1
times_two = lambda x: x * 2
divide_half = lambda x: x / 2

# call lambdas one at a time
print(add_one(1)) # should print 2
print(minus_one(1)) # should print 0
print(times_two(1)) # should print 2
print(divide_half(1)) # should print 0.5

# compose operations using lambdas
# should print 50
# 50 / 2 = 25
# 25 * 2 = 50
# 50 - 1 = 49
# 49 + 1 = 50
print(add_one(minus_one(times_two(divide_half(50)))))

Functions and lambdas can be passed as arguments themselves. Below, we have a generic math lambda called do_math() which takes in two numbers a and b as well as a function/lambda as op.

# define lambdas
add = lambda a, b: a + b
subtract = lambda a, b: a - b
multiply = lambda a, b: a * b
divide = lambda a, b: a / b

# this lambda takes in 3 arguments
# a and b are integers
# op is a function or lambda and will be applied to a and b
do_math = lambda a, b, op: op(a, b)

# call do_math and change the op
a, b = 12, 7
print(do_math(a, b, add))
print(do_math(a, b, subtract))
print(do_math(a, b, multiply))
print(do_math(a, b, divide))

# note here, we inline a lambda
print(do_math(a, b, lambda a, b: a ** b))

7.12.1. Exercise

If we have the following list of first and last names of people, transform that list to a new one where each element in the new list is the initials of the corresponding person. Try using lambdas to solve this problem.

names = [('John', 'Doe'), ('Jane', 'Smith')]

Solution.

get_initial = lambda name: f'{name.capitalize()[0]}'
get_initials = lambda fname, lname: f'{get_initial(fname)}.{get_initial(lname)}.'

names = [('John', 'Doe'), ('Jane', 'Smith')]
initials = [get_initials(fname, lname) for fname, lname in names]

print(initials)

7.12.2. Exercise

If you have the list of numbers below, create a new list from this one by including only

• those numbers that start with a 1 and

• have at least 3 digits

and transform those numbers by dividing by 2 and then raising the result to the power of 2.

numbers = [101, 100, 1003, 10002, 202, 13, 1234]

Solution.

transform = lambda x: (x / 2.0) ** 2.0
has_three_or_more_digits = lambda x: True if len(str(x)) >= 3 else False
starts_with_one = lambda x: str(x).startswith('1')
is_valid = lambda x: has_three_or_more_digits(x) and starts_with_one(x)

numbers = [101, 100, 1003, 10002, 202, 13, 1234]
nums = [transform(n) for n in numbers if is_valid(n)]

print(nums)

7.13. Generators

Generator functions are those that returns a stream of data back to the caller. The caller is able to treat the output of a generator function like an iterable collection. Here’s a simple example of a generator function that generates random colors in the set of red, green and blue. Note that we have to use yield to return the color.

from random import choice

def get_colors():
   n = 0
   while n < 100:
      yield choice(['red', 'green', 'blue'])
      n += 1

# get_colors() returns something
colors = get_colors()

# what do we get when we print colors?
print(colors)

# what is the type of colors?
print(type(colors))

# we can iterate through colors
for c in colors:
   print(c)

# we can convert the outputs of a generator to a list
colors = list(get_colors())
print(colors)

7.13.1. Exercise

Write a generator function that produces 50 random numbers in the range [0, 10]. Try using this generator function.

Solution.

from random import randint

def get_numbers():
   n = 0
   while n < 50:
      n += 1
      yield randint(0, 10)


numbers = list(get_numbers())
print(numbers)