Lecture 17, Wed 09/13

'''
Final Exam Logistics
* Final Exam: in-person
    * Thursday 9/14 @ 9:30am - 10:50am
* Bring a writing utensil and studentID
* No books / notes / electronic devices
* Please write LEGIBLY (if we can't read it, we
won't grade it)
* Final Exam will be cummulative, but have a heavier
emphasis on post-midterm material
* Types of Questions
    * True / False, if False briefly state why
    * Short answers (briefly describe / state / define)
    * Given some specification, write code
    * Given some algorithm we covered, fill in the
    blank to make it work
    * Draw diagrams
    * ...
'''
''' Topics
* Python Basics
    * Types
        * int, float, boolean, strings, lists, sets,
        dictionaries, ...
        * conversion functions (int(), float(), str(), ...)
        * Mutable vs. Immutable
    * Relational / Logical operators (==, <, <=, >, >=, and, or, ...)
    * Python Lists
        * Supporting methods (count, pop, append, ...)
    * Under-the-hood functionality of dictionaries vs lists
    * List / String slicing [:]
    * Strings
        * Supporting methods (replace, split, find, ...)
    * Function definitions
    * Control Structures
        * if, else, elif, for, while
* Testing
    * Test Driven Development (TDD)
    * pytest
* Python Errors
    * Syntax vs. Runtime
* Exceptions
    * Exception types (NameError, TypeError, ZeroDivisionError, ...)
    * Exception handling
        * try / except / raise
        * flow of execution
        * passing exceptions to function caller
        * Catching multiple exceptions
        * Catching inherited type exceptions
* Object Oriented Programming
    * Defining classes and methods
    * class constructors
        * Defining / initializing default parameters
    * shallow vs. deep equality
        * overloading __eq__ method
    * overloading operators
        * __str__, __add__, __le__, __lt__, ...
    * inheritance
        * know the implementation and behavior of inherited fields /
        methods and how to override inherited methods
        * Know the pattern on how to construct inherited classes
        * Know the hierarchy of types (how this affects exception
        handling)
        * Know how to explicitly call super/base class methods
* Algorithm Analysis and O-notation
    * Know how to derive O-notation from a time function for various
    data structures and code segments
* Binary Search
    * Search for items in a SORTED list
    * Know implementation and O-notation
* Recursion
    * Understand how recursive algorithms are managed by the call
    stack
    * Able to derive O-notation for various recursive functions
* Linear Data Structures
    * Know implementations (as covered in textbook/lecture) and
    O-notation for various functionality of data structures
        * Stacks, Queue, Deque, Linked Lists, ordered Linked Lists
* Sorting Algorithms
    * Know the implementation and O-notation analysis (best and
    worst-case scenarios)
    * Bubble Sort, Selection Sort, Insertion Sort, Merge Sort,
    Quick Sort
* Trees
    * Terminology
    * Min/Max heap data structure implementation (and underlying
    list representation)
    * Binary Trees
        * Nodes and References implementation
        * Tree traversals: pre, in, post order traversals
    * Binary Search Trees
        * Know the BST property
        * How insertion order affects the structure
        * Know various BST methods (put, get)
        * Conceptually understand BST deletion operation
'''