Classes provide a means of bundling data and functionality together. Creating a new class creates a new type of object, allowing new instances of that type to be made. Each class instance can have attributes attached to it for maintaining its state. Class instances can also have methods [defined by its class] for modifying its state.
Compared with other programming languages, Python’s class mechanism adds classes with a minimum of new syntax and semantics. It is a mixture of the class mechanisms found in C++ and Modula-3. Python classes provide all the standard features of Object Oriented Programming: the class inheritance mechanism allows multiple base classes, a derived class can override any methods of its base class or classes, and a method can call the method of a base class with the same name. Objects can contain arbitrary amounts and kinds of data. As is true for modules, classes partake of the dynamic nature of Python: they are created at runtime, and can be modified further after creation.
In C++ terminology, normally class members [including the data members] are public [except see below Private Variables], and all member functions are virtual. As in Modula-3, there are no shorthands for referencing the object’s members from its methods: the method function is declared with an explicit first argument representing the object, which is provided implicitly by the call. As in Smalltalk, classes themselves are objects. This provides semantics for importing and renaming. Unlike C++ and Modula-3, built-in types can be used as base classes for extension by the user. Also, like in C++, most built-in operators with special syntax [arithmetic operators, subscripting etc.] can be redefined for class instances.
[Lacking universally accepted terminology to talk about classes, I will make occasional use of Smalltalk and C++ terms. I would use Modula-3 terms, since its object-oriented semantics are closer to those of Python than C++, but I expect that few readers have heard of it.]
9.1. A Word About Names and Objects¶
Objects have individuality, and multiple names [in multiple scopes] can be bound to the same object. This is known as aliasing in other languages. This is usually not appreciated on a first glance at Python, and can be safely ignored when dealing with immutable basic types [numbers, strings, tuples]. However, aliasing has a possibly surprising effect on the semantics of Python code involving mutable objects such as lists, dictionaries, and most other types. This is usually used to the benefit of the program, since aliases behave like pointers in some respects. For example, passing an object is cheap since only a pointer is passed by the implementation; and if a function modifies an object passed as an argument, the caller will see the change — this eliminates the need for two different argument passing mechanisms as in Pascal.
9.2. Python Scopes and Namespaces¶
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 [containing functions such as
class ClassName: . . .9, 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
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'0 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
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'1,
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'2 is an attribute of the object
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'3. Strictly speaking, references to names in modules are attribute references: in the expression
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'4,
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'5 is a module object and
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'6 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! 1
Attributes may be read-only or writable. In the latter case, assignment to attributes is possible. Module attributes are writable: you can write
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'7. Writable attributes may also be deleted with the
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'8 statement. For example,
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'9 will remove the attribute
x = MyClass[]0 from the object named by
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'5.
Namespaces 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
x = MyClass[]2, so they have their own global namespace. [The built-in names actually also live in a module; this is called
x = MyClass[]3.]
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, there are 3 or 4 nested scopes whose namespaces are directly accessible:
the innermost scope, which is searched first, contains the local names
the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contains non-local, but also non-global names
the next-to-last scope contains the current module’s global names
the outermost scope [searched last] is the namespace containing built-in names
If a name is declared global, then all references and assignments go directly to the middle scope containing the module’s global names. To rebind variables found outside of the innermost scope, the
x = MyClass[]4 statement can be used; if not declared nonlocal, those variables are read-only [an attempt to write to such a variable will simply create a new local variable in the innermost scope, leaving the identically named outer variable unchanged].
Usually, the local scope references the local names of the [textually] current function. Outside 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 – if no
x = MyClass[]5 or
x = MyClass[]4 statement is in effect – assignments to names 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
x = MyClass[]7 removes the binding of
x = MyClass[]8 from the namespace referenced by the local scope. In fact, all operations that introduce new names use the local scope: in particular,
x = MyClass[]9 statements and function definitions bind the module or function name in the local scope.
The
x = MyClass[]5 statement can be used to indicate that particular variables live in the global scope and should be rebound there; the
x = MyClass[]4 statement indicates that particular variables live in an enclosing scope and should be rebound there.
9.2.1. Scopes and Namespaces Example¶
This is an example demonstrating how to reference the different scopes and namespaces, and how
x = MyClass[]5 and
x = MyClass[]4 affect variable binding:
def scope_test[]: def do_local[]: spam = "local spam" def do_nonlocal[]: nonlocal spam spam = "nonlocal spam" def do_global[]: global spam spam = "global spam" spam = "test spam" do_local[] print["After local assignment:", spam] do_nonlocal[] print["After nonlocal assignment:", spam] do_global[] print["After global assignment:", spam] scope_test[] print["In global scope:", spam]
The output of the example code is:
After local assignment: test spam After nonlocal assignment: nonlocal spam After global assignment: nonlocal spam In global scope: global spam
Note how the local assignment [which is default] didn’t change scope_test's binding of spam. The
x = MyClass[]4 assignment changed scope_test's binding of spam, and the
x = MyClass[]5 assignment changed the module-level binding.
You can also see that there was no previous binding for spam before the
x = MyClass[]5 assignment.
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: . . .
Class definitions, like function definitions [
def __init__[self]: self.data = []7 statements] must be executed before they have any effect. [You could conceivably place a class definition in a branch of an
def __init__[self]: self.data = []8 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 definition was entered] is reinstated, and the class object is bound here to the class name given in the class definition header [
def __init__[self]: self.data = []9 in the example].
9.3.2. Class Objects¶
Class objects support two kinds of operations: attribute references and instantiation.
Attribute references use the standard syntax used for all attribute references in Python:
x = MyClass[]0. Valid attribute names are all the names that were in the class’s namespace when the class object was created. So, if the class definition looked like this:
class MyClass: """A simple example class""" i = 12345 def f[self]: return 'hello world'
then
x = MyClass[]1 and
x = MyClass[]2 are valid attribute references, returning an integer and a function object, respectively. Class attributes can also be assigned to, so you can change the value of
x = MyClass[]1 by assignment.
x = MyClass[]4 is also a valid attribute, returning the docstring belonging to the class:
x = MyClass[]5.
Class instantiation uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class. For example [assuming the above class]:
x = MyClass[]
creates a new instance of the class and assigns this object to the local variable
x = MyClass[]8.
The instantiation operation [“calling” a class object] creates an empty object. Many classes like to create objects with instances customized to a specific initial state. Therefore a class may define a special method named
x = MyClass[]7, like this:
def __init__[self]: self.data = []
When a class defines an
x = MyClass[]7 method, class instantiation automatically invokes
x = MyClass[]7 for the newly created class instance. So in this example, a new, initialized instance can be obtained by:
x = MyClass[]
Of course, the
x = MyClass[]7 method may have arguments for greater flexibility. In that case, arguments given to the class instantiation operator are passed on to
x = MyClass[]7. For example,
>>> class Complex: ... def __init__[self, realpart, imagpart]: ... self.r = realpart ... self.i = imagpart ... >>> x = Complex[3.0, -4.5] >>> x.r, x.i [3.0, -4.5]
9.3.3. Instance Objects¶
Now what can we do with instance objects? The only operations understood by instance objects are attribute references. There are two kinds of valid attribute names: data attributes and methods.
data attributes correspond to “instance variables” in Smalltalk, and to “data members” in C++. Data attributes need not be declared; like local variables, they spring into existence when they are first assigned to. For example, if
x = MyClass[]8 is the instance of
>>> class Complex: ... def __init__[self, realpart, imagpart]: ... self.r = realpart ... self.i = imagpart ... >>> x = Complex[3.0, -4.5] >>> x.r, x.i [3.0, -4.5]3 created above, the following piece of code will print the value
>>> class Complex: ... def __init__[self, realpart, imagpart]: ... self.r = realpart ... self.i = imagpart ... >>> x = Complex[3.0, -4.5] >>> x.r, x.i [3.0, -4.5]4, without leaving a trace:
x.counter = 1 while x.counter >> class Complex: ... def __init__[self, realpart, imagpart]: ... self.r = realpart ... self.i = imagpart ... >>> x = Complex[3.0, -4.5] >>> x.r, x.i [3.0, -4.5]5 is a valid method reference, since
x = MyClass[]2 is a function, but
>>> class Complex: ... def __init__[self, realpart, imagpart]: ... self.r = realpart ... self.i = imagpart ... >>> x = Complex[3.0, -4.5] >>> x.r, x.i [3.0, -4.5]7 is not, since
x = MyClass[]1 is not. But
>>> class Complex: ... def __init__[self, realpart, imagpart]: ... self.r = realpart ... self.i = imagpart ... >>> x = Complex[3.0, -4.5] >>> x.r, x.i [3.0, -4.5]5 is not the same thing as
x = MyClass[]2 — it is a method object, not a function object.
9.3.4. Method Objects¶
Usually, a method is called right after it is bound:
x.f[]
In the
>>> class Complex: ... def __init__[self, realpart, imagpart]: ... self.r = realpart ... self.i = imagpart ... >>> x = Complex[3.0, -4.5] >>> x.r, x.i [3.0, -4.5]3 example, this will return the string
x.counter = 1 while x.counter >> class Complex: ... def __init__[self, realpart, imagpart]: ... self.r = realpart ... self.i = imagpart ... >>> x = Complex[3.0, -4.5] >>> x.r, x.i [3.0, -4.5]5 is a method object, and can be stored away and called at a later time. For example:
After local assignment: test spam After nonlocal assignment: nonlocal spam After global assignment: nonlocal spam In global scope: global spam0
will continue to print
x.counter = 1 while x.counter