Programming Python, Part II

Having covered some advanced features in Part I, it's time to include some basics.

The tutorial in last month's issue covered the basics of installing Python, running it and using it. Then, we moved on to building a basic blog in Python. The blog was extremely simple—only a Python list. We focused on the posts and built a Post class:

class Post(object):
    def __init__(self, title, body):

    def set_title(self, title):
        self._title = title

    def get_title(self):
         return self._title

    def set_body(self, body):
        self._body = body

    def get_body(self):
         return self._body

    def __repr__(self):
        return "Blog Post: %s" % self.get_title()

In this follow-up article, let's focus on the blog itself and go further.

The Blog

Now that we have the Post class, we can make the Blog class. An initial implementation may look like this:

class Blog(object):
    def __init__(self):
        self._posts = []

    def add_post(self, post):

    def get_posts(self):
        return self._posts

We are using a list to maintain the posts, but the interface is totally abstract behind a set of methods in the Blog class. This has a huge advantage: tomorrow we could replace that simple list with an SQL back end, and the code that uses Blog will need few, if any, changes.

Notice that there's no way to delete a post. We could tamper with _posts directly, but as long as we do what the class was meant to do, we can't delete a post. That may be good or bad, but the important thing is that by defining a set of methods, we exposed the design of how the class should be used.

To Publish or Not to Publish

The method get_posts returns all the posts. When we are writing a new post, we don't want the whole world to be able to read it until it is finished. The posts need a new member that tell whether it is published. In Post's initalizator, __init__, we add the line:

self._published = False

That makes every new post private by default. To switch states, we add the methods:

def publish(self):
    self._published = True

def hide(self):
    self._published = False

def is_public(self):
    return self._published

In these methods, I introduced a new kind of variable—the boolean. Booleans are simple; they can be true or false. Let's play with that a bit:

>>> cool = blog.Post("Cool", "Python is cool")
>>> cool.is_public()
>>> cool.publish()
>>> cool.is_public()
>>> cool.hide()
>>> cool.is_public()

If, when you run is_public, you get:

Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "", line 25, in is_public
    return self._published
AttributeError: 'Post' object has no attribute 

That's because _published was not created, it can't be used, and is_public wants to use it. Understanding errors in your tools is important if you want to be a successful programmer.

In this short set of messages, the last line is the error itself. There are various types of errors, and this one is an AttributeError. A lot of important information is given in the traceback. A traceback is a list of “who called whom”, providing an idea of what was being executed when the error occurred.

The first line of the traceback doesn't give much information. It probably relates to the line we typed at the REPL. The second line tells that the error was in the file, on line 25, on the method is_public. Now we have the line that raised the problem.

This traceback is simple. In a real application, you would have methods that call methods that call methods and so on. In those cases, it is not uncommon to see tracebacks of 25 lines or more. I've seen tracebacks of more than 150 lines, but those were extreme cases in extreme conditions.

The next step is a modification to the Blog class to pick up only published posts. So, we add a new method:

def get_public_posts(self):
    published_posts = []
    for post in self._posts:
        if port.is_public():

Python tries to be as readable as possible, but that method introduces too many new things, so it requires some careful explanations.



Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.


csshef's picture

cool = blog.Post("Cool", "Python is cool")

I can't get the above line to work. Is that correct?


ejournal's picture

Were you using Emacs and following the instructions in part I? If so, the class "Post" will be part of the module "blog". If not, you must arrange for that yourself - the article explains.

If I understand correctly. I'm not a Python programmer. :)