Emil Sekerinski, McMaster University, Winter Term 16/17 COMP SCI 1MD3 Introduction to Programming

Transcription

1 Emil Sekerinski, McMaster University, Winter Term 16/17 COMP SCI 1MD3 Introduction to Programming

2 In Python, variables are names of objects base 5 >>> base = 5 >>> height = 4 >>> area = base*height/2 >>> base = 7 height area 10 4 Variables can contain uppercase and lowercase letter, digits, and _ Variables must not start with a digit and must not be one of the reserved words (keywords) like def, if, while, return, base height area

3 Python uses indentation for bracketing of nested statements S T S T if B: S B + S while B: S B + S if B: S else: T + B S T

4 n! = 1 if n = 0 0! = 1, 1! = 1, 2! = 2, n * (n 1)! if n > 0 3! = 6, 4! = 24, 5! = 120 A: B: Variables used within a function are local to the function def factorial(n): i, f = 0, 1 while i < n: i, f = i+1, f*(i+1) return f >>> factorial(5) >>> f # error Trace for input n = 5: Statement i f A 0 1 B 1 1 B 2 2 B 3 6 B 4 24 B 5 120

5 All the expressions on the right are evaluated before the values are simultaneously assigned to the variables on the left >>> x, y = y, x # swaps x, y! Different from a sequence of single assignments >>> x = y # x, y now name the same object! >>> y = x Factorial without multiple assignments: def factorial2(n): i = 0; f = 1 while i < n: i = i+1 f = f*i return f A sequence of statements may also be placed on a single line when separated by ;

6 The decision to start multiplying with 1, 2, 3,... is arbitrary; we can start equally well with n, n-1, A: B: def factorial3(n): f = 1 while n > 1: f, n = f*n, n-1 return f >>> x = 5 >>> factorial3(x) >>> x Statement n f A 5 1 B 4 5 B 3 20 B 2 60 B The actual parameter x is assigned to the formal parameter n.

7 All iterative implementations of factorial use an auxiliary counter variable and an accumulator variable, which becomes the result Counting can go up, from the lower to the upper bound, or down, from the upper to the lower bound The accumulator has to be initialized to a value that is the correct result if the loop is not executed at all a most common error!

8 A: B: C: Using indentation for nesting ensures that the visual appearance corresponds to the structure of the program. Short statements don t need to go on a separate line def gcd(x, y): u, v = x, y while u!= v: if u > v: u = u-v else: v = v-u return u u, v := x, y u v + + u > v u := u - v v := v - u Statement u v A 21 6 B 15 6 B 9 6 B 3 6 C 3 3

9 As a%b = (a+b)%b = (a-b)%b for any b 0, successive subtractions can be replaced by a single modulo operation A: B: def gcd2(x, y): u, v = x, y while v!= 0: u, v = v, u%v return u Statement u v A 21 6 B 6 3 B 3 0

10 A: B: def gcd2(x, y): u, v = x, y while v!= 0: u, v = v, u%v return u Statement u v A 6 21??? Statement u v A 6 21 B 21 6 B 6 3 B 3 0

11 Operator symbols, like +, *, are overloaded: they used for different, unrelated purposes, depending on the types of the operands. Python resolves the meaning dynamically (at runtime) def double(x): return 2*x >>> double(7) >>> double('?') Note: some languages resolve overloading statically (at compile-time)

12 Integer 17 is different from the string '17'. Objects can be explicitly converted from one type to another >>> int('17'), int(3.14) >>> int('nope'), int('3.14'), int((3, 4)) >>> float(17), float('3.14') >>> float('nope'), float((3, 4)) >>> str(17), str(3.14), str('yep'), str((3, 4)) >>> tuple('yep') >>> tuple(17), tuple(3, 4) Python also implicitly converts int to float >>> 2*3.14 danger >>> int( *2.0) loss of precision! >>> *2

13 The return statement specifies the result of a function and jumps to the end of the enclosing function f(): return def evenorodd(x): if x%2 == 0: return str(x) + " is even" else: return str(x) + " is odd"

14 * * * *10 0 1*2 3 +1*2 2 +0*2 1 +1*2 0 = ((2*10+0)*10+5)*10+3 = ((1*2+1)*2+0)*2+1 = 2053 = 13 Starting with the leftmost digit, the accumulator is multiplied by the base and the next digit is added (Horner's Rule) def binarytoint(b: "string of 0's and 1's"): n, i = 0, 0 while i < len(b): n, i = 2*n+int(b[i]), i+1 return n

15 For converting a number into a series a digits, the remainder of the division with the base gives the least digit; this is repeated with the quotient, until the number fits into a single digit 2053%10 = 3 13%2 = 1 205%10 = 5 6%2 = 0 20%10 = 0 3%2 = 1 2 %10 = 2 1%2 = 1 The resulting string can be constructed by concatenating to the left def inttobinary(n)-> "string of 0's and 1's": s = str(n%2) while n > 1: n = n//2 ; s = str(n%2)+s return s

16 The task is to check if property P(i) holds for some i where a <= i < b: i = a while i < b and not P(i): i = i+1 Testing if a character is present in a string involves linear search: i := a i < b and not P(i) + i := i + 1 (i < b P(i)) (i = b "not found") def hasundefinedbase2(s): i = 0 while i < len(s) and s[i]!= 'n': i = i+1 return i < len(s)

17 The task is again to check if property P(i) holds for some i where a <= i < b: i = a while i < b: if P(i): return "found at i" i = i+1 return "not found" This scheme involves returning from inside a repetition: def hasundefinedbase3(s): i = 0 while i < len(s): if s[i]=='n': return True i = i+1 return False i := a i < b + P(i) i := i + 1 return not found + return found

18 def hasundefinedbase(s): i = 0 while s[i]!= 'n' and i < len(s): i = i+1 return i < len(s) >>> hasundefinedbase('an') >>> hasundefinedbase('aaa') No, and and or are evaluated conditionally! Recall B and C = C if B else False B or C = True if B else C They are equivalent to and only if the operands are defined. Thus and are commutative, and and or are not.

19 For-loops iterate over all elements of a tuple, string, Unlike in while loops, in for loops the number of iterations is always bound. def n_count(seq): x = 0 for c in seq: if c == 'n': x = x+1 return x def binarytoint2(b): n = 0 for c in b: n = 2*n+int(c) return n In general: i = 0 for x in s: = while i < len(s): S x = s[i] S i = i+1 body S should not modify s loop variable x is undefined after the loop

20 range(a, b) can be used for iterating from integer a to b-1 if a is left out, it is taken to be 0 def factorial4(n): f = 1 for i in range(n): f = f*(i+1) return f i takes the values 0 to n-1 Note: range returns an "iterable" object. Its "values" can be inspected by converting to a list >>> list(range(3, 7))

21 The for statement can be used with the second pattern for i in range(a, b) if P(i): return "found at i" return "not found" A palindrome is a sequence that reads the same backward and forward. We take P(i) = s[i]!=s[-i-1] def ispalindrome(s): for i in range(len(s)//2): if s[i]!= s[-i-1]: return False return True >>> ispalindrome('pool') >>> ispalindrome('racecar')

22 def ispalindrome(s): for i in range(len(s)//2): if s[i]!= s[-i-1]: return False return True >>> ispalindrome('pool') >>> ispalindrome('racecar')

23 incorrect initialization, particularly that of accumulators incorrect termination condition of the loop, e.g. < vs. <= infinite loops by incorrectly updating the loop variable index calculation is "one off" improper bracketing/indentation of nested structures

24 missing x = 0 <= should be < def bad_n_count(seq): "number of 'n' in seq" i = 0 while i <= len(seq): if seq[i] == 'n': x = x+1 i = i+1 return x too much indentation

25 should be len(seq)-1 1 > should be >= 2 def bad_last_n_index(seq): "last index of 'n' in seq" i = len(seq) while i > 0: if seq[i] == 'n': return i i = i-1 missing return : alternatively i = i-1 before if

26 for loops automatically initialize and increment the loop variable, thus avoid certain class of errors for loops may necessitate jumps out of the loop by return or break, thus having multiple exits; while loops allow a single exit and make the termination condition explicit... while i<b and s[i]!='n':... i = i+1... # i>=b or s[i]=='n' for i in range(len(s)):... if s[i]!='n': break... #?... for this reason, we avoid break and prefer a single return at the end of a function

27 A function is recursive if it is defined in terms of itself. For it to be well-defined, there has to be a base case. For factorial: 1 if n = 0 n! = or n * (n 1)! if n > 0 def factorial(n): return 1 if n == 0 else n*factorial(n-1) >>> factorial(3) (1) (8) 6 return 1 if 3 == 0 else 3*factorial(2) (2) (7) 2 0! = 1 n! = n * (n 1)! if n > 0 return 1 if 2 == 0 else 2*factorial(1) (3) (6) 1 return 1 if 1 == 0 else 1*factorial(0) (4) (5) 1 return 1 if 0 == 0 else... leads to 3 recursive calls

28 "A certain man put a pair of rabbits in a place surrounded on all sides by a wall. How many pairs of rabbits can be produced from that pair in a year if it is supposed that every month each pair begets a new pair which from the second month on becomes productive?" month number of pairs Leonardo of Pisa, later known as Fibonacci, introduced in Liber Abaci, 1202, Hindu-Arabic numerals to Western culture. The excerpt above shows the growing Fibonacci sequence. producing

29 Besides being of mathematical interest, Fibonacci numbers have applications in biology, computing, art, design, In a colony of honeybees there are male bees, the drone bees, female bees, who do not produce eggs, and one female bee, the queen, who produces eggs. Males are produced by the queen's unfertilized eggs, so males only have a mother but no father. Females are produced when the queen mates with a male, so have two parents. Some females are fed with "royal jelly" which makes them grow into queens, ready to start a new colony when the bees form a swarm and leave their hive. How many ancestors do male bees have? parents 1 grandparents 2 great-grandparents 3 great-greatgrandparents great-great-greatgrandparents 5 8

30 Fibonacci numbers are recursively defined: fib(n) = 0 if n = 0 1 if n = 1 fib(n 1) + fib(n 2) if n > 1 def fib(n): return 0 if n == 0 else \ 1 if n == 1 else fib(n-1)+fib(n 2) fib(3) fib(3) leads to 4 recursive calls fib(1) fib(2) fib(0) fib(1) Recursion leads to "tree"-like calling structures P Q: P calls Q

31 Bad documentation repeats what the program does x = 0 # initialize x n = n+1 # increment n by 1 Good documentation consists of declarative descriptions (vs the imperative description of the program): explains the program in terms of the problem domain, summarizes what is happening next, justifies the design, e.g. choice of algorithm or data structure (e.g. linear search vs binary search), asserts conditions that must hold at certain places.

32 Python supports one-line comments, parameter comments, and multi-line documentation strings: def change(a, d): """ Computes the least number of coins or bills needed for amount a, a non-negative integer; available denominations have to be in d in ascending order. """ # r: remaining amount, initialized to a # c: array of same length as d with amount of each # denomination, initialized to all zeros i, r, c = len(d)-1, a, len(d)*[0] while i >= 0: c[i], r = divmod(r, d[i]) i = i-1 return c

33 Without documentation in natural language programs are difficult to understand and maintain even by the author! Self-explaining programs and programming languages don t work, cf COBOL! IDENTIFICATION DIVISION. PROGRAM-ID. Iteration-If. AUTHOR. Michael Coughlan. DATA DIVISION. WORKING-STORAGE SECTION. 01 Num1 PIC 9 VALUE ZEROS. 01 Num2 PIC 9 VALUE ZEROS. 01 Result PIC 99 VALUE ZEROS. 01 Operator PIC X VALUE SPACE. PROCEDURE DIVISION. Calculator. PERFORM 3 TIMES DISPLAY "Enter First Number : " WITH NO ADVANCING ACCEPT Num1 DISPLAY "Enter Second Number : " WITH NO ADVANCING ACCEPT Num2 DISPLAY "Enter operator (+ or *) : " WITH NO ADVANCING ACCEPT Operator IF Operator = "+" THEN ADD Num1, Num2 GIVING Result END-IF IF Operator = "*" THEN MULTIPLY Num1 BY Num2 GIVING Result END-IF DISPLAY "Result is = ", Result END-PERFORM. STOP RUN.

34 Donald Knuth, 1984, see also literateprogramming.com: Instead of imagining that our main task is to instruct a computer what to do, let us concentrate rather on explaining to human beings what we want a computer to do. "among the 100 books that shaped the 20 th century" American Scientist Knuth created WEB for supporting literate programming for programming languages at that time. Modern languages have documentation features inspired by WEB

35 jupyter notebooks intertwine Python code with output of that code and explanations in one document: This allows explanations of code to be kept in proximity to the code, supporting understandability and maintenance.