Python: ClassesPython: ClassesBy Matt Wufsus

Scopes and NamespacesScopes and Namespaces

A namespace is a mapping from names to objects.◦ Examples: the set of built-in names, such as the function abs(),

and built-in exception names; the global names in a module; local names in a function invocation.

◦ There is no relationship between names in different namespaces.

◦ 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. The local namespace for a function is created when the function is called,

and deleted when the function returns or raises an exception that isn’t handled in the function.

Scopes and Namespaces cont.Scopes and Namespaces cont.

A scope is a textual region of a Python program where a namespace is directly accessible. ◦ Meaning that an unqualified reference to a name

attempts to find the name in the namespace.

◦ Scopes are determined statically, but used dynamically. At any time during execution, there are at least three

nested scopes who namespaces are directly accessible:◦ Innermost scope, which is searched first, containing the local

names◦ Scopes of enclosing functions, which are searched starting with the

nearest enclosing scope.◦ Next-to-last scope, containing the current module’s global names.◦ Outermost scope, the namespace containing built-in names.

Scopes and Namespaces cont.Scopes and Namespaces cont.

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.◦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 that function is called.◦Actual search for names is done dynamically, at run time.

◦ If no global statement is in effect, assignments to names always go into the innermost scope.

Class DefinitionClass Definition

When a class is defined, a new namespace is created, and all assignments to local variables go into this new namespace.

class ClassName: <statement-1> . . . <statement-N>

Example class:

class MyClass: """A simple example class""" i = 12345 def f(self):

return 'hello world'

Class ObjectsClass Objects

Attribute references use standard syntax.In the example class:

class MyClass: """A simple example class""" i = 12345 def f(self):

return 'hello world'

◦ MyClass.i would return an integer, and MyClass.f would return an object.

◦ Class attributes, like MyClass.i, can have their values changed by assignment.

◦ __doc__ is also a valid attribute that will return the docstring belonging to the class.

In the example class:“A simple example class”

Class Objects cont.Class Objects cont.

Class instantiation uses function notation. ◦ As if the class object is a parameterless function that returns a new instance

of the class

For the example class:x = MyClass()

◦ This creates a new instance of the class and assigns this object to the local variable x.

◦ Instantiation creates an empty object, so many classes like to define special methods that create objects with instances customized to a specific initial state.

For the example class:

def __init__(self):self.data = []

Class Objects cont.Class Objects cont.

◦ When a class defines an __init__() method, the class instantiation invokes __init__() for the newly-created class instance.

◦ The __init__() method may have arguments for greater ◦ flexibility.

For the example class:

>>> 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)

Instance ObjectsInstance 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”. They need not be declared.

In the example class, this piece of code will print the value 16 without leaving a trace:

x.counter = 1while x.counter < 10:

x.counter = x.counter * 2print x.counterdel x.counter

Instance Objects cont.Instance Objects cont.

The other kind of instance attribute reference is a method. A method is a function that “belongs to” an object. Valid method names of an instance object depend on its class.

By definition all attributes of a class that are function objects define corresponding methods of its instances.

In the example class, x.f is a valid method reference, since MyClass.f is a

function, but x.i is not, since MyClass.i is not.

But x.f is not the same thing as MyClass.f — it is a method object, not a function object.

Method ObjectMethod Object

Usually, a method is called right after it is bound:

In the example, the following will return the string hello world. x.f()

However, it is not necesssary to call a method right away as they can be stored away and called at a later time.

For example, this will print hello world over and over:xf = x.fwhile True:

print xf()

InheritanceInheritance

Python, like most other languages, has inheritance, as well as multiple inheritance.

In the following example, the name BaseClassName must be defined in a scope containing the derived class definition.

class DerivedClassName(BaseClassName):<statement-1>...<statement-N>

In place of a base class name, other arbitrary expressions are allowed.

class DerivedClassName (modname.BaseClassName):

Inheritance cont.Inheritance cont.

A class definition with multiple base classes looks like this

class DerivedClassName(Base1,Base2,Base3):<statement-1>...<statement-N>

Python has two built-in functions that work with inheritance:◦ isinstance() checks an instance’s type, and will return True only

if obj.__clas__ is int or some class derived from int.◦ issubclass() checks class inheritance

For example: issubclass(bool, int) is True since bool is a subclass of int.

Private VariablesPrivate Variables

“Private” instance variables that cannot be accessed except from inside an object don’t exist in Python.

But, most Python code follows the convention in which a name prefixed with an underscore, like _spam, should be treated as a non-public part of the API.

Name mangling is a limited support mechanism in which any identifier of the form __spam (two leading underscores, at most one trailing underscore) is textually replaced with _classname__spam, where classname is the current class name.

ExceptionsExceptions

User-defined exceptions are indentified by classes as well.

It is also possible to create extensible hierarchies of exceptions.

Valid raise statements:raise Class, instance

raise instance

IteratorsIterators

You can define an __iter__() method which returns an object with a next().

When there are no more elements, next() raises a StopIteration which tells the for loop to terminate.

An example would be:class Reverse: "Iterator for looping over a sequence backwards"

def __init__(self, data): self.data = data self.index = len(data)

def __iter__(self): return self

def next(self): if self.index == 0:

raise StopIteration self.index = self.index - 1 return self.data[self.index]

>>> for char in Reverse('spam'):...print char ...map s

GeneratorsGenerators

Written like regular functions, but use the yield statement whenever they want to return data.

Each time next() is called, the generator resumes where it left-off.

A trivial example is:def reverse(data): for index in range(len(data)-1, -1, -1):

yield data[index] >>> for char in reverse('golf'): ... print char ...flog

Generator ExpressionsGenerator Expressions

You can use generator expressions, instead of writing a full generator definition to quickly create a simple generator.

Some examples:>>> sum(i*i for i in range(10)) # sum of squares285

>>> data = 'golf‘>>> list(data[i] for i in range(len(data)-1,-1,-1))['f', 'l', 'o', 'g'] # puts reveresed string into list

Questions?Questions?

The Python Tutorial in the Python v2.6.4 documentation explains every Class topic in great detail with more examples than I have provided in this presentation.

ReferencesReferences

Python v2.6.4 documentation >> The Python Tutorial >> Classes◦http://docs.python.org/tutorial/classes.html