Lecture 20, Thu 06/02

'''
Reminders:
* h08 is due tomorrow 6/3 @ 11:59pm
* Lab09 due Sunday 6/5 @ 11:59pm
* Quiz5 on Gradescope tomorrow 6/3
* Final Exam (remote on Gradescope), Thursday 6/9 @ 8 - 10am
* Course Evals are open
'''

# CS 9 Review

''' Logistics
* The final exam will be on Gradescope Thursday 6/9 @ 8 - 10AM PST
* The final exam with be cummulative
* It will look similar to Quizzes / homeworks in terms of questions asked,
but will be longer in length
    * True / False
    * Short answers
        * Briefly describe / define / state / ...
    * Write code satisfying a certain specification
    * Write solutions (autograded)
* We will be monitoring Piazza during the final exam time.
    * For CLARIFYING questions, you may post a PRIVATE question to instructors
    * If there needs to be a change/modification in any question, then we will
    publicly post this on Piazza.
'''

''' Topics
* Python Basics
    * Types
        * int, float, boolean, strings, lists, sets, dictionaries,...
        * conversion functions (int(), float(), str(), ...)
        * Mutable vs. immutable
    * Relational / Logical operators (==, <, <=, >=, >, and, or, not, ...)
    * Python Lists
        * Supporting methods (count, pop, ...)
    * Understanding under-the-hood functionality of dictionaries vs. lists
    * List / String slicing [ : ]
    * Strings
        * Suporting methods (replace, split, find, ...)
    * Function definitions
    * Control structures
        * if, else, elif, for, while, ...
* Testing
    * Test Driven Development (tDD)
    * pytests
* Python Errors
    * Syntax vs. Runtime
* Exceptions
    * Exception types (NameError, TypeError, ZeroDivisionError, ...)
    * Exception handling
    * Try / except / raise
    * Flow of execution
    * Passing exceptions to the function caller
    * Catching multiple exceptions
    * Catching inherited type exceptions
* Object Oriented Programming
    * Defining Python classes and methods
    * Class constructors
        * Defining / initializing default parameters
    * Shallow vs Deep Equality
        * Overloading __eq__ method
    * Overlading operators
        * __str__, __add__, __le__, __ge__, __lt__, ...
    * Inheritance
        * Know the implementation and behavior of fields / methods and how to override
        inherted 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(es)' methods
* Algorithm Analysis and O-notation
    * Know how to derive the O-notation for various data structures and code segments
* Binary Search
    * Search for items in a SORTES list
    * Know implementatio 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 / lectues) as well as possible
    variations
        * Stacks, Queues, Deques, Linked Lists, and Ordered Linked Lists
* Sorting Algorithms
    * Know the implementation and O-notation analysis (best and worst case scenarios)
    of various sorting algorithms
    * Bubble Sort (optimized version), Selection Sort, Insertion Sort, Merge Sort,
    Quick Sort
* Trees
    * Terminology
    * Know min-heap / max-heap data structure implementation (and underlying list
    representation)
    * BinaryTrees
        * Know the nodes and references implementation
        * Tree traversals: pre / in / post order
    * Binary Search Tree (BST)
        * Know the BST property and how insertion order affects structure
        * Know various BST methods (put, get, delete)