send to Mitya

[Lance]

9.2 Python Scopes and Name Spaces
Before introducing classes, I first have to tell you something about
Python's scope rules. Class definitions play some neat tricks with
namespaces, and you need to know how scopes and namespaces work to fully
understand what's going on. Incidentally, knowledge about this subject is
useful for any advanced Python programmer.

Let's begin with some definitions.

A namespace is a mapping from names to objects. Most namespaces are
currently implemented as Python dictionaries, but that's normally not
noticeable in any way (except for performance), and it may change in the
future. Examples of namespaces are: the set of built-in names (functions
such as abs(), and built-in exception names); the global names in a module;
and the local names in a function invocation. In a sense the set of
attributes of an object also form a namespace. The important thing to know
about namespaces is that there is absolutely no relation between names in
different namespaces; for instance, two different modules may both define a
function ``maximize'' without confusion -- users of the modules must prefix
it with the module name.

By the way, I use the word attribute for any name following a dot -- for
example, in the expression z.real, real is an attribute of the object z.
Strictly speaking, references to names in modules are attribute references:
in the expression modname.funcname, modname is a module object and funcname
is an attribute of it. In this case there happens to be a straightforward
mapping between the module's attributes and the global names defined in the
module: they share the same namespace! 9.1

Attributes may be read-only or writable. In the latter case, assignment to
attributes is possible. Module attributes are writable: you can write
"modname.the_answer = 42". Writable attributes may also be deleted with the
del statement. For example, "del modname.the_answer" will remove the
attribute the_answer from the object named by modname.

Name spaces are created at different moments and have different lifetimes.
The namespace containing the built-in names is created when the Python
interpreter starts up, and is never deleted. The global namespace for a
module is created when the module definition is read in; normally, module
namespaces also last until the interpreter quits. The statements executed by
the top-level invocation of the interpreter, either read from a script file
or interactively, are considered part of a module called __main__, so they
have their own global namespace. (The built-in names actually also live in a
module; this is called __builtin__.)

The local namespace for a function is created when the function is called,
and deleted when the function returns or raises an exception that is not
handled within the function. (Actually, forgetting would be a better way to
describe what actually happens.) Of course, recursive invocations each have
their own local namespace.

A scope is a textual region of a Python program where a namespace is
directly accessible. ``Directly accessible'' here means that an unqualified
reference to a name attempts to find the name in the namespace.

Although scopes are determined statically, they are used dynamically. At any
time during execution, exactly three nested scopes are in use (exactly three
namespaces are directly accessible): the innermost scope, which is searched
first, contains the local names, the middle scope, searched next, contains
the current module's global names, and the outermost scope (searched last)
is the namespace containing built-in names.

Usually, the local scope references the local names of the (textually)
current function. Outside of functions, the local scope references the same
namespace as the global scope: the module's namespace. Class definitions
place yet another namespace in the local scope.

It is important to realize that scopes are determined textually: the global
scope of a function defined in a module is that module's namespace, no
matter from where or by what alias the function is called. On the other
hand, the actual search for names is done dynamically, at run time --
however, the language definition is evolving towards static name resolution,
at ``compile'' time, so don't rely on dynamic name resolution! (In fact,
local variables are already determined statically.)

A special quirk of Python is that assignments always go into the innermost
scope. Assignments do not copy data -- they just bind names to objects. The
same is true for deletions: the statement "del x" removes the binding of x
from the namespace referenced by the local scope. In fact, all operations
that introduce new names use the local scope: in particular, import
statements and function definitions bind the module or function name in the
local scope. (The global statement can be used to indicate that particular
variables live in the global scope.)



9.3 A First Look at Classes
Classes introduce a little bit of new syntax, three new object types, and
some new semantics.



9.3.1 Class Definition Syntax
The simplest form of class definition looks like this:


class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>
Class definitions, like function definitions (def statements) must be
executed before they have any effect. (You could conceivably place a class
definition in a branch of an if statement, or inside a function.)

In practice, the statements inside a class definition will usually be
function definitions, but other statements are allowed, and sometimes
useful -- we'll come back to this later. The function definitions inside a
class normally have a peculiar form of argument list, dictated by the
calling conventions for methods -- again, this is explained later.

When a class definition is entered, a new namespace is created, and used as
the local scope -- thus, all assignments to local variables go into this new
namespace. In particular, function definitions bind the name of the new
function here.

When a class definition is left normally (via the end), a class object is
created. This is basically a wrapper around the contents of the namespace
created by the class definition; we'll learn more about class objects in the
next section. The original local scope (the one in effect just before the
class definitions was entered) is reinstated, and the class object is bound
here to the class name given in the class definition header (ClassName in
the example).