I know it’s been a while and for that I apologize the last few months have been pretty crazy around here…although I’m starting to see a trend with life in general lately, namely that it’s always crazy.

I’ve been busy with work, Python Magazine, my wife, trips to Dallas, and yes whenever I get a chance this slowly growing level editor. Let’s see what I’ve been working on for the last little while:

Name: There has a been a name for the editor ever since I started working on it. I wasn’t sure if I was going to think up something really cool and change, or leave it. Turns out I just left it.

So from this point forward this project is christened: “Dodger”, or probably more correctly: “Dodger Level Editor”.

The name has its roots in the name of one of my cats and a history in the multitudes of level editors and game engines that I have tried to create in the past, but I wont’ go into that. So Dodger it is.

Saving and Loading: Saving and loading in the default YAML project type now really works. I still need to put in support for optional project types: XML, JSON, and other formats

Welcome Dialog: This was a real pain, but it’s made the last while so much easier. I added a working (at least I hope) welcome dialog with a way to create new projects, open old ones, and a recent file list. The recent file list really makes testing easier for me.

Rect tracking: Rect tracking is finally working properly. I’ve had the rect tracker in there for a while but it didn’t really do anything until now.

Multiple Selection/Multiple Properties: I’ve also finally got multiple selection going, which is what makes the rect tracker actually useful. You can select multiple sprties, move them around and add properties to all of them.

Remove Properties: Now you can remove custom properties that you have added. This was a must but I was lazy and left it for a while.

Steps towards being made public: A lot of the changes (and I do mean a lot) that I’ve been making have been behind the scenes. There has been a lot of refactoring and reorganizing of the code, often the result of quick and dirty implementations that I made earlier (sigh). I’ve also started working on getting the distribution of this editor going so that other people can use/develop it.

I’ve added support for zc.Buildout so that if anyone wants to develop they can quickly gather dependencies and won’t have to install the editor system wide, not that you have to anyways but zc.Buildout is really neat.

I’ve also worked on the license (GPLv3) and setup.py and README and all of that. None of it’s done but it’s working its way forward.

Faster: It’s also much faster now. None of you have used it so you’ll probably think it’s slow, but trust me it’s much faster then it was before.

Bugs: There have been loads of bugs that have been fixed and created. Plus one doozy related to
changes made to pyglet. Not pyglets fault but it took a long time to figure out what the issue was.

Google Code: The project has a temporary homepage over at google code: http://code.google.com/p/dodger-editor/ There’s nothing there yet but over time I will start to host the project there so that people can easily download it. I’ll still post updates here until the site has a full-time home.

I’m going to use Mercurial for the revision control system for the project so the CVS support at the google code site will just be for downloading. Eventually I will want to host the project on some space of my own and get a nice web interface for the mercurial repository going. I’ll have to find a new hosting company so it will take a while.

So that’s it, that’s what’s happened to the Dodger Level Editor over the last few months. I know I promised to make it public earlier but given the shape it was in at that time there really was no point. I want this to be at a point where people can actually almost use it before I make it public.

I know it’s been a while, and I know the few of you that actually care about this project have probably moved onto bigger and better things, but hopefully if you stick with me there will be something out soon.

This is a quick post on how to use menu’s in Tkinter, if you are unfamiliar with Tkinter you might want to check out some of my other Tkinter related posts.

We are going to start of with a basic python Tkinter app:

#! /usr/bin/env python
from Tkinter import *

class App(Frame):

	def __init__(self, master):
		
		"""Initialise the base class"""
        	Frame.__init__(self,master)
        
        	"""Set the Window Title"""
        	self.master.title("TkInter Menus")
		self.configure(height=200,width=200)
        	"""Display the main window
        	with a little bit of padding"""
        	self.grid(padx=15, pady=15,sticky=N+S+E+W)

if __name__ == "__main__":
	root = Tk()
	app = App(root)
	root.mainloop()

What this gives us is basically a plain old blank Tkinter window, not too exciting. The next thing we are going to do is add create our root menu, before going any further you might want to read the excellent information about menu widgets in PythonWare’s Tkinter introduction. You don’t have to but it’s an excellent source of information.

To create the root menu we simply add the following command to our __init__ function:

#Create the Menu base
self.menu = Menu(self)
#Add the Menu
self.master.config(menu=self.menu)

No we are greeted with, well a blank window with a blank menu, the reason for this is because we haven’t added anything to it. What we are going to add to it is a menu, but not just any menu, a menu who’s parent is our menu base:

#Create our Python menu
self.tkMenu = Menu(self.menu)
#Add our Menu to the Base Menu
self.menu.add_cascade(label="TkMenu", menu=self.tkMenu)

Now we’re getting somewhere at least we have a menu now! The next step is to add items to our TkMenu:

#Add items to the menu
self.tkMenu.add_command(label="Simple", command=self.Simple)
self.tkMenu.add_separator()
self.tkMenu.add_command(label="Menu", command=self.Menu)

That’s basically it! Adding the menu item’s is pretty simple, we specify it’s text and then tell it what function to call when the user clicks on the menu item. The two functions that I used don’t really do anything besides show a message box:

def Simple(self):
		tkMessageBox.showinfo("Simple", "Simple")
def Menu(self):
		tkMessageBox.showinfo("Menu", "Menu")

Well that’s it for this post, here is the code in its entirety:

#! /usr/bin/env python
from Tkinter import *

import tkMessageBox

class App(Frame):


	def __init__(self, master):
		
		"""Initialise the base class"""
        	Frame.__init__(self,master)
        
        	"""Set the Window Title"""
        	self.master.title("TkInter Menus")
		self.configure(height=200,width=200)
        	"""Display the main window
        	with a little bit of padding"""
        	self.grid(padx=15, pady=15,sticky=N+S+E+W)       
 
       		#Create the Menu base
        	self.menu = Menu(self)
        	#Add the Menu
        	self.master.config(menu=self.menu)
        	
		#Create our Python menu
		self.tkMenu = Menu(self.menu)
		#Add our Menu to the Base Menu
        	self.menu.add_cascade(label="TkMenu", menu=self.tkMenu)

		#Add items to the menu
		self.tkMenu.add_command(label="Simple", command=self.Simple)
		self.tkMenu.add_separator()
		self.tkMenu.add_command(label="Menu", command=self.Menu)
	
	def Simple(self):
		tkMessageBox.showinfo("Simple", "Simple")
	def Menu(self):
		tkMessageBox.showinfo("Menu", "Menu")        	


if __name__ == "__main__":
	root = Tk()
	app = App(root)
	root.mainloop()

All right in Part one we actually created a semi-working almost-game, in part two we’re going to go a bit further, in part two we’re going to add the walls that will make help make PyMan (our python based PacMan clone) an actual game.

Note: Part one has been mistakenly half-deleted by me, so it is not fully available at this time. I am working to re-write it so it should be up soon.

Note: I also changed the images that I used in Part one so now we have a new smaller snake.

You can download the full source for Part Two here.

What we are going to do is base some of our level code on a great PyGame tutorial over at DevShed specifically the idea of the level layout. This is something that has always puzzled me about games, how they create their levels? I’ve read some articles and beginnings of books but I’ve never really be able to understand it, but the multidimensional array approach discussed in the DevShed article is nothing if not simple.

So the idea is that our game world, or game board, will basically be a grid of 24×24 pixel items, and we will have a multidimensional array or list that we will used to describe it.

So for example lets say we have a grid like this:


0 0 0 0 0
1 1 1 1 1
1 0 0 0 1
1 1 1 1 1
0 0 0 0 0


Now that grid may result in the following:

Where 0 is nothing and where 1 is a blue square. We could then add 2’s if we wanted to and make those red squares, or anything else that we wanted. So that is basically how our levels are going to be defined.

The first thing we are going to do is add a new file to our project called levelBase.Py, in that we will define a class called level which is as follows:

class Level:
    """The Base Class for Levels"""
    def getLayout(self):
        """Get the Layout of the level"""
        """Returns a [][] list"""
        pass
    def getImages(self):
        """Get a list of all the images used by the level"""
        """Returns a list of all the images used.  The indices 
        in the layout refer to sprites in the list returned by
        this function"""
        pass

Pretty simple not much going on there, getLayout returns a multidimensional list of numbers that represents the level, and getImages returns a list of the images used by the level.

It may seem complicated but once you see our first level it will start to make some sense. The next thing to do is add a file called level001.py to our project. I waffled on this a bit, I was unsure if it was better to have one file called levels.py that contained classes called level001, or make each level a separate file. In then end I went with each level being a separate file, just because it separates things, but I don’t really know if one method is superior over the other. Here is the code for level001.py:

#! /usr/bin/env python

import levelBase
from helpers import load_image

class level(levelBase.Level):
    """Level 1 of the PyMan Game"""
    
    def __init__(self):
        self.BLOCK = 1
        self.SNAKE = 2
        self.PELLET = 0
    
    def getLayout(self):
        return [[9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 ,9, 9, 9, 9, 9, 9, 9, 9, 9, 9],\
                [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 ,9, 9, 9, 9, 9, 9, 9, 9, 9, 9],\
                [9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ,1, 1, 1, 1, 1, 1, 1, 1, 1, 9],\
                [9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ,0, 0, 0, 0, 0, 0, 0, 0, 1, 9],\
                [9, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1 ,0, 1, 1, 1, 0, 1, 1, 0, 1, 9],\
                [9, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 0, 0, 0, 0, 0, 1, 9],\
                [9, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1 ,1, 1, 0, 1, 0, 1, 1, 0, 1, 9],\
                [9, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1 ,0, 0, 0, 1, 0, 0, 0, 0, 1, 9],\
                [9, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 9],\
                [9, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 9],\
                [9, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 9],\
                [9, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 9],\
                [9, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 9],\
                [9, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 9],\
                [9, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 9],\
                [9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9],\
                [9, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 9],\
                [9, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 9],\
                [9, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 9],\
                [9, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 9],\
                [9, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 9],\
                [9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9],\
                [9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9]]         
        
    def getSprites(self):
        block, rect = load_image('block.png')
        pellet, rect = load_image('pellet.png',-1)
        snake, rect = load_image('snake.png',-1)
        return [pellet,block,snake]

You can see that in the __init__ function the level defines three values: BLOCK, SNAKE, and PELLET. These values correspond to the numbers in the list returned by getLayout(). So wherever there is a 1 in the list, that will correspond to a BLOCK, a 0 is a PELLET, and a 2 is our snake. In this example I use 9 to represent a blank square.

You’ll also notice that the getImages() function returns a list of images that are indexed by those same values. So in the list returned by getImages(), position [BLOCK] is the block image.

So far so good, the next thing we are going to do is add a base class for all of our sprites. In Part one we didn’t need to do this since we only had two sprites, but in this lesson (as we can see above) we are going to have at least three and that number will continue to grow. So we will add another file to our project called basicSprite.py, this will be the base class that we use for all of our sprites. It doesn’t do much besides add a few initialization features to pygame.sprite.Sprite class. The code for basicSprite.py is as follows:

#! /usr/bin/env python

import pygame

class Sprite(pygame.sprite.Sprite):
        
    def __init__(self, centerPoint, image):
        pygame.sprite.Sprite.__init__(self) 
        """Set the image and the rect"""
        self.image = image
        self.rect = image.get_rect()
        """Move the rect into the correct position"""
        self.rect.center = centerPoint

As you can see all that basicSprite.Sprite does is really add a few initialization values: centerPoint and image. Image is the image that the sprite will use and centerPoint is the center point of the rect, it controls where the image will be placed. The nice thing about using the center point is that it is correct regardless of the images size. So if you have a 16×16 image and a 24×24 image the center point will be the same, but the topleft point (which we used in part one) will be different for both.

Because of the addition of the basicSprite.Sprite we are going to have to change our snake sprite from part one, we are also going to move the sprite into it’s own file since it will start getting a bit complicated as time goes on. So we will add the file snakeSprite.py to our project. snakeSprite.py will contain a class called Snake, which will be based off of our basicSprite.Sprite class:

class Snake(basicSprite.Sprite):

Snake will initialize itself as follows:

def __init__(self, centerPoint, image):
    """initialize base class"""
    basicSprite.Sprite.__init__(self, centerPoint, image)
    """Initialize the number of pellets eaten"""
    self.pellets = 0
    """Set the number of Pixels to move each time"""
    self.x_dist = 3
    self.y_dist = 3 
    """Initialize how much we are moving"""
    self.xMove = 0
    self.yMove = 0

You’ll notice that the initialization is similar to the initialization in part one except this time we are using the basicSprite.Sprite class to set up our image and rect. Then we initialize the same values, except we have introduce two new ones, self.xMove and self.yMove. The reason for this is we are going to change the way that we move our snake.

If you tried out the last tutorial you’ll see that just moving the character on the key down events didn’t work all that well. It worked well enough but if you start pressing more then one key are the same time pyGame seemed to get a bit confused.

In order to combat this we will use another tip taken from the DevShed tutorial and pay attention to both the DOWN and UP events associated with keystrokes. We will also switch to using the update() function to update the snake.

So what we are going to is add two functions to the Snake class MoveKeyUp() and MoveKeyDown(). What these functions will do is adjust the xMove and yMove variables depending on what key has been pressed. Then when the update function is called the Snake will update it’s positions according the values of xMove and yMove. It may seem a bit complicated but it’s actually pretty simple:

def MoveKeyDown(self, key):
    """This function sets the xMove or yMove variables that will
    then move the snake when update() function is called.  The
    xMove and yMove values will be returned to normal when this 
    keys MoveKeyUp function is called."""
    
    if (key == K_RIGHT):
        self.xMove += self.x_dist
    elif (key == K_LEFT):
        self.xMove += -self.x_dist
    elif (key == K_UP):
        self.yMove += -self.y_dist
    elif (key == K_DOWN):
        self.yMove += self.y_dist
    
def MoveKeyUp(self, key):
    """This function resets the xMove or yMove variables that will
    then move the snake when update() function is called.  The
    xMove and yMove values will be returned to normal when this 
    keys MoveKeyUp function is called."""
    
    if (key == K_RIGHT):
        self.xMove += -self.x_dist
    elif (key == K_LEFT):
        self.xMove += self.x_dist
    elif (key == K_UP):
        self.yMove += self.y_dist
    elif (key == K_DOWN):
        self.yMove += -self.y_dist

As you can see when we press the K_LEFT key down we add -x_dist pixels to the xMove variable. This will then be used to move the snake in the update() function. Then when we let up the K_LEFT key we remove the -x_dist values that we added to xMove. For example if you hold down K_LEFT for a moment xMove will before -3 (move three pixels to the left every time the update() function is called), then when you let the K_LEFT key up xMove will become 0 (don’t move).

Then all we have to do is add the update function:

def update(self,block_group):
    """Called when the Snake sprit should update itself"""
    self.rect.move_ip(self.xMove,self.yMove)
    """IF we hit a block, don't move - reverse the movement"""
    if pygame.sprite.spritecollide(self, block_group, False):
        self.rect.move_ip(-self.xMove,-self.yMove)

Now the update() function is function in pyGames Sprite class. It really doesn’t do anything besides providing a convenient way to update a group of sprites. It will also pass the same parameters to all of your sprites in the group. So if you have a bunch of sprites that need to know the current time when you update them it’s a good idea to add them to the same group and then update them all at once by calling the group.update() function and pass the time.

You’ll also notice that there is a second parameter passed to this function called block_group, this is the group of all of our block sprites. We use that group to do a hit test. If the snake has collided with a block after we have adjusted it’s rect, we reverse the movement.

No we are going to go back to our PyManMain class and edit the LoadSprites() function. We are going to use this function to load the level that we created in level001.py and all of the sprites that we need:

def LoadSprites(self):
    """Load all of the sprites that we need"""
    """calculate the center point offset"""
    x_offset = (BLOCK_SIZE/2)
    y_offset = (BLOCK_SIZE/2)
    """Load the level"""        
    level1 = level001.level()
    layout = level1.getLayout()
    img_list = level1.getSprites()
    
    """Create the Pellet group"""
    self.pellet_sprites = pygame.sprite.Group()
    """Create the block group"""
    self.block_sprites = pygame.sprite.Group()
    
    for y in xrange(len(layout)):
        for x in xrange(len(layout[y])):
            """Get the center point for the rects"""
            centerPoint = [(x*BLOCK_SIZE)+x_offset,(y*BLOCK_SIZE+y_offset)]
            if layout[y][x]==level1.BLOCK:
                block = basicSprite.Sprite(centerPoint, img_list[level1.BLOCK])
                self.block_sprites.add(block)
            elif layout[y][x]==level1.SNAKE:
                self.snake = Snake(centerPoint,img_list[level1.SNAKE])
            elif layout[y][x]==level1.PELLET:
                pellet = basicSprite.Sprite(centerPoint, img_list[level1.PELLET])
                self.pellet_sprites.add(pellet)  
    """Create the Snake group"""            
    self.snake_sprites = pygame.sprite.RenderPlain((self.snake))

Since this function is a bit more complicated I will try to explain it in more detail. The first thing that we do is calculate the x_offset and the y_offset, using the value BLOCK_SIZE. BLOCK_SIZE is simple a global created in pyMan.py that refers to the size that each block will be. So in this case, BLOCK_SIZE = 24. The x_offset and y_offsets are the center points of a block. We use these offsets to position the sprites that we will create.

After that we load the level: we create an instance of the level001 class, and then get it’s layout and it’s image list. Then we create our pellet and block groups, these will be sprite groups that contain all the pellet or block sprites.

The next step is to loop through the layout of the level and create the necessary sprites at each position. We first calculate the current blocks center point, just to make the code a bit cleaner, and then we check to see what the current position in the layout is. It it’s a BLOCK position we create new block sprite and add it to the block_sprites group. If it’s a PELLET position, we create a new pellet sprite and add it to the pellet_sprites group.

The only sprite that we treat a bit differently is the snake sprite, since we will only have one snake per level, we only create one. And if the level designer mistakenly added two snakes, we will use the second snake as the snakes position.

You’ll also notice that both the pellet and the block sprites are simply basicSprites.Sprite’s since they don’t really do anything else besides get drawn to the screen.

Now we simply have to adjust our MainLoop() function to take into account all of the changes that we have made to our game:

def MainLoop(self):
        """This is the Main Loop of the Game"""
        
        """Load All of our Sprites"""
        self.LoadSprites();
        
        """Create the background"""
        self.background = pygame.Surface(self.screen.get_size())
        self.background = self.background.convert()
        self.background.fill((0,0,0))
        """Draw the blocks onto the background, since they only need to be 
        drawn once"""
        self.block_sprites.draw(self.background)
        
        while 1:
            for event in pygame.event.get():
                if event.type == pygame.QUIT: 
                    sys.exit()
                elif event.type == KEYDOWN:
                    if ((event.key == K_RIGHT)
                    or (event.key == K_LEFT)
                    or (event.key == K_UP)
                    or (event.key == K_DOWN)):
                        self.snake.MoveKeyDown(event.key)
                elif event.type == KEYUP:
                    if ((event.key == K_RIGHT)
                    or (event.key == K_LEFT)
                    or (event.key == K_UP)
                    or (event.key == K_DOWN)):
                        self.snake.MoveKeyUp(event.key)
            """Update the snake sprite"""        
            self.snake_sprites.update(self.block_sprites)
                        
            """Check for a snake collision/pellet collision"""
            lstCols = pygame.sprite.spritecollide(self.snake
                                                 , self.pellet_sprites
                                                 , True)
            """Update the amount of pellets eaten"""
            self.snake.pellets = self.snake.pellets + len(lstCols)
                        
            """Do the Drawing"""               
            self.screen.blit(self.background, (0, 0))     
            if pygame.font:
                font = pygame.font.Font(None, 36)
                text = font.render("Pellets %s" % self.snake.pellets
                                    , 1, (255, 0, 0))
                textpos = text.get_rect(centerx=self.background.get_width()/2)
                self.screen.blit(text, textpos)
               
            self.pellet_sprites.draw(self.screen)
            self.snake_sprites.draw(self.screen)
            
            pygame.display.flip()

It’s a lot of code, but it’s not really that different then the code was in part one. An obvious difference is the way in which we adjust the snakes position, using the MoveKeyUp, MoveKeyDown, and update function. Everything else is basically identical to the way that it was in part one.

The only other difference is the fact that we have to draw the block sprites. Since the blocks are static and will never be updated, we are going to draw then to the background surface. This will save us a bit of drawing time when we draw.

When we run the code now we are greeted with the simple PyMan level that we saw at the beginning of this post. Now this isn’t close to being a finished game as there is no level two, and there are no bad guys, but our simple game it starting to take shape.

In the next part of this pyGame series I hope to add the bad guys to the level and the idea of the super pellets. If you want to download the code for this post you can do so here.

If you like this post remember to digg it

Prerequisites

In order to follow along with this tutorial you will need Python 2.4 and PyGame 1.7.0+ installed. Since I’m doing this all on a Mac and Python 2.4.2 is not available from MacPython or any other site as a disk image I decided to install from source.

If you are try to build Python on a Mac as well you should probably install into the /Library/Frameworks path as explained by this site.

Basically once you have downloaded the source from python.org unpack the tar ball as follows:

tar -zxvf Python-2.4.2.tgz

Once that has finished change to the Python-2.4.2 directory that was just created and install it by issuing the following commands:

./configure --enable-framework
make
sudo make frameworkinstall


For Windows or Linux you should be able to install easily given the instructions on the Python site.

This will install Python in the /Library/Frameworks path, and create a symlink to the python executable in /use/local/bin, which is not part of the PATH environment variable on new OS X builds, so you will probably want to add it:

export PATH=/usr/local/bin:$PATH

Part One

The full source of this tutorial can be downloaded here.

So let’s actually start creating this game using PyGame. For our snake image in the game I’m going to use the snake to the left for now. As you can see I’m not artist, but I was able to install the gimp on my Mac and get that image to a point that I think is relatively acceptable. If anyone out there has any graphics skills and can whip me up a better looking python in a 64×64 png I’d gladly use it!

So the first thing we are going to do is create a new PyDev project in Eclipse. I’m going to use Python 2.4 for this project because it is the version that is compatible with my PyGame Installation.

Then I’m going to create a new file called PyMan.py, this will be the main file of our game for now. The architecture may change as I go through this and discover better ways to use the files in my projects but for now this will work as a main file. In the directory that I create my project I will also create a subfolder entitled “data” and in that subfolder I will have another folder entitled “images” where I will store the above snake.png image.

Note: A lot of the information in this post was taken from the Pete Shinner’s great Line by Line Chimp and Python Pygame Introduction tutorials.

Now the first thing that we are going to have to do is import the libraries that we are going to need, we’ll also warn the user if the font or sound mixers are not available:

import os, sys
import pygame
from pygame.locals import *

if not pygame.font: print 'Warning, fonts disabled'
if not pygame.mixer: print 'Warning, sound disabled'

Then we’re going to create a class called PyManMain, this is going to be the main class of our game, it will handle all of the main functions in our game, things like the game loop, the screen creation, and keeping track of all of our sprites:

class PyManMain:
    """The Main PyMan Class - This class handles the main 
    initialization and creating of the Game."""
    
    def __init__(self, width=640,height=480):
        """Initialize"""
        """Initialize PyGame"""
        pygame.init()
        """Set the window Size"""
        self.width = width
        self.height = height
        """Create the Screen"""
        self.screen = pygame.display.set_mode((self.width
                                               , self.height))

As you can see our __init__ function takes two optional parameters height and width, this will be the height and the width of the screen that we create. The __init__ function basically initializes pygame (pygame.init()) and then creates our main screen using the pygame.display.set_mode function.

So far so good! The next thing that we are going to need is a game loop, this is the loop that will process all of the events that PyGame sends our way. To do that, we’re going to add a function to our PyManMain class called MainLoop:

def MainLoop(self):
    """This is the Main Loop of the Game"""
    while 1:
        for event in pygame.event.get():
            if event.type == pygame.QUIT: 
                sys.exit()

We’ll also add the code to our class that will start out game:

if __name__ == "__main__":
    MainWindow = PyManMain()
    MainWindow.MainLoop()

If you run this now you will be with a very uninspiring black screen. It may not be much but for the amount of code that we’ve written it’s pretty good.

The next thing that we need to create is out snake sprite. We are going to wrap our snake sprite in it’s own class called snake (of course) and it will be based off of the pygame.sprite.Sprite class. If you want to read more about PyGames sprite and group classes you should read piman’s great sprite tutorial:

class Snake(pygame.sprite.Sprite):
    """This is our snake that will move around the screen"""
    
    def __init__(self):
        pygame.sprite.Sprite.__init__(self) 
        self.image, self.rect = load_image('snake.png',-1)
        self.pellets = 0

As you can see the Snake class really isn’t doing much besides initializing the Sprite base class and loading the snake image. It also sets pellets to zero, this variable isn’t used yet but it is the number of pellets that our snake has eaten.

You’ll notice that we use load_image to load our snake image. This function is taken from the Line by Line Chimp tutorial. I created a new file for my project called helpers.py which will contain all helper functions. I put load_image in this file and added the following to the top of PyMan.py:

from helpers import *

Now we have to create an instance of our snake sprite and display it. To do this I created another function in the PyManMain class called LoadSprites, this function will take care of loading all of our sprites:

def LoadSprites(self):
    """Load the sprites that we need"""
    self.snake = Snake()
    self.snake_sprites = pygame.sprite.RenderPlain((self.snake))

This function creates the sprite (self.snake = Snake) and then creates a group that contains our snake sprite (self.snake_sprites = pygame.sprite.RenderPlain((self.snake))).

We are also going to have to make some changes to the MainLoop function, we are going to have to load all of our sprites before we enter the while loop:

"""Load All of our Sprites"""
self.LoadSprites();

Then after our event for loop but within the while loop we need to tell PyGame to draw our sprit:

self.snake_sprites.draw(self.screen)
pygame.display.flip()

Now we’re getting somewhere! We’ve got our little PyMan snake displaying himself in the top left corner of our screen. Not too bad.

The next thing that we’re going to want to do is create and display all of our pellets, this isn’t very difficult if you understood the snake sprite above you’ll understand this:

class Pellet(pygame.sprite.Sprite):
        
    def __init__(self, rect=None):
        pygame.sprite.Sprite.__init__(self) 
        self.image, self.rect = load_image('pellet.png',-1)
        if rect != None:
            self.rect = rect

The only difference you’ll see in the pellet class is the fact that we have an optional rect parameter, which lets us place the pellet where ever we want. The pellets I’ve created aren’t the best pellets that I’ve ever seen but just like the snake.png they’ll do for this example.

We then need to load the pellet sprites in our LoadSprites function:

"""figure out how many pellets we can display"""
nNumHorizontal = int(self.width/64)
nNumVertical = int(self.height/64)       
"""Create the Pellet group"""
self.pellet_sprites = pygame.sprite.Group()
"""Create all of the pellets and add them to the 
pellet_sprites group"""
for x in range(nNumHorizontal):
    for y in range(nNumVertical):
        self.pellet_sprites.add(Pellet(pygame.Rect(x*64, y*64, 64, 64)))

Then we have to draw the pellets in out MainLoop:

self.pellet_sprites.draw(self.screen)
self.snake_sprites.draw(self.screen)
pygame.display.flip()

Now it’s time to make that snake move, to do so we’re going to have to look at the event loop in our MainLoop. ( for event in pygame.event.get():) What we are going to do is move the snake around when the arrow keys are pressed. To do that we are going to check to see if the event is a KEYDOWN event, and if it is a key down event whether the key being pressed is one of the arrow keys:

if event.type == pygame.QUIT: 
    sys.exit()
elif event.type == KEYDOWN:
    if ((event.key == K_RIGHT)
    or (event.key == K_LEFT)
    or (event.key == K_UP)
    or (event.key == K_DOWN)):
        self.snake.move(event.key)

Then we have to add a move function to our snake class that will actually move our snake:

def move(self, key):
    """Move your self in one of the 4 directions according to key"""
    """Key is the pyGame define for either up,down,left, or right key
    we will adjust ourselves in that direction"""
    xMove = 0;
    yMove = 0;
    
    if (key == K_RIGHT):
        xMove = self.x_dist
    elif (key == K_LEFT):
        xMove = -self.x_dist
    elif (key == K_UP):
        yMove = -self.y_dist
    elif (key == K_DOWN):
        yMove = self.y_dist
    self.rect.move_ip(xMove,yMove);

You’ll notice that the move function references self.x_dist and self.y_dist, these are basically two integers that I set in the snake’s __init__ function, they are the number of pixels that we want the snake to move in the x or y direction. I set mine to 5.

To move the snake we adjust it’s rect so that the next time it is displayed it will be drawn in a different direction. To do that we call the rect.move_ip function with the amount of pixels in the x and y directions to move.

Now we are going to have to add some collision detection to make our snake eat our pellets. Thankfully the spirt and group classes have built in collision detection that we are able to use:

"""Check for collision"""
lstCols = pygame.sprite.spritecollide(self.snake
                                     , self.pellet_sprites
                                     , True)
"""Update the amount of pellets eaten"""
self.snake.pellets = self.snake.pellets + len(lstCols)

We use the pygame.sprite.spritecollide function to see if our snake sprite collided with any of the pellet sprites. If they did we kill which ever pellet that was hit by passing True as the third parameter. pygame.sprite.spritecollide basically goes through all of the sprites in the group passes and sees if the sprites rect intersects with the sprit passed in as parameter one.

pygame.sprite.spritecollide also returns a list of all the sprites that were collided by our snake, so we use that to update the number of pellets that we have eaten.

The last thing that we our going to do in this tutorial is display the number of pellets that we have eaten to the user:

if pygame.font:
    font = pygame.font.Font(None, 36)
    text = font.render("Pellets %s" % self.snake.pellets
                        , 1, (255, 0, 0))
    textpos = text.get_rect(centerx=self.width/2)
    self.screen.blit(text, textpos)

This code is taken from the line by line chimp example with very few changes. Instead of telling the user to hit the chimp for cash, we’re telling them how many pellets that the snake has eaten so far. We need to put the code right right before we draw our sprites in the game loop.

That’s about it for this example, there is a bit of code in the finished “product” that I didn’t discuss but if you download the full source it the new code should be pretty self explanatory. Now this isn’t a full example by any means and probably isn’t something that you’d really want to base any game off of, but it does give you a pretty basic idea about what is required to create a game in using Python and PyGame.

If you are really interested in creating a game I’d suggest you download the full source and play around with it a bit. I’m also suggest (insist?) that you read the documentation and tutorials provided for you on the main PyGame site, if it wasn’t for them I would have been unable to write this simple tutorial.

Whew, that was a lot a typing, it’s time for me to go make some dinner and have a glass of wine.

Useful links:

If you like this post remember to digg it.

Note: Whew! Many thanks to James for finding the google cahce for me! I looked for it when I first deleted it but couldn’t fine it. Much appreciated!

Here are some alternate images that were sent to me by a kind reader named Jordan:

Well as someone who programs a lot and likes using computers creating a viedo game is always something that I’ve wanted to do. In the past I spent a lot of time learning OpenGL and actually went quite far in the creation of a simple/not-so-simple game. The game was put on hold indefinitely once real life responsibilities started to encroach on my evenings. Since then I’ve longed to try again.

Every since I heard about PyGame from import this, I thought it looked promising. It’s cross platform, which is something that is very important to me as a developer, and it lets me stratch my Python skills which is the whole reason I have this website. Here is some of the about information from the PyGame website:

Pygame is a set of Python modules designed for writing games. It is written on top of the excellent SDL library. This allows you to create fully featured games and multimedia programs in the python language. Pygame is highly portable and runs on nearly every platform and operating system.

So I decided to test my skills and create a simple game using PyGame. My first instinct was to create a cool game, but I soom realized that creating cool game right away probably wasn’t going to be the easiest thing to do so I decided to try something really simple and went with the idea of a PacMan clone, which I decided to call PyMan.

Now I assume that there have been many PacMan clones written using PyGame, but I’m honestly not trying to copy them or steal their thunder, I’m simply trying to learn how PyGame works.

The first thing that you should do is visit the PyGame site and read some of their documentation and tutorials. So I’m going to assume that you have a limited understanding of what PyGame is and how to program in Python, not too much becuase I don’t, but still a little bit.

Since this project is probably going to be a bit more complicated I’m going to use Eclipse with the PyDev plugin. I’m also going to use the gimp for all of my graphics, since it’s the only graphics program that I know how to use, now I just need to figure out how to install it on OS X.

Up until now we’ve focused on python applications that only run in the command line. For a lot of tasks this is great, but in order to be really impressive we’re going to want to create a GUI for some of our python applications.

There are a lot of python GUI toolkits out there, but for our first application we are going to use Tkinter, which is considered somewhat of a standard right now and is installed when pyhon is installed. Another nice thing about the Tkinter GUI is that it is cross platform and offers a native look and feel on *nix, Windows, and OS X.

Tkinter Example One

So lets start off with a simply “Hello World” GUI app:

#! /usr/bin/env python
from Tkinter import *

class GUIFramework(Frame):
    """This is the GUI"""
    
    def __init__(self,master=None):
        """Initialize"""
        
        """Initialize the base class"""
        Frame.__init__(self,master)
        
        """Display the main window"""
        self.grid()
        
        """Create the Text"""
        self.HelloLabel = Label(master, text="Hello World!")
        self.HelloLabel.grid()
                
if __name__ == "__main__":
    guiFrame = GUIFramework()
    guiFrame.mainloop()

Running this on OS X results in the following:

And running it in Windows Xp gives you:

As you can see the code used to create the GUI is pretty simple and easy to understand, but it is actually more complicated then need be because it uses classes. But since I’ll be using classes whenever building a GUI I thought that this was the best starting point. We start off by importing the Tkinter library into our program using this following:

from Tkinter import *

After that we create a class called GUIFramework, which is the class that will be used to great the GUI elements in Tkinter and uses the Tkinter frame class as its base. For now all the work that we do is done in the __init__ function.

There we first initialize the base class (which will initialize Tkinter) and then tell ourselves to be visible:

"""Initialise the base class"""
Frame.__init__(self,master)

"""Display the main window"""
self.grid()

To display ourselves we use the grid geometry manager, the grid geometry manager is a straight forward way to display widgets and position them. Since we have no other widgets in this example the defaults are fine, take a look at example two for for information on widget placement using the grid function.

Next is the process of creating the HelloWorld label widget, which is a member of the GUIFramework class, and setting it to be visible. It’s a good idea to make your widgets members of the class in case you need to access them later, but if you’re sure that you’ll never have to access them later, you can just create them locally.

self.HelloLabel = Label(master, text="Hello World!")
self.HelloLabel.grid()

After that all the other processing is done in the “main” section of our code where we initialize our class and tell it to enter the “mainloop”. The “mainloop” is basically the application responding to events:

if __name__ == "__main__":
    guiFrame = GUIFramework()
    guiFrame.mainloop()

Tkinter Example Two

Next I’ll show you a more complicated example, I won’t go into specifics with this one since it’s still pretty simple. But if you have any questions about the following code feel free to ask via a comment.

#! /usr/bin/env python
from Tkinter import *
import tkMessageBox

class GUIFramework(Frame):
    """This is the GUI"""
    
    def __init__(self,master=None):
        """Initialize yourself"""
        
        """Initialise the base class"""
        Frame.__init__(self,master)
        
        """Set the Window Title"""
        self.master.title("Type Some Text")
        
        """Display the main window"
        with a little bit of padding"""
        self.grid(padx=10,pady=10)
        self.CreateWidgets()
       
    def CreateWidgets(self):
        """Create all the widgets that we need"""
                
        """Create the Text"""
        self.lbText = Label(self, text="Enter Text:")
        self.lbText.grid(row=0, column=0)
        
        """Create the Entry, set it to be a bit wider"""
        self.enText = Entry(self)
        self.enText.grid(row=0, column=1, columnspan=3)
        
        """Create the Button, set the text and the 
        command that will be called when the button is clicked"""
        self.btnDisplay = Button(self, text="Display!", command=self.Display)
        self.btnDisplay.grid(row=0, column=4)
        
    def Display(self):
        """Called when btnDisplay is clicked, displays the contents of self.enText"""
        tkMessageBox.showinfo("Text", "You typed: %s" % self.enText.get())    
                
if __name__ == "__main__":
    guiFrame = GUIFramework()
    guiFrame.mainloop()

This creates the following window:

That shows this dialog when the button is pressed:

Links that helped me get through this post:

• http://www.pythonware.com/library/tkinter/introduction/
• http://infohost.nmt.edu/tcc/help/pubs/tkinter/

If you like this post remember to digg it.

Please remember to read part one and part two.

Classes and Generators

All right, now that we have split our RSS reader up into functions, we’re going to go one step further and put our code into a class.

We’re also going to do something a bit more advanced with our class and create a generator. The reason that we are going to do this is because python has such nice iteration handling and because in the future we’ll probably want to handle each RSS item individually rather then simply dumping it out to the terminal.

Generators are basically a type of iterator, except their syntax is slightly different. In fact anything you can accomplish in a generator you can accomplish in a standard iterator.

Here is an example generator that yields all the factors of the specified number:

def factors (num):
	count = 1;
	while count < = num/2:
		if (num % count == 0):
			yield count
		count = count + 1
	yield num

The special statements that make this function a generator are those two yield statements. (The second yield statement is simply to return the number itself, since a number is always a factor of itself.) The yield statement basically returns the data to the caller and the next time the function is iterated on, the function continues exactly where it left off.

You call the generator in the following way:

for res in factors(30):
	print res

With the following results:


1
2
3
5
6
10
15
30

class RSSItem:
	"""This is an RSS item, it contain all the RSS info like Tile and Description"""
	def __init__(self,title="",description=""):
		self.title = title
		self.description = description

class RSSReader:
	"""This class is an RSS reader, it should have a better docstring"""

def __init__(self,RSSUrl):
	"""Initialize the class"""
	self.RSSUrl = RSSUrl;
	self.xmldoc = self.GetXMLDocument(RSSUrl)
	if (not self.xmldoc):
		print "Error Getting XML Document!"

def GetXMLDocument(self,RSSUrl):
	"""This function reads in a RSS URL and then"""
	"""returns the XML document on success"""
	url_info = urllib2.urlopen(RSSUrl)
	xmldoc = None
	if (url_info):
		xmldoc = minidom.parse(url_info)
	else	:
		print "Error Getting URL"
	return xmldoc

def GetItems(self):
	"""Generator to get items"""
	for item_node in self.xmldoc.documentElement.childNodes:
			if (item_node.nodeName == "item"):
				"""All right we have an item"""
				rss_item = self.CreateRSSItem(item_node)
				yield rss_item

def CreateRSSItem(self,item_node):
	"""Create an RSS item and return it"""
	title = self.GetChildText(item_node,"title")
	description = self.GetChildText(item_node,"description")
	return RSSItem(title,description)

Then CreateRSS item call the constructor of the RSSItem class and returns the created class: return RSSItem(title,description)

There are only two more functions left, both of which are (as you might have guessed) very simply. This is the beauty of using functions, you get to break up the code into manageable and reusable tasks. The two functions that are left are GetChildText and GetItemText.

Where GetChildText searched through childNodes for a matching item, GetItemText simply returns an XML node’s text:

def GetItemText(self,xml_node):
	"""Get the text from an xml item"""
	text = ""
	for text_node in xml_node.childNodes:
		if (text_node.nodeType == Node.TEXT_NODE):
			text += text_node.nodeValue
	return text

def GetChildText(self, xml_node, child_name):
	"""Get a child node from the xml node"""
	if (not xml_node):
		print "Error GetChildNode: No xml_node"
		return ""
	for item_node in xml_node.childNodes:
		if (item_node.nodeName==child_name):
			return self.GetItemText(item_node)
	"""Return Nothing"""
	return ""

All that’s left is to show how we create an instance of the RSSReader class, and then use the generator to iterate through all of the RSSItems:

if __name__ == "__main__":
	rss_reader = RSSReader('http://rss.slashdot.org/Slashdot/slashdot')
	for rss_item in rss_reader.GetItems():
		if (rss_item):
			print rss_item.title
			print ""
			print rss_item.description
			print ""

Here is the code in its entirety, it call also be downloaded from here:

#! /usr/bin/env python

import urllib2
from xml.dom import minidom, Node

class RSSItem:
	"""This is an RSS item, it contain all the RSS info like Tile and Description"""
	def __init__(self,title="",description=""):
		self.title = title
		self.description = description

class RSSReader:
	"""This class is an RSS reader, it should have a better docstring"""
	
	def __init__(self,RSSUrl):
		"""Initialize the class"""
		self.RSSUrl = RSSUrl;
		self.xmldoc = self.GetXMLDocument(RSSUrl)
		if (not self.xmldoc):
			print "Error Getting XML Document!"
		
	def GetXMLDocument(self,RSSUrl):
		"""This function reads in a RSS URL and then"""
		"""returns the XML documentn on success"""
		url_info = urllib2.urlopen(RSSUrl)
		xmldoc = None
		if (url_info):
			xmldoc = minidom.parse(url_info)
		else	:
			print "Error Getting URL"
		return xmldoc
	
	def GetItemText(self,xml_node):
		"""Get the text from an xml item"""
		text = ""
		for text_node in xml_node.childNodes:
			if (text_node.nodeType == Node.TEXT_NODE):
				text += text_node.nodeValue
		return text
	
	def GetChildText(self, xml_node, child_name):
		"""Get a child node from the xml node"""
		if (not xml_node):
			print "Error GetChildNode: No xml_node"
			return ""
		for item_node in xml_node.childNodes:
			if (item_node.nodeName==child_name):
				return self.GetItemText(item_node)
		"""Return Nothing"""
		return ""
	
	def CreateRSSItem(self,item_node):
		"""Create an RSS item and return it"""
		title = self.GetChildText(item_node,"title")
		description = self.GetChildText(item_node,"description")
		return RSSItem(title,description)
	
	def GetItems(self):
		"""Generator to get items"""
		for item_node in self.xmldoc.documentElement.childNodes:
				if (item_node.nodeName == "item"):
					"""Allright we have an item"""
					rss_item = self.CreateRSSItem(item_node)
					yield rss_item
					
if __name__ == "__main__":
	rss_reader = RSSReader('http://rss.slashdot.org/Slashdot/slashdot')
	for rss_item in rss_reader.GetItems():
		if (rss_item):
			print rss_item.title
			print ""
			print rss_item.description
			print ""

This post is my continuation of my Python based RSS reader that I wrote in part one. As I said the code written in part one is not something that you would ever really want to use or maintain since it wasn’t broken up in to functions properly. So, in this part we’re going to work on breaking the old script up into functions.

Functions

Functions are defined in python using the def keyword. So if I wanted to define a function called “count” that counts from 1 to a certain number I would do so like so:

def count(nNum):

Where count is the name of the function and nNum is a parameter that is being passed into the function. If I wanted to call the function I would do so like this:

count(10)

Here is the entire code for the count function:

def count(nNum):
    x = 1
    while x &lt: nNum :
        print x
        x = x +1

Another interesting feature that python uses are Documentation Strings, these are basically comments that help document the code for you and can also be read by documentation tools like pyDoc to create formatted documentation. Since this is becoming a standard it’s a good way for other people, and you, to be able to easily see what your program does.

So for the count function we might add something like this:

def count(nNum):
    """This function prints out the numbers from 1 to nNum"""
    x = 1
    while x &lt: nNum :
        print x
        x = x +1

The Code

We will be reusing the code that was already written in Part One for this section.

Now what we need to do is break up the code that we used in part one so that it uses functions. The first thing that we are going to do is instead of always using the same location for our RSS we are going to write a function that takes an RSS url as it parameter and then attempts to retrieve it’s RSS information. We’ll call that function GetRSS:

def GetRSS(RSSurl):
	"""This function attempts to get the RSS info using RSSurl as the RSS url"""

	url_info = urllib2.urlopen(RSSurl)
	if (url_info):
		"""We have retrieve the RSS url properly, now let's parse it up"""
		xmldoc = minidom.parse(url_info)
		if (xmldoc):
			"""Loop through all children of the main document"""
			for item_node in xmldoc.documentElement.childNodes:
				if (item_node.nodeName == "item"):	
					"""If we have found an item print out the title 
					and description"""
					PrintNodeItems(item_node, ["title","description"])
		else:
			print "Error parsing url into xml"
	else:
        	print "Error! Getting URL"

You’ll notice that GetRSS is very similar to the majority of code that we had in Part One. Basically it gets the RSS XML from a specific URL, then it loops through all of the child nodes in the XML looking for item nodes. Once an node with the name of “item” is found the following new code is called:

PrintNodeItems(item_node, ["title","description"])

This line calls another new function in the code called PrintNodeItems, passing it our item node and a list of items:

def PrintNodeItems(XmlNode, items):
	"""This function prints out all children of XmlNode found in items"""
	for item_node in XmlNode.childNodes:
		if item_node.nodeName in items:
			PrintNodesText(item_node)

PrintNodeItems is a simple function that loops through all of the childNodes found in XmlNode and check to see if the childNodes nodeName is in the list items. If it is in the list, then the function PrintNodesText is called.

def PrintNodesText(XmlNode):
	"""This function prints out an XML Nodes text nodes."""
	text = ""
	for text_node in XmlNode.childNodes:
		if (text_node.nodeType == Node.TEXT_NODE):
			text += text_node.nodeValue
	"""Noe print out the text"""
	if (len(text)>0):
		print text
		print ""

PrintNodeItems is another simple function that basically loops through an XmlNode’s children and prints out all TEXT_NODES. You’ll notice that this code is identical to the code that we used to print out the “title” and “description” nodes in Part One. The difference this time is that instead of duplicating code in two spots we simple create one function that gets called twice.

Now we have the a simple main() function that calls GetRSS:

def main():
	"""Main Function"""
	GetRSS('http://rss.slashdot.org/Slashdot/slashdot')

The final step is a method for getting the ball rolling, for starting the execution. So far we’ve simply defined functions that perform tasks when called but how do we call the first function?

The answer is a simple check at the bottom of your python script to determine if the script was launched directly as a standalone script (which is all that we have been doing so far when we call out scripts via the command line):

if __name__ == "__main__":
	main()

This is basically a way for the Python script to know if it has been launched directly, if it has not been launched directly and is been instantiated in a different manner __name__ will not equal “__main__” and the main function will not be called automatically.

All right so I’ve already figured out how to write an executable script that writes out “Hello World!” to the command line, now I need to figure out how to do something interesting.

As a result I was surfing the Internet and reading some Python documentation, trying to come up with something to do but nothing seemed interesting enough or easy enough for me to do until I visited one of my favorite websites: slashdot.org.

It was there that I noticed that RSS icon that Firefox always shows me whenever I come across a website with an RSS feed (like this one.)

So I thought to myself, ‘Hmm I wonder how hard it would be to create a simple RSS reader in Python?’ Read on to discover the results.

First I had to look at Slashdots RSS XML to know what it looks like and what my code should be looking for. If you copy and paste: http://rss.slashdot.org/Slashdot/slashdot into your web browser you will be able to take a look at the XML format. The format is basically as follows:

< ?xml version="1.0" encoding="UTF-8"?>
<rdf :RDF>
	
	<item rdf:about="http://someulr">
		<title>The Title</title>
		<link>The Link</link>
		<description>The Description</description>
		
	</item>
	<item rdf:about="http://someulr">
		<title>The Title</title>
		<link>The Link</link>
		<description>The Description</description>
		
	</item>
</rdf>

For this simple RSS reader I’m only going to pay attention to each <item> and ignore all other tags. In each <item> I’m going to want to display the <title> and the <description>. That way when we run this program well see the title and descriptions of all the items on Slashdot’s main page.

Now that I knew what I wanted to do I fired up my trusty copy of gedit and began searching the web for information. By far the best site I’ve found for Python based information is the source, python.org. There is tons of documentation and information on this site, everything a new programmer needs. There may be sites out there that are better, but I haven’t found them yet.

Now that I knew what I was going to do, I needed to find some libraries to help me with my task, since there was no way I was going to do all of this myself. Fortunately for me python has many built-in libraries that make doing complicated things a lot easier.

The first thing I needed to do was create a blank shell of a script based on my first executable python script. I called my new file pythonRSS.py and edited it so that it only contained the following:

#! /usr/bin/env python

After that I needed to include (sorry for the c++ terminology) the libraries that I needed to make my RSS reader:

import urllib2
from xml.dom import minidom, Node

The first line gives me access to the library urllib2, and the second line imports the minidom and Node submodules from the xml.dom library and makes them available without the package prefix. Had I just used the following line:

import xml.dom

I would have had to reference the Node and minidom submodules using the package prefix: xml.dom.Node, instead I am able to reference them directly as Node

Now to get down to the programming business, the first piece of the puzzle that I needed was slashdot’s RSS XML, that’s pretty easy to get using the ulrlib2 library. We download the RSS feed using the urlopen function:

url_info = urllib2.urlopen('http://rss.slashdot.org/Slashdot/slashdot')

This gives us a “file-like” object stored in url_info, if we wanted to run through the XML returned line-by-line we could actually use the following:

for lines in url_info:
	print lines

But since we have a fancy XML library at our disposal manually running through the file wouldn’t make much sense.

Now that we have the RSS XML we are going to pass it to our minidom object and get it to parse it into a document:

xmldoc = minidom.parse(url_info)

The parse function parses up the XML into the Document Object Model, or DOM (as in minidom or xml.dom), and returns the document to us. For more information on this please see the Document Object Model specification.

Now that we have the document, were going to get the root node (<rdf :RDF>) and then loop through all of its children nodes looking for <item> nodes. This is actually really simply and intuitive:

rootNode = xmldoc.documentElement
for node in rootNode.childNodes:
	if (node.nodeName == "item"):

The above is something that I am definitely learning to love about python, the ability to iterate through things easily. Instead of having to redo the same iteration code for difference classes and different types (like I have to in C++) python makes this easy and intuitive using for loops or while loops.

Once we’ve found an <item> node, were just going to do that exact same thing we did above except this time we are going to look for <title> and <description> nodes:

for item_node in node.childNodes:
	if (item_node.nodeName == "title"):
		title = ""
		for text_node in item_node.childNodes:
			if (text_node.nodeType == node.TEXT_NODE):
				title += text_node.nodeValue
		if (len(title)>0):
			print title

	if (item_node.nodeName == "description"):
		description = ""
		for text_node in item_node.childNodes:
			if (text_node.nodeType == node.TEXT_NODE):
				description += text_node.nodeValue
		if (len(description)>0):
			print description + "\n"

The above code is basically just a variation of the code that we used to get the iterate through all the children of the root node. The only difference in this case is what we do when we find them, which is to iterate through all of their child nodes that are text nodes and then store that value for printing. This is the only part of the script that felt a bit weird to me, shouldn’t it be more like node.Text or something like that? Either way it works and that is basically the end of the RSS reader. Just feed it into python or make it executabe and that’s it:

$ python pythonRSS.py

All-in-all this code didn’t take that long to write, a few google searches and I was on my way. Truthfully witting this blog post took longer to write then the code did.

Please keep in mind that there are many things wrong with this code, the most obvious is that it make no use of functions to simplify the code. But this is only part one of my RSS reader and with time I will fix up the code.

Here is the code in its entirety with some comments thrown in, alternatively you could also download the code as a text file:

#! /usr/bin/env python

import urllib2
from xml.dom import minidom, Node

""" Get the XML """
url_info = urllib2.urlopen('http://rss.slashdot.org/Slashdot/slashdot')

if (url_info):
	""" We have the RSS XML lets try to parse it up """
	xmldoc = minidom.parse(url_info)
	if (xmldoc):
		"""We have the Doc, get the root node"""
		rootNode = xmldoc.documentElement
		""" Iterate the child nodes """
		for node in rootNode.childNodes:
			""" We only care about "item" entries"""
			if (node.nodeName == "item"):
				""" Now iterate through all of the <item>'s children """
				for item_node in node.childNodes:
					if (item_node.nodeName == "title"):
						""" Loop through the title Text nodes to get
						the actual title"""
						title = ""
						for text_node in item_node.childNodes:
							if (text_node.nodeType == node.TEXT_NODE):
								title += text_node.nodeValue
						""" Now print the title if we have one """
						if (len(title)>0):
							print title

					if (item_node.nodeName == "description"):
						""" Loop through the description Text nodes to get
						the actual description"""
						description = ""
						for text_node in item_node.childNodes:
							if (text_node.nodeType == node.TEXT_NODE):
								description += text_node.nodeValue
						""" Now print the title if we have one.
						Add a blank with \n so that it looks better """
						if (len(description)>0):
							print description + "\n"
	else:
		print "Error getting XML document!"
else:
	print "Error! Getting URL"

Links that helped me get through this post:

• Pyxml FAQ
• Python XML howto
• Python Documentation
• http://www.google.com
• WordPress Code Highlight Plugin

Well after reading the python documentation for a few days I decided it was time for me to write my first real script. Now I’ve written a few scripts before in the python interpreter, but I wanted to try my hand at creating some stand-alone executable file.

Now I didn’t want to go too crazy with my first script so I thought I would start off with the simplest program that everyone knows, the Hello World program. For this example I’m going to use the gedit since I already have it installed and it comes with built-in python syntax highlighting, but any standard or fancy text editor could be used in its place.

So to start gedit simply type ‘gedit’ in a terminal or find it in your gnome menu. Once gedit has started put it into pythong mode by selecting View | Highlight Mode | Scripts | Python from the menu.

Now I’m greeted with a blank gedit canvas and it’s time to write my first script. In order for a script to be executable on a Linux/Unix based OS it must start with the following line (or something similar):

#! /usr/bin/env python

Basically whatever follows the #! characters must locate the interpreter needed to execute the script file, in our case that’s the python interpreter. But instead of passing the path to the python interpreter (which we could have using something like #! /usr/bin/python) we use the env utility to search the PATH for the first executable named “python”. (PATH is an environment variable containing paths where executables can be found)

I found that there is a lot of debate about which form to use #! /usr/bin/env python or #! /usr/bin/python but for now I’m just going to stick with #! /usr/bin/env python since it appears to be the most portable.

After that I added a blank line to separate things and typed the following code:

print "Hello World!"

Not very complicated but it will get the job done. You’ll also notice, if you are working with gedit, the nice syntax highlighting. After that I saved my files as helloworld.py.

Now to execute this file we can open up a terminal, browse to the directory containing our helloworld.py file and type:

$ python helloworld.py

But that doesn’t make much sense since we went through all that trouble to type the #! line at the beginning of our file. So in order to make use of that we have to tell the system that helloworld.py is an executable file, to do that we need to modify its properties using chmod.

To do that we simply type:

$ chmod +x helloworld.py

Now the system knows that helloworld.py is an executable file and in order to run it we simple have to type the following in a terminal:

$ ./helloworld.py

(The ./ part of the above simple tells the terminal that we are looking in the current directory.)

Not very exciting or difficult but at least it worked!