Programming for Engineers in Python. Recitation 3 Functions

Transcription

1 Programming for Engineers in Python Recitation 3 Functions

2 Plan Short review FOR and Lists Python references Mutable vs. immutable data types List references Functions Scope Call by assignment Global variables Other types of functions Modules 1

3 Two ways to iterate list elements lst = [10, 20, 30, 40, 50] # Direct iteration over list elements for elem in lst: print elemt # Iterate using indices index_lst = range(len(lst)) for i in index_lst: print lst[i] Output:

4 Changing Elements in a list lst = [1, 4, 3, 6, 8] # take 1 for elem in lst: if elem % 2 == 0: elem = 0 print lst [1, 4, 3, 6, 8] TASK: Set even list elements to zero # take 2 index_lst = range(len(lst)) for i in index_lst: if lst[i] % 2 == 0: lst[i] = 0 print lst [1, 0, 3, 0, 0] 3

5 Python references Assigning a variable in Python creates: An object storing the value A name variable holding a reference to the object. In code: a = 5 In memory: a 5 name int object name reference int object 4

6 Python references Assigning a new variable to an existing variable copies the reference In code: a = 5 name int object b = a name name a name b name In memory: 5 int object 5

7 Python references Name variables can be redirected to point new objects In code: a = 5 In memory: name int object 6 b = a name name b = 6 name int object a name b name 5 object 6 object

8 Mutable objects can be modified after creation Can we modify an existing list? >>> a_list = [1,2,3] >>> a_list[2] 3 >>> a_list[2] = 'Inigo Montoya' >>> a_list [1,2,'Inigo Montoya'] Yes, the list was mutated (changed)! 7 Note: When referring to mutable/immutable we refer to modifying the object itself! Name variables can always be modified to point to a different object!

9 Immutable objects cannot be changed after creation Can we change an existing String? >>> name = 'Inigo Montoya' >>> name[0] 'I' >>> name[5] ' ' >>> name[3] = 't' Traceback (most recent call last): File "<pyshell#14>", line 1, in <module> name[3] = 't' TypeError: 'str' object does not support item assignment 8 No, Strings are Immutable!

10 Assignments of List Variables >>> orig_list = [1,2,3] >>> copy_list = orig_list >>> orig_list = [6,7,8,9] >>> copy_list [1,2,3] >>> orig_list [6,7,8,9] So far - no surprises 9

11 Assignments of List Variables >>> orig_list = [6,7,8,9] >>> copy_list = orig_list >>> orig_list[0] = 1000 >>> orig_list [1000,7,8,9] >>> copy_list [1000,7,8,9] Surprise! 10

12 List references In code: a = [1,2,3] name list object In memory: a [1,2,3] name reference list object 11

13 List references In code: a = [1,2,3] In memory: name list object b = a a [1,2,3] b 12

14 List references In code: a = [1,2,3] In memory: name list object b = a b = [4,5,6] a b [1,2,3] [4,5,6] 13

15 List references In code: In memory: a = [1,2,3] name list object b = a b = [4,5,6] a = b a b What happens to this list? [1,2,3] [4,5,6] 14

16 Changes to a mutable object will be reflected in all names referencing it In code: In memory: a = [1,2,3] name list object 15 b = a b = [4,5,6] a = b b[0] = 100 a b What happens to this list? [1,2,3] [100,5,6]

17 Memory A list variable is a reference to the information List assignment orig_list = [6,7,8,9] creates: a list object, [6,7,8,9] a reference from the variable name, orig_list, to this object. Memory orig_list [6,7,8,9] 16 See visual example in:

18 Different reference variables, same information The assignment copy_list = orig_list does not create a new object, just a new name variable, copy_list, which now refers to the same object. Memory orig_list [6,7,8,9] copy_list 17

19 Changing list information Mutating list elements, orig_list[0] = 1000, does not create a new object and does not change existing references. Memory orig_list [1000,7,8,9] copy_list 18

20 Changing list information: example 2 a = [1, 2, 3] a b = a a b a.append(4) a b 19

21 FUNCTIONS Why should we organize our code using functions? Break the problem into smaller sub-tasks Readability and Maintenance Re-usability Solve bugs once (Unit-testing, later on) 20

22 Functions How to write a new function: def name(arg1, arg2,...): ''' documentation''' #Optional documentation statements 21

23 Example: gcd 22 def gcd(a, b): "Return the greatest common divisor of a and b" while a!= 0: a, b = b%a, a # multiple assignment return b >>> gcd(12, 20) 4 >>> help(gcd) Help on function gcd in module main : gcd(a, b) Return the greatest common divisor of a and b (END)

24 return!= print #!!! def function_that_prints(): print "I printed" def function_that_returns(): return "I returned" ################################## f1 = function_that_prints() f2 = function_that_returns() print "Now let's see what the values of f1,f2 are" print f1 print f2 23

25 Example: phone book def search_book(book, name): '''Run through the repository, search for the name (case insensitive). Return [] if not found''' result = [] for contact in book: if contact[0].lower() == name.lower(): result = contact break return result >>> the_book = [['Nir', 1122], ['Ron', 2233], ['Orna', 3344]] >>> r = search_book(the_book, 'ORnA') >>> r ['Orna', 3344] 24

26 Example: phone book, cont def show_record(record): '''Show the obtained data record''' if len(record)!= 2: print 'Bad data' else: print 'Name: ' + record[0] print 'Phone: ' + str(record[1]) >>> the_book = [['Nir', 1122], ['Ron', 2233], ['Orna', 3344]] >>> r = search_book(the_book, 'ORnA') >>> show_record(r) Name: Orna Phone:

27 Functions Scope When python executes a function it creates a new scope for it: Defined parameters are local They are defined in the scope and then disappear Calling statement sees only the results Calling statement (in the main script or in some other function) input Function scope Local variables return Output 26 20

28 Functions Scope example 1 What will be printed? From the blog

29 28 Functions Scope example 1

30 Functions Scope example 1 What happened? 29

31 Functions Scope example 1 Prints the i of the global scope 30 21

32 Functions Scope example 1 The global i is masked by the local i defined in the function 31 21

33 Simulation i = 1 def foo(): i = 5 print "local",i print "global",i foo() i = 1 Local parameters: i = 5 32

34 Simulation i = 1 def foo(): i = 5 print "local",i print "global",i foo() print "global",i What will this do? 33

35 Simulation i = 1 def foo(): i = 5 print "local",i print "global",i foo() print "global",i What will this do? global 1 local 5 global 1 34

36 Simulation i = 1 def foo(): i = 5 print "local",i print "global",i foo() print "global",i What will this do? global 1 local 5 global 1 After the function ended, we are back to global scope, and the original variable is now unmasked. 35

37 Functions Scope example We will now watch 2 functions that implement the power function: 36

38 Immutable arguments We will now watch 2 functions that implement the power function: def power_for_num(n,pow): n = 5 n = n**pow return n power_for_num(n) 37

39 Immutable arguments We will now watch 2 functions that implement the power function: def power_for_num(n,pow): n = 5 n = n**pow return n power_for_num(n) Traceback (most recent call last): File "test.py", line 8, in <module> power1(n) TypeError: power_for_num() takes exactly 2 arguments (1 given) 38

40 Immutable arguments We will now watch 2 functions that implement the power function: def power_for_num(n,pow): n = 5 n = n**pow return n power_for_num(n) When you call a function, you must assign values to the function s arguments Traceback (most recent call last): File "test.py", line 8, in <module> power1(n) TypeError: power_for_num() takes exactly 2 arguments (1 given) 39

41 Immutable arguments def power_for_num(n,pow): n = n**pow return n n = 5 result = power_for_num(n,2) print n print result 40

42 Immutable arguments def power_for_num(n,pow): n = n**pow return n n = 5 result = power_for_num(n,2) print n print result 5 25 The function used the value in the global variable n, but the global variable didn t change. 41

43 Mutable arguments def power_first_element(l,pow): if len(l) == 0: return #nothing to raise l[0] = l[0]**pow return l[0] l = [5,6] print power_first_element(l,2) 25 42

44 Mutable arguments def power_first_element(l,pow): if len(l) == 0: return #nothing to raise l[0] = l[0]**pow return l[0] l = [5,6] print power_first_element(l,2) print l 25 [25,6] 43

45 Mutable arguments def power_first_element(l,pow): if len(l) == 0: return #nothing to raise l[0] = l[0]**pow return l[0] l = [5,6] print power_first_element(l,2) print l? 25 [25,6] 44

46 Pass Arguments By Assignment The caller specifies arguments (values) for the function call. These arguments are assigned to the variables, with which the function works. As we saw: assigning a value val to a variable named x makes x a reference to val. In program: x = 8 y = x In memory: x y 8 45

47 Pass Arguments By Assignment Cont. Similarly, function s parameters are references to the same values of the callers arguments. In program: x = -7 print abs(x) In memory, when abs starts running: Argument of abs x -7 Whether or not the function can change these values depends on whether their type is mutable. 46

48 Functions mutable example 1 def increment(lst): for i in range(len(lst)): lst[i] = lst[i]+1 # no value returned Now let us execute it in the following manner >>> list1 = [0, 1, 2, 3] >>> increment(list1) >>> list1 [1, 2, 3, 4] 48 list1 was mutated inside the body of increment(lst)! Such a change occurs only for mutable objects.

49 Functions mutable example 2 Consider the following function: def nullify(lst): lst = [] # no value returned Now let us execute it in the following manner >>> list1 = [0, 1, 2, 3] >>> nullify(list1) >>> list1 [0, 1, 2, 3] list1 has NOT changed! Why? 49

50 Global Variables In Python, a variable is local unless declared otherwise. def f(): print s s = 'bbb' print s >>> s = 'aaa' >>> f() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in f UnboundLocalError: local variable 's' referenced before assignment 50 Check here for more information

51 Global Variables In Python, a variable is local unless declared otherwise. (Is that so?) Mandatory def f(): global s print s s = 'bbb' print s >>> s = 'aaa' >>> f() aaa bbb >>> print s bbb Optional def f(): global s print s >>> s = 'aaa' >>> f() aaa 51 Check here for more information

52 Global Variables def foo(c, d): global a a = 42 c,d = d,c b = 11 print a,b,c,d >>> a,b,c,d = 1,2,3,4 >>> foo('cccc', 7) cccc >>> print a,b,c,d a = 142 b = 2 c = 3 d = 4 c = cccc 7 d = 7 cccc b = 11 52

53 Functions - Information Flow The ways to pass information from a function back to its caller: Return a value(s) Change a mutable argument Modify a global variable 53

54 Other functions Methods: members of specific types: Call by: variable_name.function_name(arguments) Examples: str.upper(my_string) list.append(my_list, 7) Write variable_name. Then type tab to get the list of variable members (press tab to choose one) Built-in functions (colored in IDLE) abs len my_string.upper() my_list.append(7) 54

55 Exercise merge lists Input: 2 ordered lists Output: merged ordered list How to begin? At each point we decide what item to insert next based on the comparison between the lists :

56 Exercise merge ordered lists Input: 2 ordered lists Output: merged ordered list If we reached the end of one of the lists, we we ll append the end of the list to the merged list Out of bound

57 Question 1 def merge(l_1, l_2): merged = [0] * (len(l_1) + len(l_2)) li_1,li_2,merged_i = 0,0,0 #the green arrows while li_1 < len(l_1) and li_2 < len(l_2): if l_1[li_1] <= l_2[li_2]: merged[merged_i] = l_1[li_1] li_1 += 1 merged_i += 1 else: merged[merged_i] = l_2[li_2] l_i2 += 1 merged_i += 1 57

58 Question 1 cont d #copy remaining merged[merged_i:] = l_1[li_1:] merged_i += len(l_1) li_1 merged[merged_i:] = l_2[li_2:] return merged 58

59 Python Code Hierarchy Statement function Module Package 59

60 60 Modules: Functions and Constants All standard modules and their contents (functions, constants) can be found at >>> import math # mathematical functions >>> dir(math) [' doc ', ' name ', ' package ', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc'] >>> math.pi # a constant >>> math.sqrt(16) # a function 4.0 >>> math.log(8, 2) 3.0

61 More Function Examples 61

62 Example: the beauty of functions When one team keeps writing informative functions, another team can use it even without knowing how they work The Robot example: Our robot can move forwards or backwards forward(robot, time) backward(robot, time) It can also wait wait (robot, time) 62

63 Example: the beauty of functions This modularity enables writing complex functions although we don t really know how the robot works. def yoyo(robot, time, yoyo_repeats): count_repeats = 0 while count_repeats < yoyo_repeats: forward(robot,time) wait(time) backward(robot,time) wait(robot,time) count_repeats = count_repeats

64 Question 1 Input: a list of grades Output: maximum grade, without using built-in max. def max_value_in_list(grades): '''Given a list of grades between 0 and 100, return the maximum grade''' max_grade = -1 for grade in grades: if max_grade < grade: max_grade = grade return max_grade 64 >>> x = [78, 88, 95, 92] >>> print max_value_in_list(x) 95

65 Question 2 Input: a list of grades, and a list of student names Output: a list of students with maximal grade def students_with_max_grade(grades,names): '''return a list of the students with the maximal grade''' max_grade = max_value_in_list(grades) max_grade_students = [] for i in range(len(names)): if max_grade == grades[i]: max_grade_students.append(names[i]) return max_grade_students >>> grades = [99, 80, 92, 99, 97] >>> names = ["Tom", "Ron", "Benny", "Adi", "Livnat"] >>> print students_with_max_grade(grades, names) ['Tom', 'Adi'] 65

66 Question 3 Input: a list of grades Goal: give non-failed grades a factor of y (>0) (No return!) def give_factor(grades,y): for i in range(len(grades)): if grades[i] >= 60: grades[i] += y if grades[i] > 100: grades[i] = 100 >>> print grades [99, 80, 92, 99, 97] >>> give_factor(grades, 5) >>> print grades [100, 85, 97, 100, 100] We can also use: min(grade[i]+y,100) 66