Functions. CSE 231, Rich Enbody. From Mathematics we know that functions perform some operation and return one value.

Size: px

Start display at page:

Download "Functions. CSE 231, Rich Enbody. From Mathematics we know that functions perform some operation and return one value."

Colin Pearson
5 years ago
Views:

1 Functions CSE 231, Rich Enbody From Mathematics we know that functions perform some operation and return one value. 2 1

2 Functions encapsulate the performance of some operation, so it can be used by others. (for example, the sqrt() function) 3 Consider a function to convert Celsius to Fahrenheit: Formula: F = C * Functional notation: F = g(c) where g(c) = C*

3 Invocation Math: F= g(c) Python: F = g(c) Terminology: argument C 5 Definition Math: g(c) = C* Python: def g(c): return C* Terminology: parameter C 6 3

4 Terminology Invocation (Call) F = g(c) function name; must meet regular variable naming rules Definition : indicates the body def g(c): of the function follows return C* keyword indicating function being defined indented function body (suite) in parenthesis is a list of parameters being passed 7 Python function call (invocation): F = g(0.0) function name; must have previously been defined in parenthesis is a list of arguments (expressions) 8 4

5 F = g(c) 1. Call copies argument C to parameter Temp 2. Control transfers to function g def g(temp): return Temp* F = g(c) 3. Expression in g is evaluated 4. Value of expression is returned to the invoker def g(temp): return Temp*

6 Operation name space celsius2fahrenheit def celsius2fahrenheit (x): return x* c = 100 f = celsius2fahrenheit(c) print(f) Defines celsius2fahrenheit (associates the function body to the name celsius2fahrenheit) 11 Operation name space celsius2fahrenheit c 100 def celsius2fahrenheit (x): return x* Associates the value 100 to the variable c. c = 100 f = celsius2fahrenheit(c) print(f) 12 6

7 Operation def celsius2fahrenheit (x): return x* c = 100 f = celsius2fahrenheit(c) print(f) name space celsius2fahrenheit c c2f name space x Invocation: 100 Creates a local namespace for celsius2fahrenheit. Associates the value of the parameter x to argument c (associates 100 with x). 13 Operation def celsius2fahrenheit (x): return x* name space celsius2fahrenheit c c2f name space x 100 c = 100 f = celsius2fahrenheit(c) print(f) Transfers control to function celsius2farenheit 14 7

8 Operation def celsius2fahrenheit (x): return x* c = 100 f = celsius2fahrenheit(c) print(f) name space celsius2fahrenheit c c2f name space x Return command: 100 evaluates the expression 15 Operation def celsius2fahrenheit (x): return x* (212) c = 100 f = celsius2fahrenheit(c) print(f) name space celsius2fahrenheit c f c2f name space x Return command: Evaluates the expression. Returns the value: 212. f added to namespace and associated with 212. Function namespace deleted. Parameter x exists only in the function celsius2fahrenheit s namespace 16 8

9 Operation def celsius2fahrenheit (x): return x* ;... c = f = celsius2fahrenheit(c) print f... Name space celsius2 = c = 100 f = 212 Continues sequential execution 17 Verbose Python Invocation Math: F= g(c) Python: cels_temp = 100 fahr_temp = celsius_to_fahrenheit(cels_temp) print(cels_temp, in Fahrenheit is:,fahr_temp) 18 9

10 Example 16 simplefns This example illustrates the construction and use of several functions. Verbose Python Definition Math: g(c) = C* Python: def celsius_to_fahrenheit(cels_temp): return cels_temp*

11 Program Abstraction 1. Get Temperature 2. Convert Temperature 3. Display Temperature 21 Needed Behavior Please enter a temperature in degrees Celsius: 19.5 Original: 19.5 C Equivalent: 67.1 F 22 11

12 Get a temperature def get_temp(): cels_temp = input(\ Please enter \ temperature in degrees \ Celsius: ") return float(cels_temp) 23 Convert def celsius_to_fahrenheit(cels_temp): result = cels_temp* return result 24 12

13 Display results def display(cels_temp,fahr_temp): print("original: ",cels_temp) print("equivalent:",fahr_temp) print() 25 The function arguments are passed in order to the function parameters. The names need not match

14 When a function runs, it defines a new namespace. The names in the function s namespace are only available to the function. 27 Passing arguments by reference: the first argument passes its namespace reference to the first parameter, second to second, and so on. What gets passed? 28 14

15 my_int = 25 my_function(my_int) def my_function(an_int): print(an_int) print(my_int) my_int reference 25 reference an_int main namespace Python objects my_function namespace 29 Both namespaces now refer to the same object: the reference got passed. What happens if the function changes that variable? 30 15

16 my_int = 25 my_function(my_int) print(my_int) def my_function(an_int): an_int = 37 print(an_int) my_int reference reference an_int main namespace Python objects my_function namespace 31 The object (int) is immutable: it wasn t changed. The function namespace simply updated its reference to a new object. The reference in the calling program was unaffected

17 my_list = [1,2,3] my_function(my_list) print(my_list) def my_function(a_list): a_list[0] = 100 print(a_list) my_list reference 100 [1,2,3] reference a_list main namespace Python objects my_function namespace 33 Local Objects A function has its own namespace ( local ), so a parameter is in the function s namespace so any use outside the function is an error. any variable assigned in the function is in the function s namespace so it is not available outside of the function

18 a = 25 my_function(a) print(a) def my_function(b): a = 37 print(a, b) a reference reference b a main namespace Python objects my_function namespace 35 Why Functions? 18

19 Functions for better design Functions are very useful to break the program down into small, understandable, maintainable pieces Example: def get_temp(none) def celsius_to_fahrenheit(temp) def display(fahr_temp, cels_temp) 37 Software engineering There is a discipline of computer science dedicated to the systematic development and maintenance of software. There are a number of approaches that SE use: modularization, proveability, testing, refactoring and others

20 Refactoring: reexamine code to improve its readability while not changing its functionality. For example, extracting complicated code into multiple functions, creating better abstractions. 39 Function rules of thumb Should do one thing. A function abstracts one idea. Should not be overly long (~one page of code). Best if generic so it could be reused elsewhere

21 Functions Reuse Abstraction (Encapsulation) 41 PerfectNumbers Fn 21

22 List passed but not returned In classify_value, a list is passed but never returned This is because the calling program and the function share the same reference, and since the list is mutable a change in the function is a change to the calling 43 Our own data structure The variable result defines our own data structure: o the first element is a list o the second and third are integers We add perfect numbers to the first list, and keep the abundant and deficient in the two counts 44 22

23 isolate complicated printing print_results isolates the messy formatting of the output hiding complicated details is one thing that functions do well. 45 mileage puzzle 23

24 Car Talk Puzzler The Palindromic Odometer Driving along, Terry notices that the last four digits on the odometer are palindromic. A mile later, the last five digits are palindromic. A mile later, the middle four digits are palindromic. One mile after that, all six are palindromic. What was the odometer reading when Terry first looked at it? 47 making a main function it is common to create the main function that starts the whole program running now when we run our file, it defines the main function which we must call manually

25 extensive use of continue checks for non-palindromes under the required circumstances and continues makes the process more efficient. 49 checking time import time start = time.time() #... do stuff... end = time.time() print( It took:,end-start, seconds ) 50 25

26 refactoring what if you want to check a different approach to palindrome? It is easy to refactor this program. Provide a new function with a different definition to see the effect. functions make refactoring easier 51 26

Functions. Rich Enbody. From Mathematics we know that functions perform some operation and return one value.

Functions. Rich Enbody. From Mathematics we know that functions perform some operation and return one value. Functions Rich Enbody From Mathematics we know that functions perform some operation and return one value. 2 1 Functions encapsulate the performance of some operation, so it can be used by others. (for