CS 116 Fall 2016 Review Notes Created By: Rina Dong

Transcription

1 Design Recipe: ü Purpose Explicitly indicate what the function does, including how the parameters are used. (Function name, parameters name, how the parameters are used) Example: fn_name(p1, p2,, pn) consumes., and produces. ü Effect If function mutates the contents of a parameter, this must be included in the Purpose and Effect statement Possible effects of a function: 1. Printing to screen (have print statement in the function) 2. Reading from keyboard (ask for user input) 3. Mutation of parameter (e.g., mutate the list) ü Contract Types of consumed and produced values. Example: fn_name: type_of_p1 type_of_p2 type_of_pn > produced_type Data types Nat: 0 + all the positive integer (immutable) {ONLY USED in design recipe} Int: all the negative integer all the positive integer (immutable) Float: rational and irrational numbers (3 is Int or Nat, 3.0 is a Float) (immutable) Str: have single quotes ( ) or double quotes ( ) (immutable) Bool: Boolean return one of True or False (immutable) (listof ): a list of somethings (somethings can be Nat Int Float Str or (listof..)) None: the function returns nothing (BUT the function may mutate the parameters or do somethings else) (anyof ): data type can be one of ü Requires Function has any restrictions or requirements about parameters (consumed values only) Example: Requires: ü Examples Need to write at least 2 examples (one base case and one non-base case). Also, in python, examples are COMMENTS Example: fn_name(p1, p2,, pn) => expected_value

2 ü Function def : ü Tests import check Tests have to include ALL base cases and SOME non-base cases Mechanics of testing: check.expect( label the test, expr, value_expected) check.within( label the test, expr, value_expected, tolerance) {tolerance: close enough value} check.set_screen( description of expected screen output ) check.set_input([ a, list, of, string ]) {user input is always a string} Using different mechanics for different situations: 1. Return number Nat & Int: check.expect() Float: check.within() 2. Return string and list check.expect() 3. Having user input ONLY check.set_input() + check.expect() 4. Having print statement ONLY check.set_screen() + check.expect() 5. Mutation check.expect() + check.expect() OR check.within() {first need to check the output of function is None, and check the parameter is mutated. When one item in the list is a floating point number should use check.within}

3 The math Module: Basic Mathematical Operations ü Addition (+), Substraction (-), Multiplication (*) Int Int -> Int OR Nat Nat -> Nat Float (anyof Int Nat Float) -> Float ü Division (/) Always produce Float ü Integer division (//) Int Int -> Int Float (anyof Float Int Nat) -> Float (but with the decimal part being.0) ü Remainder (%) Int Int -> Nat ü Exponents (**) (anyof Int Nat Float) (anyof Int Nat Float) -> (anyof Int Nat Float) More math function import math ü math.sqrt(n) => n ü math.log(n, b) => log b (n) ü math.log(n) => ln(n) ü math.floor(n) => largest integral value <= n ü math.ceil(n) => smallest integral value >= n ü math.factorial(n) => n! = n x (n-1) x (n-2) x x 1

4 Boolean Expressions & Conditional Statements ü Bool expressions will return True or False e.g., ==, >, <, >=, <=,!=, and, or ü Conditional statement 1. Basic conditional statement If test: true_action 2. Another conditional statement If test: true_action else: false_action 3. Chained Conditional statement if test1: true_action_test1 elif test2: true_action2_test2 else: false_action 4. Nested conditional statement If test1: true_action_test1 if test2: true_action_test2 elif/else elif/else 5. Separated conditional statement if test1: true_action1 else: false_action1 if test2: true_action2 else: false_action2

5 The string Module & Print & User Input: ü string operations 1. s in t (s is a substring of t? => Bool) 2. len(s) => length of s 3. s[i:j] => substring from string s 4. +: combine two or more strings ü string methods s = this is a string 1. s.find("s ) => 3 {only for the first s } 2. s.find( s, 11, 15) => -1 { s is not in tring } 3. s.split() => ['this', 'is', 'a', 'string'] {return a list of string} 4. s.isupper() 5. s.islower() 6. s.isnumeric() ü Print statement 1. Has an effect 2. Produces None 3. print(x) => None {x can be any type of data} ü The format method print( CS116 ISAs are {0}, {1}, and {2}..format( Ian, Liyan, Rina )) 1. Uses the embedded {#} to show where a value should be inserted in the new string 2. The # indicates which of the format arguments (0 - n) should appear at the location of the string. ü User input user_input = input(prompt) OR user_input = input() 1. Prints the value of prompt (if have) before reading any characters 2. Value produced by input is always a Str 3. Must be described in the Purpose statement (describe what happens with the value entered by the user, use relevant parameter names in description) 4. Mentioned in the Effect statement ü Special Characters 1. \n print in a new line (newlines character), len( \n ) = 1

6 Lists: ü lists functions 1. len(l) => the length of L 2. L[i] => itme at position I, 0 <= i < len(l) 3. L[i:j] => [L[i], L[i+1],, L[j-1]] 4. L[i:j:k] => [L[i], L[i+k], L[i+2k],, L[i+m*k]], includes all the positions up to (but not including) j {empty case} 5. x in L => True if x in L, False otherwise 6. sum => produces the sum of all values in a list of numbers ü Mutation 1. L[i] = new_value => sign new_value to L[i] 2. L.append(add_value) => add_value appears at the end of L 3. L.extend((listof )) => add a list of value at the end of L 4. L.insert(p, value) => insert value in L[p], len(l) increases by 1 5. L.remove(value) =>remove the value (first time appears in L) 6. L.pop(p) => return the value in L[p], and remove the value in L[p] ü Abstract list functions 1. list(map(fn, lst/string)) => apply fn to each item in lst/string, and return a new list 2. list(filter(fn, lst/string)) => apply fn to each item in lst/string, and only keep the item that fn return True (a new list) 3. lambda x1, x2,, xn: body => body should be an expression

7 Recursions: ü Countup & Countdown template def countdown_fn(n): if n == 0: return base_answer else: answer = n countdown_fn(n-1) return answer { countup need to change the base case and n increase} ü Basic List template def basic_list_fn(lst): if lst == []: return base_answer else:..lst[0].. return basic_list_fn(lst[1:]) ü Accumulative Recursion def acc_helper(acc, remaining,...): # if at stopping case of remaining # return (answer using acc) # else: # return acc_helper(updated acc, # updated remaining....) def fn(...): # process result of calling # acc_helper(initial acc, # initial remaining,...) # Note: consider special cases, as needed ü Generative Recursion ü Functions: return none

8 Iteration ü while loop 1. while loop template ## initialize loop variables while (test): ## body, including statements to: ## - update variables used in test ## - update value being calculated ## additional processing 2. while loop basics - If the continuation test is True => Execute the loop body - If the continuation test is False => Do not execute the loop body - After completing the loop body => Evaluate the continuation test again - The body usually includes a mutation of variables used in the continuation test 3. Steps for writing a while loop You must determine: how to initialize variables outside the loop when the loop body should be executed, or, when it should stop what variables must be updated in the loop body so the loop will eventually stop what other actions are needed within the loop bod 4. Tests for while loop - the body executes zero times - the body executes exactly one time - the body executes a "typical" number of times - the body executes the maximum number of times ü for loop 1. for loop template for item in collection: loop_body 2. for loop basics Iterate over all members in a collection Called bounded iteration 3. range is an iterator. It can generate a collection, and the next value in the range is computed automatically with each pass through the for loop.

9 ü while and for loop > while loop - Loop counter should be initialized outside loop. - Includes continuation test before body. - Should update loop variables in body of loop. - Body contains steps to repeat > for loop - Loop counter initialized automatically - Continues while more elements in collection, or more values in iterator - Loop variable updated automatically do not update in loop - Body contains steps to repeat

10 Efficiency ü Time efficiency: how long it takes an algorithm to solve a problem. Depends on its implementation ü Running time is always stated as a function of n. We denote it by T(n) Let n refer to the size: Length of list Number of characters in a string Number of digits in a Nat Meaning should be specified if not clear ü Best case & Worst case - the minimum value of T(n) possible for a fixed value of n => best case - the largest value of T(n) possible for a fixed value of n => worst case ü Big O notation 1. The order of a running time: the order is the dominant term without its coefficient. This is called the asymptotic run time. 2. The orders arranged from smallest to largest: O(1) < O(log n) < O(n) < O(n log n) < O(n 2 ) < O(2 n ) 3. Big O arithmetic: - Add => the result is the largest of the two orders - Multiply => the result is the product of the two orders ü Basic Operations in Python Numerical operations: +,-,*,/,= are O(1) max(a,b), min(a,b) are O(1) String operations, where n = len(s) len(s), s[k] are O(1) s + t is O(n + len(t)) Most string methods (e.g. count, find, lower) are O(n) print and input are dependent on the length of what is being printed and read in when n = len(l) - len(l), L[k] are O(1) - L + M is O (n + len M) L + [x] is O(n) - sum(l), max(l), min(l) are O(n) - L[a:b] is O(b a), so at most O(n) L[1:]is O n - L.append(x) is O(1) - list(range(n)) is O(n)

11 - Most other list methods on L (e.g. count, index, insert, pop, remove) are O(n) - L.sort() is O(n log n) ü Common Summations O 1 = O(log n) O(1) = O(n) O(n) = O(n : ) O(i) = O(n : ) ü Recurrence Relations T(n) = O(1) + T(n-1) = O(n) T(n) = O(n) + T(n-1) =O(n 2 ) T(n) = O(1) + T(n/2) = O(log n) T(n) = O(1) +2 * T(n/2) = O(n) T(n) = O(n) + 2 * T(n/2) = O(n log n) OR T(n) = O(n) + T(n/2) = O(n log n) T(n) = O(1) + T(n-1) + T(n-2) = O(2 n ) OR T(n) = O(1) + 2 * T(n-1) = O(2 n ) ü Abstract list functions => map(f, L), filter(f, L) are at least O(n)

12 Searching and Sorting Algorithms ü Algorithm (called Linear Search) Implementing Linear Search ## linear_search(l, target) ## produces True if target is in L, ## False otherwise ## linear_search: (listof X) X -> Bool ## Note: equivalent to: target in L def linear_search (L, target): for val in L: if val == target: return True return False Best case => O(1) Worst case => O(n) ü Binary Search Implementing Binary Search def binary_search(l, target): beginning = end = while : middle = if L[middle] == target: return True elif L[middle] > target : else: return False Test cases: 1. empty list 2. list of length 1: target in list and not in list 3. small list, both even and odd lengths 4. larger list target outside list, i.e. target < L[0] or target > L[len(L)-1] target in the list, various positions (first, last, middle) target not in the list, value between two list consecutive values

13 Worst case => O(log n) ü Selection Sort Implementing Selection Sort def selection_sort(l): n = len(l) positions = list(range(n-1)) for i in positions: min_pos = i for j in range(i,n): if L[j] < L[min_pos]: min_pos = j temp = L[i] L[i] = L[min_pos] L[min_pos] = temp Runtime: O(n 2 ) ü Insertion Sort Implementing Insertion Sort # insert(l,pos) sorts L[0:pos] when L[0:pos-1] is already sorted. def insert(l, pos): while pos > 0 and L[pos] < L[pos-1]: temp = L[pos] L[pos] = L[pos-1] L[pos-1] = temp pos = pos-1 def insert_sort(l): for i in range(1,len(l)): insert(l,i) Runtime: O(n 2 ) ü Merge sort Implementing Merge sort: def merge(l1, L2, L): pos1 = 0 pos2 = 0 posl = 0 while (pos1 < len(l1)) and (pos2 < len(l2)): if L1[pos1] < L2[pos2]:

14 L[posL] = L1[pos1] pos1 += 1 else: L[posL] = L2[pos2] pos2 += 1 posl += 1 while (pos1 < len(l1)): L[posL] = L1[pos1] pos1 = pos1+1 posl = posl+1 while (pos2 < len(l2)): L[posL] = L2[pos2] pos2 = pos2+1 posl = posl+1 def mergesort(l): if len(l) < 2: return mid = len(l)//2 L1 = L[:mid] L2 = L[mid:] mergesort(l1) mergesort(l2) merge(l1, L2, L) Runtime: O(n log n) ü Quick Sort Implementing Quick Sort # quicksort(lst) sorts a list of integers, lst, using the # quicksort algorithm. # quicksort: (listof Int) -> (listof Int) def quicksort(lst): if lst == []: return [] n = lst[0] lst1 = list(filter(lambda x: x < n, lst)) lst2 = list(filter(lambda x: x > n, lst)) return quicksort(lst1) + [n] + quicksort(lst2) Runtime: O(n 2 )

15 ü Sorting Summary Algorithm best case worst case Insertion sort O(n) O(n : ) Selection sort O(n : ) O(n : ) Merge sort O(n log n) O(n log n) Quick sort O(n log n) O(n : )

16 Dictionaries (key-value collections) ü Use {} for dictionaries ü Data Type: (dictof Key_type Value_type) ü The type used for the key must be immutable (e.g. Str, Int) ü Any type can be used for the value ü Keys are not sorted or ordered ü Dictionary Operations: Retrieve a value by using its key as an index d[key] => value Update a value by using its key as an index && Add a value by using its key as an index d[key] = value len(d) => number of pairs in d d.keys() => a view of keys in d. list(d.keys) => list of keys d.values() => a view of values in d. list(d.values) => list of values k in d => True if k is a key in d d.pop(k) => value for k, and removes k:value from d

17 Classes ü including several very important methods in our classes to help with Creating objects Printing objects Comparing objects ü These methods will use the local name self to refer to the object being used ü init class name: def init (self, f1, f2, ): self.field1 = f1 self.field2 = f2 Creates the class Call the fields by: x = name(field1,field2, ) x.field1 ü repr def repr (self): return "name: {0},{1}, ".format(self.field1, self.field2, ) ü eq def eq (self, other): return isinstance(other, name) and \ self.field1 == other.field1 and \ self.field2 == other.field2 and \ If two classes have the same fields (and are not aliases), it is used to ensure that they produce True.

18 File Input and Output ü Step 1: Finding a file ü Step 2: Opening a file open(filename, "r") or open(filename) opens the file named filename for reading open(filename, "w") creates the file named filename for writing. If there is already a file named filename, its contents are erased before the new data is written. ü Step 3: Accessing files - reading f.readline() Returns the next line from file f Includes newline character Returns the empty string when at end of file f.readlines() Returns a list of strings containing each line from file f Each string terminates with newline character (if present in file) If file is very large, this may consume a lot of memory Template for reading from a file input_file = open(filename, "r") ## read file using ## input_file.readline() in a loop, or ## input_file.readlines() ## Note: resulting strings ## contain newline input_file.close() ü Step 3: Accessing files - reading f.write(s) Appends the string s to the end of file f Writes the newline character only if s includes it f.writelines(los) Appends all the strings in los to the end of file f Writes newline characters only for those strings in los which include it Template for writing to a file output_file = open(filename, "w") ## write to file using ## output_file.write(s) in a loop, or

19 ## output_file.writelines(los) ## Note: newlines are written only ## if strings include them output_file.close() ü Step 4: Closing a file f.close() Closes the file f If you forget to close a file after writing, you may lose some data You can no longer access a file after it has been closed ü The Design Recipe and Files: Purpose: Should include details about what is read from a file or written to a file Effects: Should mention reading from a file or writing to a file (don't need details here) Testing file input # process_file: Str -> (listof Int) def process_file(filename): f = open(filename, "r") Set up a test file of data, and include a comment describing contents of file. e.g., check.expect('q1t1', process_file("q1t1file.txt"), [2,4,6]) Testing file output 1. check.set_file_exact(actual, expected) actual name of file created by program expected name of file you created with the expected output 2. check.set_file(actual, expected) actual name of file created by program expected name of file you created with the expected output Differences: this version ignores whitespace in the two files 3. check.set_file() or check.set_file_exact() + check.expect() ü Sorting Characters ord(c) len(c) = 1 Produces the ASCII code for character c e.g. ord('a') => 97, ord('\n') => 10 chr(code) 0 <= code <= 255 Produces the string containing the character with the given code e.g. chr(100) => 'd', chr(32) => ' '

20 Graph Theory ü Undirected Graph An undirected graph G is a set V, of vertices, and a collection E, of unordered pairs from V, called edges. We write G=(V,E). The edges may (or may not) have weights associated with them. If (v k, v p ) is an edge, we say that vk and vp are neighbours, and are adjacent The number of neighbours of a vertex is also called its degree A sequence of nodes v 1, v 2,, v k is a path of length k-1 if (v 1, v 2 ),(v 2, v 3 ),,(v k-1, v k ) are all edges If v 1 = v k, this is called a cycle A graph G is connected if there exists a path through all vertices in G Results in graph: Let n = number of vertices, and m = number of edges: 1. m n(n 1)/2 2. The number of graphs on n vertices is 2 n(n-1)/2 3. The sum of the degrees over all vertices is 2m. Edge list: [e 1, e 2, e 3,, e m ], where edge e j = [a, b] when vertices a and b are connected by an edge Adjacency list: 1. For each vertex: Store the labels on its neighbours in a list 2. We will use a dictionary Keys: labels of vertices Associated values: List of neighbours (adjacent vertices) Adjacency Matrix: 1. For simplicity, assume vertices are labelled 0,, n 1 2. Create an n*n matrix for G If there is an edge connecting i and j: Set G[i][j] = 1 Set G[j][i] = 1 3. Otherwise, set these values to 0 ü Graph Traversals Breadth-first search(bfs) Definition: choose a starting point v => visit all the neighbours of v => visit all the neighbours of the neighbours of v, etc. => repeat until all reachable vertrices are visited => need some way to avoid visiting edges more than one

21 Implementation: def bfs(graph, v): all = [] Q = [] Q.append(v) while Q!= []: v = Q.pop(0) all.append(v) for n in graph[v]: if n not in Q and n not in all: Q.append(n) return all Depth-first search (dfs) Definition: choose a starting point v => proceed along a path from v as far as possible => backup to previous (most recently visited) vertex, and visit its unvisited neighbor (this is called backtracking) => repeat while unvisited, reachable vertices remain Implementation: def dfs(graph, v): visited = [] S = [v] while S!= []: v = S.pop() if v not in visited: visited.append(v) for w in graph[v]: if w not in visited: S.append(w) return visited