Function Composition (functions calling functions)

Section 8.8 Function Composition (functions calling functions)

It is important to understand that each of the functions we write can be used and called from other functions we write. This is one of the most important ways that computer programmers take a large problem and break it down into a group of smaller problems. This process of breaking a problem into smaller subproblems is called functional decomposition.

Here’s a simple example of functional decomposition using two functions. The first function called square simply computes the square of a given number. The second function called sum_of_squares makes use of square to compute the sum of three numbers that have been squared.

Even though this is a pretty simple idea, in practice this example illustrates many very important Python concepts, including local and global variables along with parameter passing. Note that the body of square is not executed until it is called from inside the sum_of_squares function for the first time on line 6.

Also notice that when square is called (at Step 8, for example), there are two groups of local variables, one for square and one for sum_of_squares. Each group of local variables is called a stack frame. The variables x, and y are local variables in both functions. These are completely different variables, even though they have the same name. Each function invocation creates a new frame, and variables are looked up in that frame. Notice that at step 9, y has the value 25 in one frame and 2 in the other.

What happens when you to refer to variable y on line 3? Python looks up the value of y in the stack frame for the square function. If it didn’t find it there, it would go look in the global frame.

In the example below, we create a turtle drawing program that uses function composition.

import turtle
import random

def random_col(tur):
     """ Sets turtle to a random color """
     red = random.random()
     green = random.random()
     blue = random.random()
     tur.color(red, green, blue)

def random_location(tur):
     """ Take turtle to a random location on canvas
     Pre-conditions: Assume canvas is 400 x 400 """
     x = random.randrange(-180, 180) # get random x location
     y = random.randrange(-180, 180) # get random y location
     tur.penup()
     tur.goto(x,y) # move to location without drawing
     tur.pendown()

def draw_triangle(tur, side_length):
    """ draws a triangle in current position and color"""
    for _ in range(3):
        tur.forward(side_length)
        tur.left(120)

def draw_square(tur, side_length):
    """ draws a square in current position and color"""
    for _ in range(4):
        tur.forward(side_length)
        tur.left(90)

def draw_design(tur, side_length):
    """ draws a square with two internal triangles """
    random_location(tur)
    random_col(tur)
    draw_square(tur, side_length)
    draw_triangle(tur, side_length)
    tur.forward(side_length)
    tur.left(90)
    tur.forward(side_length)
    tur.left(90)
    draw_triangle(tur, side_length)

wn = turtle.Screen()
yan = turtle.Turtle()
yan.speed(10)

for _ in range(5):
     side = random.randrange(30, 100)
     draw_design(yan, side)

The turtle example above has 5 different functions. Two of them are helper functions that move a turtle to a random location and set a turtle to draw in a random color. The other three are drawing functions that cause the turtle to draw things. The global part of the code (lines 47-53) creates the window and the turtle and sets the turtle speed to 10 so the turtle draws quickly. Then there is a for loop that iterates 10 times. Each time through the loop a new random size is generated and then the draw_design() function is called with the random size. The draw_design function calls the other four functions, ane even calls the draw_triangle function twice.

Check your Understanding

Checkpoint 8.8.1.

1. Write two functions, one called addit and one called mult. addit takes one number as an input and adds 5. mult takes one number as an input, and multiplies that input by whatever is returned by addit, and then returns the result.

You have attempted of activities on this page.

Prev Top Next