Defining Functions

Today's Goal Learn to write your own functions

Functions Recall that a function is like a mini-program: Takes input Performs calculations Produces result

Anatomy of a Function Definition Function name Parameters A function definition consists of 1. Interface: Specifies Function name Parameters 2. Implementation Statements that perform the work def add(x, y): result = x + y return result

A Basic Example The drawSquare function: takes no parameters draws a square of fixed size using the turtle created by the main program Note that the functions must be defined at the top of the program import turtle def drawSquare(): for i in range(4): t.forward(20) t.left(90) # ---- main program ---- t = turtle.Turtle() drawSquare()

An Example with Parameters We want two different turtles to be able to draw a square Our new drawSquare() needs two parameters from the main program: Turtle to use to draw Length of side of square def drawSquare(t, size): for i in range(4): t.forward(size) t.left(90) # ---- main program ---- alex = turtle.Turtle() drawSquare(alex, 40) greta = turtle.Turtle() drawSquare(greta, 20)

More About Parameters Formal parameters Parameters in Function Definition Placeholders for values supplied by code that calls the function Called "Formal Parameters" Parameters in Calling Code Supply values to function Called "Actual Parameters" or "Arguments" When a function is called, values from the arguments are copied to the formal parameters def drawSquare(t, size): for i in range(4): t.forward(size) t.left(90) # ---- main program ---- alex = turtle.Turtle() drawSquare(alex, 40) Actual parameters (aka Arguments)

Returning Data A function can return a value to its caller using the return statement The return statement specifies a value to be transmitted back to the caller. When the return statement executes, the specified value is copied back to the variable in the calling assignment statement. Demo: Trace execution in CodeLens Textbook 6.2 Functions that Return Values def square(x): answer = x * x return answer result = square(10) print(result) 100

Returning Multiple Values A function can return two or more values. def divide(x, y): quotient = x // y remainder = x % y return (quotient, remainder) (quo, rem) = divide(10, 3) print(quo, rem)

Calling Functions in Expressions The data returned by a return statement can be used in any expression Doesn't have to be in an assignment statement def add(x, y): result = x + y return result print( add(2, 3) ) y = 5 * add(5, 10) z = add(add(2, 3), y)

Type Hints result = x + y return result You can specify the data types of the parameters and the return value by adding type hints A type hint specifies the expected data type for a particular parameter or for the return type The type hints are for readers of your code They are not checked by the Python interpreter Data Type names: int, float, bool, str Parameter type hints def add(x, y): result = x + y return result def add(x: float, y: float) -> float: Return type hint

Practice Write a function named max that takes two numbers and returns the larger. Write a function named roundIt that takes a positive number and rounds it to the nearest integer (hint: think about adding .5 and then dropping any fractional portion). Include type hints.

Practice The program below finds the largest number in a list of positive numbers entered by the user. Rework the following code to use max(): largest = 0 num = 0 while num != -1: num = int(input(("Enter a number (-1 to quit): ")) if num > largest: largest = num print('The largest number was', largest) def max(x: int, y: int) -> int: if x > y: return x else: return y

Why Create Functions? Two key reasons: Manage complexity Eliminate duplicate code

Duplicate Code Duplicate code is a Great Evil When you copy and paste code, you copy the bugs in the code Duplicate code leads to larger, more complicated programs Practice: Create a function to eliminate the duplicate code alex.forward(30) alex.right(120) greta.forward(50) greta.right(120)

Managing Complexity Large programs are complicated. To manage the complexity, we break the programs up into functions. We can Test each function separately Reason about each function separately Functions are a key mechanism that makes abstraction possible. Abstraction (n). Hiding information to manage complexity.

Abstraction Abstraction is one of the Big Ideas in Computer Science. It makes digital technology possible. Without it, there would be no Smart phones Internet Digital messaging Why?