THIS IS ENDMATTER

APPENDIX -- A Selective and Impressionistic Short Review of Python
-------------------------------------------------------------------

  A reader who is coming to Python for the first time would be well
  served reading Guido van Rossum's _Python Tutorial_, which can be
  downloaded from <http://python.org/>, or picking up one of the
  several excellent books devoted to teaching Python to novices. As
  indicated in the Preface, the audience of this book is a bit
  different.

  The above said, some readers of this book might use Python only
  infrequently, or not have used Python for a while, or may be
  sufficiently versed in numerous other programming languages, that
  a quick review on Python constructs suffices for understanding.
  This appendix will briefly mention each major element of the
  Python language itself, but will not address any libraries (even
  standard and ubiquitous ones that may be discussed in the main
  chapters). Not all fine points of syntax and semantics will be
  covered here, either. This review, however, should suffice for a
  reader to understand all the examples in this book.

  Even readers who are familiar with Python might enjoy skimming
  this review. The focus and spin of this summary are a bit
  different from most introductions. I believe that the way I
  categorize and explain a number of language features can
  provide a moderately novel--but equally accurate--perspective
  on the Python language. Ideally, a Python programmer will come
  away from this review with a few new insights on the familiar
  constructs she uses every day.  This appendix does not shy
  away from using some abstract terms from computer science--if
  a particular term is not familiar to you, you will not lose
  much by skipping over the sentence it occurs in; some of these
  terms are explained briefly in the Glossary.


SECTION -- What Kind of Language is Python?
--------------------------------------------------------------------

  Python is a byte-code compiled programming language that supports
  multiple programming paradigms. Python is sometimes called an
  interpreted and/or scripting language because no separate
  compilation step is required to run a Python program; in more
  precise terms, Python uses a virtual machine (much like Java or
  Smalltalk) to run machine-abstracted instructions. In most
  situations a byte-code compiled version of an application is
  cached to speed future runs, but wherever necessary compilation
  is performed "behind the scenes."

  In the broadest terms, Python is an imperative programming
  language, rather than a declarative (functional or logical) one.
  Python is dynamically and strongly typed, with very late binding
  compared to most languages. In addition, Python is an
  object-oriented language with strong introspective facilities,
  and one that generally relies on conventions rather than
  enforcement mechanisms to control access and visibility of names.
  Despite its object-oriented core, much of the syntax of Python is
  designed to allow a convenient procedural style that masks the
  underlying OOP mechanisms. Although Python allows basic
  functional programming (FP) techniques, side effects are the
  norm, evaluation is always strict, and no compiler optimization
  is performed for tail recursion (nor on almost any other
  construct).

  Python has a small set of reserved words, delimits blocks and
  structure based on indentation only, has a fairly rich collection
  of built-in data structures, and is generally both terse and
  readable compared to other programming languages. Much of the
  strength of Python lies in its standard library and in a flexible
  system of importable modules and packages.


SECTION -- Namespaces and Bindings
--------------------------------------------------------------------

  The central concept in Python programming is that of a namespace.
  Each context (i.e., scope) in a Python program has available to
  it a hierarchically organized collection of namespaces; each
  namespace contains a set of names, and each name is bound to an
  object. In older versions of Python, namespaces were arranged
  according to the "three-scope rule" (builtin/global/local), but
  Python version 2.1 and later add lexically nested scoping. In
  most cases you do not need to worry about this subtlety, and
  scoping works the way you would expect (the special cases that
  prompted the addition of lexical scoping are mostly ones with
  nested functions and/or classes).

  There are quite a few ways of binding a name to an object
  within the current namespace/scope and/or within some other
  scope.  These various ways are listed below.

  TOPIC -- Assignment and Dereferencing
  --------------------------------------------------------------------

  A Python statement like 'x=37' or 'y="foo"' does a few things. If
  an object--e.g., '37' or '"foo"'--does not exist, Python creates
  one. If such an object -does- exist, Python locates it. Next, the
  name 'x' or 'y' is added to the current namespace, if it does not
  exist already, and that name is bound to the corresponding
  object. If a name already exists in the current namespace, it is
  re-bound. Multiple names, perhaps in multiple scopes/namespaces,
  can be bound to the same object.

  A simple assignment statement binds a name into the current
  namespace, unless that name has been declared as global.  A
  name declared as global is bound to the global (module-level)
  namespace instead.  A qualified name used on the left of an
  assignment statement binds a name into a specified
  namespace--either to the attributes of an object, or to the
  namespace of a module/package, for example:

      >>> x = "foo"              # bind 'x' in global namespace
      >>> def myfunc():          # bind 'myfunc' in global namespace
      ...     global x, y        # specify namespace for 'x', 'y'
      ...     x = 1              # rebind global 'x' to 1 object
      ...     y = 2              # create global name 'y' and 2 object
      ...     z = 3              # create local name 'z' and 3 object
      ...
      >>> import package.module  # bind name 'package.module'
      >>> package.module.w = 4   # bind 'w' in namespace package.module
      >>> from mymod import obj  # bind object 'obj' to global namespace
      >>> obj.attr = 5           # bind name 'attr' to object 'obj'

  Whenever a (possibly qualified) name occurs on the right side of
  an assignment, or on a line by itself, the name is dereferenced to
  the object itself. If a name has not been bound inside some
  accessible scope, it cannot be dereferenced; attempting to do so
  raises a 'NameError' exception. If the name is followed by left
  and right parentheses (possibly with comma-separated expressions
  between them), the object is invoked/called after it is
  dereferenced. Exactly what happens upon invocation can be
  controlled and overridden for Python objects; but in general,
  invoking a function or method runs some code, and invoking a
  class creates an instance. For example:

      >>> pkg.subpkg.func()   # invoke a function from a namespace
      >>> x = y               # deref 'y' and bind same object to 'x'

  TOPIC -- Function and Class Definitions
  --------------------------------------------------------------------

  Declaring a function or a class is simply the preferred way of
  describing an object and binding it to a name. But the 'def' and
  'class' declarations are "deep down" just types of assignments.
  In the case of functions, the `lambda` operator can also be used
  on the right of an assignment to bind an "anonymous" function to
  a name. There is no equally direct technique for classes, but
  their declaration is still similar in effect:

      >>> add1 = lambda x,y: x+y # bind 'add1' to function in global ns
      >>> def add2(x, y):        # bind 'add2' to function in global ns
      ...     return x+y
      ...
      >>> class Klass:           # bind 'Klass' to class object
      ...    def meth1(self):    # bind 'meth1' to method in 'Klass' ns
      ...        return 'Myself'

  TOPIC -- 'import' Statements
  --------------------------------------------------------------------

  Importing, or importing -from-, a module or a package adds or
  modifies bindings in the current namespace. The 'import'
  statement has two forms, each with a bit different effect.

  Statements of the forms:

      >>> import modname
      >>> import pkg.subpkg.modname
      >>> import pkg.modname as othername

  add a new module object to the current namespace.  These
  module objects themselves define namespaces that you can
  bind values in or utilize objects within.

  Statements of the forms:

      >>> from modname import foo
      >>> from pkg.subpkg.modname import foo as bar

  ...instead add the names 'foo' or 'bar' to the current namespace.
  In any of these forms of 'import', any statements in the imported
  module are executed--the difference between the forms is simply
  the effect upon namespaces.

  There is one more special form of the 'import' statement; for
  example:

      >>> from modname import *

  The asterisk in this form is not a generalized glob or regular
  expression pattern, it is a special syntactic form. "Import star"
  imports every name in a module namespace into the current
  namespace (except those named with a leading underscore, which
  can still be explicitly imported if needed). Use of this form is
  somewhat discouraged because it risks adding names to the current
  namespace that you do not explicitly request and that may rebind
  existing names.

  TOPIC -- 'for' Statements
  --------------------------------------------------------------------

  Although 'for' is a looping construct, the way it works is by
  binding successive elements of an iterable object to a name (in
  the current namespace). The following constructs are (almost)
  equivalent:

      >>> for x in somelist:  # repeated binding with 'for'
      ...     print x
      ...
      >>> ndx = 0             # rebinds 'ndx' if it was defined
      >>> while 1:            # repeated binding in 'while'
      ...    x = somelist[ndx]
      ...    print x
      ...    ndx = ndx+1
      ...    if ndx >= len(somelist):
      ...        del ndx
      ...        break

  TOPIC -- 'except' Statements
  --------------------------------------------------------------------

  The 'except' statement can optionally bind a name to an exception
  argument:

      >>> try:
      ...     raise "ThisError", "some message"
      ... except "ThisError", x:    # Bind 'x' to exception argument
      ...     print x
      ...
      some message


SECTION -- Datatypes
--------------------------------------------------------------------

  Python has a rich collection of basic datatypes. All of Python's
  collection types allow you to hold heterogeneous elements inside
  them, including other collection types (with minor limitations).
  It is straightforward, therefore, to build complex data
  structures in Python.

  Unlike many languages, Python datatypes come in two varieties:
  mutable and immutable. All of the atomic datatypes are immutable,
  as is the collection type 'tuple'. The collections 'list' and
  'dict' are mutable, as are class instances. The mutability of a
  datatype is simply a question of whether objects of that type can
  be changed "in place"--an immutable object can only be created
  and destroyed, but never altered during its existence. One upshot
  of this distinction is that immutable objects may act as
  dictionary keys, but mutable objects may not. Another upshot is
  that when you want a data structure--especially a large one--that
  will be modified frequently during program operation, you should
  choose a mutable datatype (usually a list).

  Most of the time, if you want to convert values between different
  Python datatypes, an explicit conversion/encoding call is
  required, but numeric types contain promotion rules to allow
  numeric expressions over a mixture of types. The built-in
  datatypes are listed below with discussions of each. The built-in
  function `type()` can be used to check the datatype of an object.

  TOPIC -- Simple Types
  --------------------------------------------------------------------

  bool
      Python 2.3+ supports a Boolean datatype with the possible
      values 'True' and 'False'.  In earlier versions of Python,
      these values are typically called '1' and '0'; even in
      Python 2.3+, the Boolean values behave like numbers in
      numeric contexts.  Some earlier micro-releases of Python
      (e.g.,  2.2.1) include the -names- 'True' and 'False', but
      not the Boolean datatype.

  int
      A signed integer in the range indicated by the register
      size of the interpreter's CPU/OS platform.  For most current
      platforms, integers range from (2**31)-1 to negative
      (2**31)-1. You can find the size on your platform by
      examining `sys.maxint`. Integers are the bottom numeric
      type in terms of promotions; nothing gets promoted -to- an
      integer, but integers are sometimes promoted to other
      numeric types.  A float, long, or string may be explicitly
      converted to an int using the `int()` function.

      SEE ALSO, [int]

  long
      An (almost) unlimited size integral number.  A long literal
      is indicated by an integer followed by an 'l' or 'L' (e.g.,
      '34L', '9876543210l').  In Python 2.2+, operations on ints
      that overflow `sys.maxint` are automatically promoted to
      longs.  An int, float, or string may be explicitly
      converted to a long using the `long()` function.

  float
      An IEEE754 floating point number.  A literal floating point
      number is distinguished from an int or long by containing a
      decimal point and/or exponent notation (e.g., '1.0', '1e3',
      '.453e-12', '37.').  A numeric expression that involves both
      int/long types and float types promotes all component types
      to floats before performing the computation.  An int, long,