Lesson on Python Classes by Matt Wufus 2003

Python: Classes
Python: Classes
By Matt Wufsus

Scopes and Namespaces
Scopes 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.
 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.

 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 Definition
Class 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 Objects
Class 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.
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.
>>> 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 Objects
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”. They
need not be declared.
In the example class, this piece of code will print the value 16 without leaving a trace:
x.counter = 1
while x.counter < 10:
x.counter = x.counter * 2
print x.counter
del 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 Object
Method 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.f
while True:
print xf()

Inheritance
Inheritance
 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 Variables
Private 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.

Exceptions
Exceptions
 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

Iterators
Iterators
 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
...
m
a
p
s

Generators
Generators
 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
...
f
l
o
g

Generator Expressions
Generator 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 squares
285
>>> 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.

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

Lesson on Python Classes by Matt Wufus 2003

More Related Content

Similar to Lesson on Python Classes by Matt Wufus 2003

Recently uploaded

Lesson on Python Classes by Matt Wufus 2003