After looking into the OpenERP/OpenObject project (which looks pretty neat), I realized their complex GUI was written in Python. After a little investigation, I figured out they were using PyGTK (Python bindings for the GTK widget toolkit) and Glade (a GUI builder).

Combining Python, PyGTK and Glade seems to lead to a workable solution for creating GUIs for Python applications. There’s a nice tutorial on how all these pieces fit together here.

Before we discuss the pros and cons of  C++, here’s a factoid: C++ is based on C, which was written in 1972 (approximately 37 years ago) at Bell Labs for use with the UNIX operating system.

Here are a few of the things I don’t like about C++:

• No garbage collection
• Poorly implemented generics
• Local objects (there’s a reason no other language has them)
• Real pointers (most languages have replaced pointers with “references”)
• A tiny standard library (most languages have huge standard libraries, with Python and .NET being some of the best)

There are several libraries like Boost and QT, which provide an object model, handle garbage collection, and remove the need for pointers, making C++ more developer friendly. However, we’re talking about what comes in the box, not all the accessories that you can add after.

C++ is compiled directly to machine code, making execution faster than languages that compile to a byte code (like C#, Java and Python (which does compilation on the fly)) and require a runtime.

The real question is, does this really matter anymore? Most clients have duel or quad core processors, with clock speeds in excess of 2GHz, and servers have two to eight times the power of clients.

In my opinion, the answer is a definitive no. Why? Hand written assembly is faster than the machine code generated by the C++ compiler, but modern applications aren’t written in assembly. Does it matter anymore? Not really, thanks to Moore’s law.

Since we were able to move beyond assembly, I think we can safely shelve C++, and move on to languages like C#, Java and Python for 90% of software development.

I haven’t found a good use for a grid personally, but I found a nice piece software to setup a SSI (Single System Image, basically means one OS running on multiple machines) grid, and a nice tutorial.

If I had a grid running MySQL, the 35 million row DB table I use would probably search pretty fast.

In other news, Panda3D (a game engine, usable from C++ or Python) looks like it has excellent documentation, something that a lot of engines are lacking. I’m also wondering if I should buy a Mac now that Snow Leopard is out (that’s when I said I’d buy one)… I wonder if I’d really use the Mac applications…

Python doesn’t really support traditional access modifiers, and C# doesn’t offer true multiple inheritance (you can inherit from one class and multiple interfaces).

While C++ offers the most OOP features of the three languages, it has some disadvantages. If you compare C++ to modern languages like Python, Ruby or C#, C++ starts to show it’s age. Further more, given a small application, it’s usually much faster to write it in Python than in any C language.

The question ultimately becomes, are all the OOP features in C++ really needed in every day development? For small projects, most likely, no. For large projects with a team of developers, maybe.

In most C languages, the “self” parameter is hidden (an implicit parameter), and is usually accessible through a reserved word (e.g this is C++ and C#).

Which is better? Python’s upfront approach is nice for beginners, but for experienced programmers, it creates some extra work.

This particular module needed the /MANIFEST linker option, and the windows setup script didn’t work properly.

After fixing both of those problems, I present the compiled binaries (MySQL-python-1.2.3c1.win32-py2.6.exe (191)), and the fixed setup_windows.py (mysql-python-setup_windows.py (198)), if you want to compile mysql-python yourself.

There are two types of loops in Python, the for loop, and the while loop. The for loop is one of the easiest ways to process data. Let’s take a look:

# Define a list
a = ['test1', 'test2', 'test3']

# In the first iteration (pass through the loop)
# the value 'test1' will be assigned to the variable temp1
#
# In the second iteration, it will be assigned the value 'test2'
for temp in a:
    print temp

The syntax of a for loop is as follows:

# Define a list
a = ['test1', 'test2', 'test3']

for tempVariableName in collectionToLoopThrough:
    print 'do stuff here with the temp variable here'

The other type of loop is the while loop:

# Define a list
a = ['test1', 'test2', 'test3']

# Loop control variable
i = 0

# Store the length of the list a
max = len(a)

while i < max:
   print a[i]
   i += 1

The expression that follows the word while is the loop test. If true, the loop will run, and if false, it will not. The loop test is tested when the loop is first entered, and at the beginning of each iteration.

Loops in Python offer a lot of other control features, which you can read about here.

If you’ve been following the tutorials, you should have enough knowledge to learn the other features of Python on your own. If you have questions, the best place to go is either the Python documentation, especially the Python tutorial, or Google (if you wanted to write program that finds and replaces words in files in a given directory, you might search for “read file python”, “file io python”, “string replace python”).

I just finished a little backup script, which copies files only if they are newer than the copy in the destination folder, or if they don’t exist in the destination yet.

First of all, if we’re not doing object oriented programming, what kind of programming are we doing? Most likely, procedural. Procedural programming uses multiple functions to accomplish a task. Object oriented programming is the idea of packaging related variables and functions together in a reusable container called a class. Technically, OO is about modeling real world objects.

For example:

class Shower:
     cold_waterrate = 0
     hot_waterrate = 0
     door_state = 0

     def UpdateWaterRates(self):
         API.SetColdRate(self.cold_waterrate)
         API.SetHotWaterRate(self.hot_waterrate)

    def UpdateDoorState(self):
         API.SetDoorState(door_state)

The above code defines a class called Shower with data (cold_waterrate, hot_waterrate and door_state) and function members (UpdateWaterRates and UpdateDoorState).

Defining a class creates a blueprint. Basically, the instructions that are used to create an instance of the class.

You might be wondering what the self parameter is in the methods. self is a special word in Python that is automatically set to be the object that it was called on. Without a self parameter, we wouldn’t be able to access class data from inside our function. We’ll explore this again later.

In order to use our new class, we need to create an instance of the class. When an instance is created, the class definition is used to construct an object. So, what’s an object? Your monitor is an object, as is your mouse, keyboard and desk. Let’s take the mouse for example; It has blueprints or plans that are used to construct each mouse object, like the one on your desk.

Let’s create an instance of the Shower class:

shower1 = Shower()

On line 1, I call the Shower class (called the “The instantiation operation” (source)), which gives me a new instance of the Shower class, and I store that instance in shower1.

shower1 now contains a Shower object. I can access it like this:

# Like many languages, Python uses object.memberName
# to access members of a class

# Setting class data
shower1.cold_waterrate = 15
shower1.hot_waterrate = 20
shower1.door_state = 0

# Calling class methods
shower1.UpdateDoorState()
shower1.UpdateWaterRates()

When I call shower1.UpdateDoorState, I don’t specify a value for the self parameter. It is automatically passed shower1. Technically, that’s not what really happens. The Python language converts the method call “shower1.UpdateDoorState()” to “Shower.UpdateDoorState(shower1)”.

Many classes have a special initial state that’s needed for them to work correctly. Python provides a special method that we can define called “__init__”.

Here’s what the shower class looks like with an “__init__” method:

class Shower:
     cold_waterrate = 0
     hot_waterrate = 0
     door_state = 0

     def __init__(self):
         self.UpdateWaterRates()
         self.UpdateDoorState()

     def UpdateWaterRates(self):
         API.SetColdRate(self.cold_waterrate)
         API.SetHotWaterRate(self.hot_waterrate)

  def UpdateDoorState(self):
         API.SetDoorState(door_state)

Basically, this “__init__” method will make sure the water rates and door state are set to their defaults by calling the API methods when an instance is created.

Suppose we wanted to add parameters to the Shower() call? We can add them in the init method:

     def __init__(self, cold_water, hot_water, door):
         self.cold_waterrate = cold_water
         self.hot_waterrate = hot_water
         self.door_state = door

         self.UpdateWaterRates()
         self.UpdateDoorState()

Then, we’d create instances like this:

shower1 = Shower(15, 20, 0)

When you call “Shower(param1, param2, param2, etc)”, your parameters go to the init method. In the above case, init would have 15 in cold_water, 20 in hot_water and 0 in door.

Lots of things are objects

In Python, lots of different things are treated as objects. Class instances, functions, collections, etc.

Let’s look at an example function definition:

def Foo():
    print "Foo."

In the function definition, we associate the name Foo with the function that we are defining. In Python, even though Foo is a function, it’s really an object, which can be very useful. Let’s say I want to have a function called when a task gets completed by another function. It’s easy to pass the function I want called to the worker function:

def Foo():
    print "Foo."

def DoWork(callback):
    print "Doing work..."
    callback()

DoWork(Foo)

When DoWork calls it’s parameter callback, it will be calling Foo. We can also create additional names that point to the same function:

def Foo():
    print "Foo."

Bar = Foo

# The below statements do the same thing
Foo()
Bar()

Most of the other things in Python that are treated as objects make sense, and I won’t cover them here.

Object copies

One thing to be really careful with is copying objects. Python does NOT do this for you.

If you were to do:

class Foo:
    pass

temp1 = Foo()
temp1.something = 25

# This makes temp2 another name for the instance that
# temp1 points to
temp2 = temp1

# This will overwrite temp1.something
temp2.something = 50

If you wanted to copy the object temp1 into temp2:

temp2 = Foo()
temp2.something = temp1.something

The same holds true for lists (since they’re objects too):

temp1 = ['item1', 'item2']

# This makes temp2 another name for the list that
# temp1 points to
temp2 = temp1

temp2[0] = 'itemmagic'
# temp1[0] is now 'itemmagic'

Related topics

Something you might be wondering about:

class Foo:
    pass

What was that “pass” statement? Literally, it means, do nothing. Execute will “pass” by the “pass” statement. The reason I used it was to create an empty container class, into which I could store data.

In the next tutorial, we’ll examine a real Python script.

First, what is coding style? It defines how code should be formatted, how to name different code elements, where white space should be in expressions, how code should be documented, etc.

Now you might be wondering, why should I follow a coding style? By following PEP 8, Python’s official coding style, you will make your code more readable, both for yourself, and other Python developers.

When code is easy to read, it makes the code easier to understand, and easier to debug.

If you work with other programmers, and you don’t follow a decent coding style, they will be at your door with pitch forks and torches