Lecture 19, Thu 12/02

''' Final Exam Logistics
* The final exam will be in-person (LSB 1001), Wed 12/8 @ 7:30 - 9:30pm PST
* Bring a writing utensil and photo ID
	* Please write LEGIBLY (if we can't read it, we can't grade it)
	* Preferrably ink / dark led
	* When leaving the room, you musts present your ID and hand in
	your exam before leaving (it's your ticket out!)
	* Closed book: (No notes / book / electronic devices)
* The final will be cumulative
* Questions
	* True / False (if false, explain why)
	* Short answer
		* Briefly explain / describe / define / state / ...
	* Given some code, write the output
	* Write code satisfying a certain specification (similar to quizzes)
	* Given some algorithm we covered, fill in the blank to make it work
	* Draw diagrams
* I plan to design the exam such that 2 hours should be enough time
asuming students prepare and study the material.
* TAs and I will be proctoring the exam and can help answer any CLARIFYING
questions
'''
''' Topics
* Python Basics
	* Types
		* int, float, boolean, strings, listtts, sets, dictionaries, ...
		* conversion functions (int(), float(), str(), ...)
		* Mutable vs immutable
	* Relational / logical operators (==, <, <=, >=, >, and, or, ...)
	* Python lists
		* Supporting methods (count, pop, ...)
	* Understanding under-the-hood workings of dictionaries vs lists
	* List / string slicing [:]
	* Strings
		* Supporting methods (replace, split, find, ...)
	* Function definitions
	* Control structures
		* if, else, elif, for, while, ...
* Testing
	* TDD
	* pytests
* Python Errors
	* Syntax vs Runtime
* Exception
	* 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 classes and methods
	* class constructors
		* Defining / initializing default parameters
	* Shallow vs. Deep Equality
		* Overlaoding the __eq__ method
	* overloading operators
		* __str__, __add__, __le__, __lt__, __ge__, __gt__, ...
	* Inheritance
		* Know the implementation and inheritance of fields / methods
		and how to override inherited methods
		* Know the pattern on how to construct inherited classes
		* Know the hierarchy of types (how this is related to 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 aa 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 the implementation (as covered in the textbook / lecture) and
	O-notation for various functionality of data structures
		* 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,
		MergeSort, QuickSort
* Trees
	* Terminology
	* Know min-heap / max-heap data structure implementation (and the
	underlying list)
	* Binary Trees
		* Nodes / references implementation
		* Tree traversals: pre, in, post order
	* Binary Search Tree
		* Known as BST. Know BST property and how insertion order
		affects structure.
		* Know various BST methods (put, get, deletion)
'''