A Python 2.7 programming tutorial

Let's start building a snail-racing application for Malek the object-oriented Python way. Let's assume that all we're tracking about a particular snail is its name and its finishing time. We need to define a class named SnailRun, whose instances track just these two attributes.

Here is the general form of a class declaration in Python:

class ClassName:
    def method1(self, ...):
        block1
    def method2(self, ...):
        block2
    ... etc.

A class declaration starts out with the keyword class, followed by the name of the class you are defining, then a colon (:). The methods of the class follow; each method starts with “def”, just as you use to define a function.

Before we look at the construction of the class, let's see how it works in practice. To create an instance in Python, you use the name of the class as if it were a function call, followed by a list of arguments in parentheses. Our SnailRun constructor method will need two arguments: the snail's name and its finish time. Once we have defined the class, we can build a new instance like this:

judyRace9 = SnailRun ( 'judy', 87.3 )

To get the snail's name and time attributes from an instance, we use the instance name, followed by a dot (.), followed by the attribute name:

>>> judyRace9.name
'judy'
>>> print judyRace9.time
87.3

Our example class, SnailRun, will have just two methods:

Continuing our example from above, here's an example of the use of the .show() method:

>>> print judyRace9.show()
Snail 'judy' finished in 87.3 minutes.

Here is the entire class definition:

class SnailRun:
    def __init__ ( self, snailName, finishTime ):
        self.name  =  snailName
        self.time  =  finishTime

    def show ( self ):
        return ( "Snail '{0}' finished in {1:.1d} minutes.".format(
                 self.name, self.time )

Instantiation means the construction of a new instance. Here is how instantiation works.

Let's look again in more detail at the constructor:

    def __init__ ( self, snailName, finishTime ):
        self.name  =  snailName
        self.time  =  finishTime

All the constructor does is to take the snail's name and finish time and store these values in the instance's namespace under the names .name and .time, respectively.

Note that the constructor method does not (and cannot) include a return statement. The value of self is implicitly returned to the statement that called the constructor.

As for the other methods of a class, their definitions also start with the special argument self that contains the instance namespace. For any method that takes N arguments, the caller passes only the last N-1 arguments to it.

In our example class, the def for the .show() method has one argument named self, but the caller invokes it with no arguments at all:

>>> kyleRace3=SnailRun('Kyle', 96.6)
>>> kyleRace3.show()
"Snail 'Kyle' finished in 96.6 minutes."