Elegant XML parsing using the ElementTree Module

Mark Mruss

Note: This article was first published the October 2007 issue of Python Magazine

XML is everywhere. It seems you can’t do much these days unless you utilize XML in one way or another. Fortunately, Python developers have a new tool in our standard arsenal: the ElementTree module. This article aims to introduce you to reading, writing, saving, and loading XML using the ElementTree module.

  1. Introduction
  2. Reading XML data
  3. Listing 1
  4. Listing 2
  5. Reading XML Attributes
  6. Writing XML
  7. Listing 3
  8. Writing XML Attributes
  9. Reading XML Files
  10. Writing XML Data to a File
  11. Reading from the Web
  12. Conclusion

Continue reading Elegant XML parsing using the ElementTree Module

PyLan a GTD todo application written in python and PyGTK – part four context menus!

PyLan Four

Hello welcome to the fourth installment of the PyLan tutorial. This will be a quick tutorial to introduce one feature: context (or popup) menus. I’ve had many questions regarding this so I thought I would take a quick stab at it.

If you want to follow along with the code in detail, and have not done so already, you should read part one, part two and part three of this series.

You can download the full source to this tutorial here.

Python GTD pyGTK

Continue reading PyLan a GTD todo application written in python and PyGTK – part four context menus!

Creating a game using python and Silverlight 1.1

This tutorial assumes that you have a passing understanding of Silverlight and Microsoft’s .NET technologies. If you do you should have no trouble understanding everything in this code, and chances are you will understand some of it more then I do!

But to start it off here is a little bit of information straight from Microsoft’s website:

Silverlight is a new Web presentation technology that is created to run on a variety of platforms. It enables the creation of rich, visually stunning and interactive experiences that can run everywhere: within browsers and on multiple devices and desktop operating systems (such as the Apple Macintosh). In consistency with WPF (Windows Presentation Foundation), the presentation technology in Microsoft .NET Framework 3.0 (the Windows programming infrastructure), XAML (eXtensible Application Markup Language) is the foundation of the Silverlight presentation capability.
This white paper will step you through the basics of Silverlight and how you can use the Microsoft stack of tools, including Microsoft Expression Blend, Microsoft Visual Studio 2005, and XAML to build rich graphical sites. First, let’s take a primer on the background leading up to Silverlight and where it stands on the development landscape.

What we are going to do is create a simple game with falling targets that they user has to click on in order to “hit” them. Each time they hit a target they will get a point and another target will be created.

Python silverlight

You can try the “finished” product out here: http://www.learningpython.com/silverpy/index.htm

Continue reading Creating a game using python and Silverlight 1.1

PyLan a GTD todo application written in python and PyGTK – part three

PyLan three

Hello welcome to the long-time-coming third article in this tutorial. I apologize to everyone (anyone?) that was waiting for it. I have been very busy as of late and have had much of my time taken up by a few other python projects, that I hope to be able to show you all soon.

If you want to follow along with the code in detail, and have not done so already, you should read part one and part two of this series.

Python GTD pyGTK

You can download the full source to this tutorial here.

This tutorial will teach you the following things:

  1. How to construct a simple theme engine, or at least how I would, hopefully it will give you some ideas!
  2. How to display icons in a gtk.TreeView
  3. How to catch the selection event in a gtk.TreeView.
  4. How to enable or disable widgets.
  5. How to remove the selection from a gtk.TreeView if the user clicks on the gtk.TreeView but not on a tree item.

Continue reading PyLan a GTD todo application written in python and PyGTK – part three

PyLan a GTD todo application written in python and PyGTK – part two

PyLan two

This is part two of the PyLan tutorial series, if you want to follow along with the code in detail, and have not done so already, you should read part one of this series.

In this tutorial I will go over the following items:

This tutorial is organized into the following sections:

  1. The GUI
  2. The todo.Task Object
  3. Adding a todo.Task object
  4. Showing the Calendar window
  5. Editing todo.Category and todo.Task items
  6. Pango markup in the gtk.TreeView
  7. Conclusion

Python GTD pyGTK

You can download the full source to this tutorial here.

Continue reading PyLan a GTD todo application written in python and PyGTK – part two

PyLan a GTD todo application written in python and PyGTK – part one


All right, many of you have probably heard of, or read, David Allen’s book Getting Things Done if not it’s a pretty interesting book about how to organize the things in your life.

As I was reading it I thought that a simple todo list could be created using Python and PyGTK pretty easily, so I decided to create the application and write a tutorial surrounding it. Since the actual application is quite large I have decided to break it up into a series of tutorials, each highlighting a few specific tasks. The full goal of this series is to show everything that is required when creating a python/PyGTK based application, for the GUI setup all the way to distribution.

These tutorials assume that you have a basic knowledge of python and PyGTK. If you have not already done so it is recommended that you take a look at some of my previous PyGTK based tutorials as I will be glossing over much of that which is explained there:

PyLan – part one

Python GTD pyGTK

So the application that we will be creating will be called PyLan, pronounced: plan. In brief it will be used to create a tree of tasks that can be organized into categories and subcategories.

You can download the full source to this tutorial here.

Part one of this tutorial will introduce you to the idea of the application and create the basic shell for it. It will outline the following:

Continue reading PyLan a GTD todo application written in python and PyGTK – part one

Creating a GUI using Python, WxWidgets, and wxPython

After putting off this tutorial for as long as I possibly could (I’m not sure why) I have finally decided to buckle down and learn how to use WxWidgets using the WxPython Python bindings.


Getting WxWidgets and WxPython installed on my Debian Linux computer was as simple as installing the python-wxgtk2.6 Debian package. If you have any problems installing wxPython on your computer I suggest that you follow the instructions in the wxPython FAQ. Or you can follow the Getting Started instructions on the wxPython wiki.

Setting up the Window

Now that you have WxWidgets and WxPython installed it’s time to write a quick wxPython application. Start up your favourite python editor and enter the following:

[code lang=”python”]
#!/usr/bin/env python

import wx

if __name__ == “__main__”:
app = wx.App()

Save the file as wxHello.py, or whatever you would like. You can run the file if you want but you won’t actually see anything. The first thing that you will notice is that we import wx, this will import wxPython into your program.

The next thing that we do is create a wx.App and then call it’s MainLoop function, which starts the main GUI event loop. Here is a description of the wx.App class from the wxPython documentation :

The wx.App class represents the application and is used to:

  • bootstrap the wxPython system and initialize the underlying gui toolkit
  • set and get application-wide properties
  • implement the windowing system main message or event loop, and to dispatch events to window instances
  • etc.

Every application must have a wx.App instance, and all creation of UI objects should be delayed until after the wx.App object has been created in order to ensure that the gui platform and wxWidgets have been fully initialized.

Normally you would derive from this class and implement an OnInit method that creates a frame and then calls self.SetTopWindow(frame).

Notice the last little instruction there:

Normally you would derive from this class and implement an OnInit method that creates a frame and then calls self.SetTopWindow(frame).

So that is our next step, derive a class from wx.App and override the OnInit member:

[code lang=”python”]
#!/usr/bin/env python

import wx

class wxHelloApp(wx.App):
“””The wx.App for the wxHello application”””

def OnInit(self):
“””Override OnInit to create our Frame”””
frame = wx.Frame(None, title=”wxHello”)
return True

if __name__ == “__main__”:
app = wxHelloApp()

Now instead of creating a wx.App we create a wxHelloApp that is derived from a wx.App. All that the wxHelloApp does is override the OnInit() function. In that function it creates a wx.Frame (from the wxWidget docs):

A frame is a window whose size and position can (usually) be changed by the user. It usually has thick borders and a title bar, and can optionally contain a menu bar, toolbar and status bar. A frame can contain any window that is not a frame or dialog.

When we create the frame we set its parent to be nothing, and it’s title to be “wxHello”. If you run the wxHello.py file now you will be greeted by the following:

Python wxPython

Continue reading Creating a GUI using Python, WxWidgets, and wxPython

TextWidget – A simple text class for PyGame


All right, this is just a little tutorial about working with text in pygame. Now, this isn’t the only way to work with text, there are many other methods to do this, in fact much of the time you’ll probably end up using images for interactive text. So this is mainly meant to serve as a informative guide to using the text features in PyGame, and how you might want to implement them.

The TextWidget object discussed in this tutorial can be used to make something that looks like this (but you’d probably want to use better looking colours):

The full source and necessary files for this tutorial can be downloaded here.

So, in order to make this easy to use and very reusable we’re going to create a class called TextWidget in a file called TextWidget.py. The top of the file is full of the standard python initialization:

[code lang=”python”]
#! /usr/bin/env python

import pygame


We import pygame and then we set a define TEXT_WIDGET_CLICK , which will be used later on as the event type when the TextWidget is clicked on.

The next thing to do is define the actual class:

[code lang=”python”]
class TextWidget(object):

Now the astute among you will recognize that this is a “new-style” python class (i.e. it’s base class is the object class) rather then a classic class. I did this for two reasons:

  1. I wanted to be able to control what happens when people set values in the class. So, for example, if you set the size of the font to be something, I wanted the display to automatically adjust to reflect the new size.
  2. I haven’t really used new-style classes before so I thought I’d try them out.

Note: If you are unfamiliar with properties or new-style classes you might want to give this a read:

Continue reading TextWidget – A simple text class for PyGame

WordPy 0.2 – Using XML to Save and Load Data

All right, so we have our base WordPy application running, so let’s try to extend it a bit more by letting you load and save blog posts to and from an xml file. Please note that this tutorial simply shows one method of saving and loading data using xml, there are many different methods and this method was chosen for its simplicity.

If you are unfamiliar with the first WordPy tutorial you should probably read it fist in order to have a better understanding of some of what happens in this tutorial.

You can download the complete code for this tutorial here.


The first thing we need to-do is open up the wordpy glade project and make some changes:

  1. We’ll start off by adding another item to our VBox in Glade. You can do this by holding down shift and clicking on the WordPy window until you see the GTKVBox come up in the properties window. Then simply change it’s size value from 4 to 5.
  2. In the empty space add a menu bar. Then on the Packing tab of the menu bar’s properties set the position to be zero, so that the menu is at the top of the window.
  3. Then edit the menu so that only the File, Edit, and Help menu’s remain.
  4. Add handlers to each of the files menu items: on_file_new, on_file_open, on_file_save, on_file_save_as

GLADE Window PyWine

The Code

That’s it for editing the GUI, now we have to go and edit the code. The first step is to connect all of the menu events with our code:

[code lang=”python”]
dic = {“on_wndMain_destroy” : self.quit
, “on_btnBold_clicked” : self.on_btnBold_clicked
, “on_btnItalic_clicked” : self.on_btnItalic_clicked
, “on_btnLink_clicked” : self.on_btnLink_clicked
, “on_btnBlockQuote_clicked” : self.on_btnBlockQuote_clicked
, “on_btnDel_clicked” : self.on_btnDel_clicked
, “on_btnIns_clicked” : self.on_btnIns_clicked
, “on_btnImage_clicked” : self.on_btnImage_clicked
, “on_btnUnorderedList_clicked” : self.on_btnUnorderedList_clicked
, “on_btnOrderedList_clicked” : self.on_btnOrderedList_clicked
, “on_btnListItem_clicked” : self.on_btnListItem_clicked
, “on_btnCode_clicked” : self.on_btnCode_clicked
, “on_btnMore_clicked” : self.on_btnMore_clicked
, “on_btnSettings_clicked” : self.on_btnSettings_clicked
, “on_btnpost_clicked” : self.on_btnpost_clicked
, “on_file_new” : self.on_file_new
, “on_file_open” : self.on_file_open
, “on_file_save” : self.on_file_save
, “on_file_save_as”: self.on_file_save_as}

[code lang=”python”]
def on_file_new(self, widget):

def on_file_open(self, widget):

def on_file_save(self, widget):

def on_file_save_as(self. widget):

Continue reading WordPy 0.2 – Using XML to Save and Load Data

IronPython Hello World Tutorial

As some of you may have heard IronPython 1.0 has been released. If you don’t’ know what IronPython is, it’s:

a new implementation of the Python programming language running on .NET. It supports an interactive console with fully dynamic compilation. It is well integrated with the rest of the .NET Framework and makes all .NET libraries easily available to Python programmers, while maintaining full compatibility with the Python language.

The cool thing about IronPthon is that it also works with the Windows Presentation Foundation which will be released when Windows Vista is released and available for Windows XP and Windows Vista.

I thought that this was pretty interesting so I thought I’d try playing with it and write a quick tutorial.


For this tutorial you need the following:

For this tutorial I has assumed that you have installed IronPython to:



Once you have everything installed load up Microsoft Expression Interactive Designer (MEID from now on) or sparkle as it used to be called and close the Welcome Screen. You might notice that MEID is very slow, on my system the program just seems to c-r-a-w-l, but it does allow you to do some pretty neat things.

After it has finished loading and clearing the Welcome screen you should be left with a blank canvas. The canvas is too large for the Hello World program we’re creating so resize the canvas until it has reached a suitable size.

Then with the canvas selected, select the Background item in the Appearance pallet and set the background of the canvas (our window) to something suitable using the colour picker below. I selected a nice dark shade of green.


Continue reading IronPython Hello World Tutorial