Started on final changes to the build scripts so that we can start with totally automatic builds
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>
Chapter. oop
</title>
<link rel="stylesheet" href="/review/support/styles.css" type="text/css" />
<meta name="generator" content="DocBook XSL Stylesheets V1.74.3" />
<link rel="shortcut icon" type="image/png" href="/review/support/figs/favicon.png" />
<script type="text/javascript" src="/review/support/jquery-min.js">
</script>
<script type="text/javascript" src="/review/support/form.js">
</script>
<script type="text/javascript" src="/review/support/hsbook.js">
</script>
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="chapter" id="ch6oop">
<div class="titlepage">
</div>
<div class="toc">
<p>
<b>
Table of Contents
</b>
</p>
<dl>
<dt>
<span class="article">
<a href="#id2471018">
Classes and Objects
</a>
</span>
</dt>
</dl>
</div>
<div class="article" title="Classes and Objects">
<div class="titlepage">
<div>
<div>
<h2 class="title">
<a name="id2471018">
</a>
Classes and Objects
</h2>
</div>
</div>
<hr />
</div>
<p id="ch6oop_1">
In the previous sections we learnt about functions which provide certain level
of abstraction to our code by holding the code which performs one or more
specific functionalities. We were able to use this function as many times as we
wanted. In addition to functions, Python also higher level of abstractions
through
<span class="emphasis">
<em>
Classes
</em>
</span>
and
<span class="emphasis">
<em>
Objects
</em>
</span>
.
<span class="emphasis">
<em>
Objects
</em>
</span>
can be loosely defined as a
collection of a set of data items and a set of methods. The data items can be
any valid Python variable or any Python object. Functions enclosed within a class
are called as
<span class="emphasis">
<em>
methods
</em>
</span>
. If you are thinking if methods are functions why is there
a distinction between the two? The answer to this will be given as we walk through
the concepts of
<span class="emphasis">
<em>
Classes
</em>
</span>
and
<span class="emphasis">
<em>
Objects
</em>
</span>
.
<span class="emphasis">
<em>
Classes
</em>
</span>
contain the definition for the
<span class="emphasis">
<em>
Objects
</em>
</span>
.
<span class="emphasis">
<em>
Objects
</em>
</span>
are instances of
<span class="emphasis">
<em>
Classes
</em>
</span>
.
</p>
<p id="ch6oop_2">
A class is defined using the keyword
<span class="strong">
<strong>
class
</strong>
</span>
followed by the class name, in
turn followed by a semicolon. The statements that a
<span class="emphasis">
<em>
Class
</em>
</span>
encloses are written
in a new block, i.e on the next indentation level:
</p>
<pre class="programlisting">
class Employee:
def setName(self, name):
self.name = name
def getName(self):
return self.name
</pre>
<p id="ch6oop_3">
In the above example, we defined a class with the name Employee. We also defined
two methods, setName and getName for this class. It is important to note the
differences between the normal Python functions and class methods defined above.
Each method of the class must take the same instance of the class(object) from
which it was called as the first argument. It is conventionally given the name,
<span class="emphasis">
<em>
self
</em>
</span>
. Note that
<span class="emphasis">
<em>
self
</em>
</span>
is only a convention. You can use any other name, but
the first argument to the method will always be the same object of the class
from which the method was called. The data memebers that belong to the class are
called as
<span class="emphasis">
<em>
class attributes
</em>
</span>
.
<span class="emphasis">
<em>
Class attributes
</em>
</span>
are preceded by the object of
the class and a dot. In the above example,
<span class="emphasis">
<em>
name
</em>
</span>
is a class attribute since it
is preceded by the
<span class="emphasis">
<em>
self
</em>
</span>
object.
<span class="emphasis">
<em>
Class attributes
</em>
</span>
can be accessed from
anywhere within the class.
</p>
<p id="ch6oop_4">
We can create objects of a class outside the class definition by using the same
syntax we use to call a function with no parameters. We can assign this object
to a variable:
</p>
<pre class="programlisting">
emp = Employee()
</pre>
<p id="ch6oop_5">
In the above example, we create an object named
<span class="emphasis">
<em>
emp
</em>
</span>
of the class
<span class="emphasis">
<em>
Employee
</em>
</span>
.
All the attributes and methods of the class can be accessed by the object of the
class using the standard notation
<span class="emphasis">
<em>
object.attribute
</em>
</span>
or
<span class="emphasis">
<em>
object.method()
</em>
</span>
.
Although the first parameter of a class method is the self object, it must not
be passed as an argument when calling the method. The
<span class="emphasis">
<em>
self
</em>
</span>
object is implicitly
passed to the method by the Python interpreter. All other arguments passing rules
like default arguments, keyword arguments, argument packing and unpacking follow
the same rules as those for ordinary Python functions:
</p>
<pre class="programlisting">
>>> emp.setName('John')
>>> name = emp.getName()
>>> print name
John
>>> print emp.name
John
</pre>
<p id="ch6oop_6">
If we at all try to access a class attribute before assigning a value to it, i.e
before creating it, Python raises the same error as it would raise for the
accessing undefined variable:
</p>
<pre class="programlisting">
>>> emp = Employee()
>>> emp.name
Traceback (most recent call last):
File "class.py", line 10, in <module>
print e.name
AttributeError: Employee instance has no attribute 'name'
</pre>
</div>
</div>
</body>
</html>