Lecture Notes 06: Intro to Functions

Execution Control Flow

Imagine you want to give someone directions of how to drive from A to B in Mexico City, and then, how to return through a different path:

Low level of abstraction:

1. Get into the car
2. put the key in the ignition
3. turn the key
4. put the car in Drive
5. press the accelerator until you reach 1000 feet
6. turn the wheel left until the car is facing 90 degrees left from the "previous direction",
7. then straighten the wheel
8. press the accelerator until you reach 1000 feet
9. turn the wheel right until the car is facing 90 degrees right from the "previous direction",
10. then straighten the wheel
11. press the accelerator until you reach 200 feet
12. press the breaks until you get to 0 mph and park.

1. Get into the car
2. put the key in the ignition
3. turn the key
4. put the car in Drive
5. press the accelerator until you reach 200 feet
6. turn the wheel left until the car is facing 90 degrees left from the "previous direction",
7. then straighten the wheel
8. press the accelerator until you reach 200 feet
9. turn the wheel left until the car is facing 90 degrees left from the "previous direction",
10. then straighten the wheel
11. press the accelerator until you reach 1450 feet
12. turn the wheel left until the car is facing 90 degrees left from the "previous direction",
13. then straighten the wheel
14. press the accelerator until you reach 1200 feet
15. turn the wheel left until the car is facing 90 degrees left from the "previous direction",
16. then straighten the wheel
17. press the accelerator until you reach 1200 feet
18. press the breaks until you get to 0 mph and park.

High level of abstraction:

1. Get into the car
2. put the key in the ignition
3. turn the key
4. put the car in Drive

1. press the accelerator until you reach x feet

1. turn the wheel right until the car is facing x degrees right from the "previous direction",
2. then straighten the wheel

1. turn the wheel left until the car is facing x degrees left from the "previous direction",
2. then straighten the wheel

1. press the breaks until you get to 0 mph and park.

1. turn_on_car ()
2. drive_straight (1000)
3. turn_left (90)
4. drive_straight (1000)
5. turn_right (90)
6. drive_straight (200)
7. apply_breaks()

1. turn_on_car ()
2. drive_straight (200)
3. turn_left (90)
4. drive_straight (200)
5. turn_left (90)
6. drive_straight (1450)
7. turn_left (90)
8. drive_straight (1200)
9. turn_left (90)
10. drive_straight (50)
11. apply_breaks()

• Note 1: When giving the instructions, we must "wait" for each step of the "invoked" set of actions to get executed, and only then do we continue where we left off. In other words, the sequence of execution (or execution flow) jumps around.



• Note 2: There are two sections of actions here:
  
  1. the "memorized" sequences (or known routines);
  
  
  2. the set of instruction calls.

Functions: Motivation

Answer the following questions:

Activity 2 [2 minutes]:

Indentation

Just as in the example with the "Driving Directions", there are two "types" of sections of instructions:

• The section that has series of actions that have been memorized but are not currently in use
• And the section that has either simple instructions to be executed, or calls to routines that should be executed at that point

Indentation in Python

Functions: How to make them?

We called the ones you make "User-defined" functions.

We follow some rules to make a function:

1. use the def keyword to let the interpreter know that what follows is a function definition
   (it doesn't matter where the def goes as long as it is defined above where it is invoked)
   when the Python interpreter encounters the def (or class) keywords, it only stores those definitions for later use and doesn’t actually execute them until you tell it to
2. indicate the name of the function (use Python coding conventions.
3. add a parenthesis pair to indicate the input parameter section
4. inside the parens, add a coma-sepparated list of input parameters
5. add a colon (  :  ) to indicate the start of the function body
6. indent once (2 or 4 spaces is standard, and it can be done with a single tab)
7. add the body of the function
8. IF the function is expected to return something, add the keyword return, followed by the value or variable you wish to return

Example 1

• it acccepts no input
• it returns no output
• it simply prints a default message to the console (sound familiar)

# function definition
def hi():
  print("hello world!")

Example 2

• it accepts 1 input parameter (an integer)
• it returns no output
• it simply prints a default message to the console (sound familiar)

# function definition
def append(num):
  print("I got this input:", end=" ")
  print(num)

# statement area
append(2)
print("done!")

Example 3

• it accepts 1 input parameter (an integer)
• it returns as output the next integer
• it does not print anything to console

# function definition
def next(num):
  return num + 1

# statement area
nxt = next(2)
print(nxt)
print("done!")

Example 4

• it accepts 2 input parameters (two integers)
• it returns as output the remainder of dividing the first by the second integer
• it does not print anything to console

# function definition
def mod(a, b):
  return a%b

# statement area
remainder = mod(256, 5)
print(remainder)

The main

Python executes instructions top-down unless we split the code into "functions".

There is a way to force Python to start execution inside a function.

This is a good idea for reasons that will be explaned later.

Forcing the start of a main function

1  
2  
3  
4  
5  

def main():
    print("Hello World!")

if __name__ == "__main__":
    main()

1  
2  
3  
4  
5  
6  
7  
8  
9  

def main():
    print("Larry")

print("Curly")

if __name__ == "__main__":
    main()
    
print("Moe")

if __name__ == "__main__":
    main()

Multiple returns (simple version)

A function can return multiple elements, if needed. We'll see a more advanced way to do this later, but for now the following works:

def sum_and_mult ( a, b):
    num_sum = a+b
    num_mult = a*b
    return num_sum, num_mult
    
def main ():
    n1 = 3
    n2 = 8
    x, y = sum_and_mult(n1,n2)
    print("the sum of {} and {} is {};" \
    "their mult is {}" .format(n1, n2, x, y) )
    
if __name__ == "__main__":
    main()

Using Functions: A worked Example

Look at the following code:

def turn_on_car ():
  """ prints steps to turn on car

  """
  print("Get into the car")
  print("put the key in the ignition")
  print("turn the key")
  print("put the car in Drive")

def drive_straight (x):
  """ prints steps to drive some distance

  Args: an integer representing a distance in feet 
  Returns: nothing
  """
  print ("press the accelerator until you reach {:d} feet".format(x))

def apply_breaks ():
  """ prints steps to stop a car

  """
  print("press the breaks until you get to 0 mph and park.")

def turn_right (x):
  """ prints steps to turn to the right

  Args: an integer representing an angle in degrees 
  Returns: nothing
  """
  print("turn the wheel right until the car is facing {:d} degrees right from the 'previous direction',".format(x))
  print("then straighten the wheel")

def turn_left (x):
  """ prints steps to turn to the left

  Args: an integer representing an angle in degrees 
  Returns: nothing
  """
  print("turn the wheel left until the car is facing {:d} degrees left from the 'previous direction',".format(x))
  print("then straighten the wheel")

# main() IS THE START POINT FOR EXECUTION
def main():
  print("You call your friend and tell them: ")
  #here is where we'll add the function "CALLS"


# This defaults to calling the main function: 
# (We'll discuss this later)
if __name__ == "__main__":
  main()

Functions: Terminology

Functions: API for Built-in functions

We use built-in functions depending how they were constructed.
We know hoe to use a thing whe it is intuitive OR when it comes with instructions!

The instructions for using built-in functions for programming an application is called the
Application Programming Interface, or API.

A good API for Python can be found here: Python 3.9.7 API

The API section specific to built-in functions can be found here: Built-In Functions in Python 3.9.7 API

For example, the info for the round function will have a way of using it:


Note that the things in brackets are optional parameters (you can choose to add them if you need them).

As an example of how to read the input with the round function:

1. round(2.672)    # which will round up to 3; or, with
2. round(2.672, 2)    # which will round down to 2.67

Before next class (Monday)