From scripting to object-oriented Python programming


Python has begun soaring in popularity in recent years, and part of the reason is that the language is very flexible, yet incredibly powerful. Python can be used for systems administration, Web development, GUI programming, scientific computing, and more. The main aim of this article is to introduce people who are used to scripting procedural code in Bash, PHP, or some other language, and to assist them in moving into object-oriented Python developing. This rising popularity of Python means that developers currently using other programming languages might be called upon to do some of their projects in Python, in addition to their favorite language.

Procedural programming certainly has its place, and it can be a highly effective way to solve a problem. On a very basic level, procedural programmming can be defined as a list of instructions, and Bash and PHP often are written in such a manner. Because of Python’s popularity, though, PHP and Bash scripters who are Web developers or systems administrators are getting thrown into situations in which they have to learn both object-oriented programming and Python at the same time.

Object-oriented can be a lot to digest at once, so this article takes on procedural Bash and PHP scripts, and first converts them to procedural Python. As a final step, they get converted into the end goal of object-oriented Python. The article concludes by touching on a few advantages of object-oriented Python, and then finally with some disadvantages in which either procedural or functional programming might be a better fit. By the end of this article, Bash or PHP programmers should be able to jump into object-oriented Python projects without fear.

Writing a disk-monitoring function in PHP and Bash

While PHP is mostly meant to be run inside a browser, it can also perform system calls by way of the exec function. The first example, written in PHP, will capture the output of the shell command “df -h,” place the output into an array, and then examine each line of output against a regular expression. If the line matches the regular expression, then you print out that line. If you want to run this example from home, you will only need to call this script index.php and place it in the served-out directory of an Apache/mod_php server.

PHP disk-monitoring example


//Analyzes disk usage
//Takes regex pattern and message
function disk_space( $pattern="/2[0‑9]%/", $message="CAPACITY WARNING:" )

    exec(escapeshellcmd("df ‑h"),$output_lines,$return_value);
    foreach ($output_lines as $output) {
        if (preg_match( $pattern, $output ))
            echo "<b>$message</b> $output <br />";




If you run this Web page in a browser, you get the following results:

        CAPACITY WARNING: /dev/sda1 3.8G 694M 2.9G 20% /

Looking at the code, you can see that the regular expression pattern was set to match a line that contained 20-29%. This could be modified easily to fit some other flag, such as 90-99%, as 20% is a very low disk capacity.

Next let’s look at doing this in a Bash function. In Bash, the problem is much easier to solve because you are really processing system calls. In this example, you don’t even need to use an array or a regular expression library, because a pipe to grep is much easier. Setting default parameters for functions in Bash are always a bit verbose, though.

Bash disk-monitoring example

#!/usr/bin/env bash

#function flags disk usage takes pattern and message optionally
function disk_space ()
    #checks for pattern parameter
    if [ "$1" != "" ]; then

    #checks for message parameter
    if [ "$2" != "" ]; then
        message="CAPACITY WARNING:"

    #looks at output for pattern to flag
    output_lines=df ‑h | grep $pattern
    if [ "$output_lines" != "" ]; then
        echo $message $output_lines

#example of optional parameters usage
#disk_space 9[0‑9]% ALERT:


When you run this script, you get the same output, so you can skip showing it. What you can correlate from the PHP version of the script and Bash version is that this procedural code does in fact run like a set of instructions. It is almost as if the computer is a small child, and you are telling the child how to do something like tie his shoes for the first time. Before you get into thinking in the “Object-Oriented Paradigm” in Python, let’s look at making a procedural version of this same function in Python.

Python disk-monitoring example

from subprocess import Popen, PIPE
import re

def disk_space(pattern="2[0‑9]%", message="CAPACITY WARNING:"):

        #takes shell command output
        ps = Popen("df ‑h", shell=True,stdout=PIPE, stderr=PIPE)
        output_lines = ps.stdout.readlines()
        for line in output_lines:
            line = line.strip()
                print "%s %s" % (message,line)


Looking over the procedural Python version of our code, it quite similar to both the Bash and PHP versions. With Python, the subprocess module handles making the system call to the shell command, and puts it into a list, called in array in Bash or PHP. Much like the PHP version, I then iterate over the items in the list that are lines of the standard out of the command. I look for a regular expression that makes the pattern I am looking for, and then print the line of the disk report with a special message that gets injected. This is a classic example of how a top-down scripting problem can be solved, but in the next section you change your approach completely and think in terms of objects.

From procedural to object-oriented Python

Procedural programming is often the most natural style of programming for a beginning developer, and it is also highly effective for many problems. On the other hand, object-oriented programming can be a very useful way to create abstraction, and thus resuable code. Often procedural code can show cracks in its foundation when a project approaches a certain level of complexity, though. Let’s jump right into an object-oriented version of the last example and see how that changes things.

Object-oriented Python disk-monitoring script

#!/usr/bin/env python from subprocess import Popen, PIPE import re class DiskMonitor(): """Disk Monitoring Class""" def init(self, pattern="2[0-9]%", message="CAPACITY WARNING", cmd = "df -h"): self.pattern = pattern self.message = message self.cmd = cmd def diskspace(self): """Disk space capacity flag method""" ps = Popen(self.cmd, shell=True,stdout=PIPE,stderr=PIPE) outputlines = ps.stdout.readlines() for line in outputlines: line = line.strip() if,line): print "%s %s" % (self.message,line) if _name == "__main": d = DiskMonitor() d.disk_space()

In looking at the object-oriented version of the code, you can see that the code becomes more abstract. Sometimes too much abstraction can lead to design problems, but in this case it allows you to separate the problem into more reusable pieces. The DiskMonitor class has an init method where you define your new parameters, and the disk_space function is now a method inside of the class.

With this new style, you can easily reuse and customize things without changing the original code, as is often necessary with procedural code. One of the more powerful, and also overused, aspects of object-oriented design is inheritance. Inheritance allows you to reuse and customize existing code inside a new class. Let’s see what that might look like in this next example.

Object-oriented Python disk-monitoring script using inheritance

#!/usr/bin/env python from subprocess import Popen, PIPE import re class DiskMonitor(): """Disk Monitoring Class""" def init(self, pattern="2[0-9]%", message="CAPACITY WARNING", cmd = "df -h"): self.pattern = pattern self.message = message self.cmd = cmd def diskspace(self): """Disk space capacity flag method""" ps = Popen(self.cmd, shell=True,stdout=PIPE,stderr=PIPE) outputlines = ps.stdout.readlines() for line in outputlines: line = line.strip() if,line): print "%s %s" % (self.message,line) class MyDiskMonitor(DiskMonitor): """Customized Disk Monitoring Class""" def diskspace(self): ps = Popen(self.cmd, shell=True,stdout=PIPE,stderr=PIPE) print "RAW DISK REPORT:" print if __name == "__main": d = MyDiskMonitor() d.disk_space()

If you run this version of the script that uses inheritance, you get the following output:

Filesystem            Size  Used Avail Use% Mounted on
/dev/sda1             3.8G  694M  2.9G  20% /
varrun                252M   48K  252M   1% /var/run
varlock               252M     0  252M   0% /var/lock
udev                  252M   52K  252M   1% /dev
devshm                252M     0  252M   0% /dev/shm

This output is very different from the previous — flagged — version, because it is just the unfiltered results of df -h with a print statement injected at the top. You were able to change the intent of the disk_space method completely by overriding the method in the MyDiskMonitor class.

The Python magic that allowed you to reuse the attributes from the other class were this “MyDiskMonitor(DiskMonitor).” You only needed to place the name of the previous class inside of paranethesis when you defined the name of the new class. As soon as that happens, you instantly gain access to the other classes attributes to do with as you wish. The fun doesn’t stop there, either. You could further customize the new class by adding another method, perhaps called disk_alert(self), which would e-mail flagged messages. This is the beauty of object-oriented design; it allows experienced developers to constantly reuse code they have written, and save themselves quite a bit of time.

There is a dark side to object-oriented programming, as well, unfortunately. All of this abstraction comes at a cost of complexity, and if abstraction is taken far enough, it can get downright ugly. Because Python supports multiple inheritance, abstraction can be taken to a level of complexity that is quite unhealthy. Can you imagine having to look at several files to just write one method? Believe it or not, this does happen, and it represents the unfortunate reality of one side of object-oriented programming.

One alternate to object-oriented programming is functional programming, and Python offers resources to program in a functional style, as well as object oriented and procedural. In the final example, let’s take a look out how to write our now tiresome disk-monitoring code in a functional style.

Functional-style Python disk-monitoring script

from subprocess import Popen, PIPE import re def disk_space(pattern="2[0-9]%", message="CAPACITY WARNING:"): #Generator Pipeline To Search For Critical Items ps = Popen("df -h", shell=True,stdout=PIPE, stderr=PIPE) outline = (line.split() for line in ps.stdout) flag = (" ".join(row) for row in outline if, row[-2])) for line in flag: print "%s %s" % (message,line) disk_space()

If you look at this last example, it is much different from anything else you have seen in this article. If you walk through the code line by line, you can first start with something you have seen before in “ps” variable. The next two lines of code-use generator expressions to handle the file object ps.stdout and to parse it and search it for the lines you are looking for. If you cut and pasted these lines of code into an interactive Python shell, you would see that outline and flag are both generator objects if you printed them. Generator objects come with a next method attached to them, and as such, allow you “pipeline” actions together.

The outline line strips the newline character from one row, and then passes that one row down to the next generator expression, which searches for a regular expression match, in each row, one at a time, and then passes the output to flag. This type of compact workflow can be an alternative to the object-oriented programming style, and it is quite interesting. There are drawbacks to this style as well, though, as the conciseness of the code can lead to errors that are difficult to debug unless each line of code is executed independantly. Functional programming also stretchs the brain, as it makes you think of solving problems by chaining solutions together. This is quite different from either procedural or object-oriented styles.


This article was somewhat experimental, as it went from Bash and PHP, to procedural, object-oriented, and finally functional Python using the same basic code. I hope it illustrated that Python is a very flexible and powerful language that developers in other programming languages can also learn to appreciate. As Python continues to grow in popularity, it will become more important for other developers to learn about in addition to their language of choice.

Two of the largest recent growth areas of Python are Web development and systems administration. In terms of Web development, developers in PHP may soon have to make weekly choices about which project makes more sense in Python, and which project makes more sense in PHP. For systems administrators, Bash and Perl scripters,are often being asked to look at doing some of their projects in Python. Partly this is out of choice, and partly because many vendors are offering Python API’s for their products. Having a bit of Python in your toolkit can never hurt anyone.