The final exam is worth 300 points (about double the midterm). I have not
written this exam yet, but I expect it to be like the midterm: about 10
questions (some might have multiple parts), each covering about 1 week of
material for the 10 week quarter. So, it is cumulative. Over this 120 minute
test, that is about 12 minutes per question (to read and answer it).

We have covered way too much material for you to re-read everything. I suggest
primarily reviewing the quizzes and midterm, and then the programming
assignments: not reading them in depth, but being familiar with them and their
major themes. Of course you will be analyzing and writing code on the final
exam, but I expect there also to be a small number of questions to be answered
in English or with pictures.

Here is my view of the material that we covered.

------------------------------------------------------------------------------

Review/Extension
  data types: list (sorting), tuple/named-tuple, set/frozenset, dict/defaultdict
  iterators
  comprehensions
  function calls (argument/parameter binding)
  lambdas
  exception/handling
  classes (dict for object name spaces)

Text Patterns
  EBNF
  regular expressions

Classes
  the fundamental equation of object oriented programming
  operator overloading via method definition
    misc: __init__, __len__, __bool__, __str__/__repr__
    relational
    arithmetic
    container: __getitem__, __setitem__, __delitem__, __contains__
    function call: __call__
    iterators: __iter__, __next__
    attribute: __getattr__, __setattr__, __delattr__, __getattribute__
    context managers: __enter__, __exit__
  decorators

Iterators
  general review of use/illustrations of how to write some builtin (range)
  implementation with nested classes
  implementation with generators

Functional programming
  recursive programming
  map/filter/reduce (+ lambdas)

Inheritance
  type vs isinstance
  inheriting/using/overriding: state, __init__, other methods
  locating attribute names in inheritance hierarchy
    (updating the fundamental equation of object-oriented programmming)
  for handling exceptions in hierarachy

Self-referential data types
  linked lists: pictures and hand-simulation
  binary trees/structure trees
  iterative and recursive functions

Analysis of Algorithms
  analysis of code
  complexity classes and their meaning
  empirical analysis
  using logarithms base 2

Testing Tools
  profiler
  unittest

A bit about Java (no homeworks on these
  so if I asked one question it would
  be conceptual)