The Quick Answer: For the most accurrate time elapsed, use the time module and make 2 time.time() objects.  The difference between these objects is the time elapsed. Do not use time.clock().

The Whole Story

Its pretty basic: I have certain parts of a large python script (that happen to access a MySQL database) that I would like to keep track of how long it took them to execute.

Wrong Answers

Initially, I read on a PLEAC-Python article, Dates and Times (which really is a great overview of Python’s time module), about some ways to use Python’s time module.  That article suggests that all you need to do is:

#-----------------------------
# High Resolution Timers

t1 = time.clock()
# Do Stuff Here
t2 = time.clock()
print t2 - t1

# 2.27236813618
# Accuracy will depend on platform and OS,
# but time.clock() uses the most accurate timer it can

For one of my projects, that worked fine. But then I had a bigger script that used a lot of MySQL via the Python module MySQLdb, and I would look at my script’s run time after leaving, and the times looked short… but not too short. Eventually after running a script that took a 7 hour sleep and then some to run — but the script reported only taking an hour or so — I knew something was wrong.

Only timing the work of Python?

It seemed as if using the time.clock() approach was only timing what Python (as opposed to MySQL?) was doing.  I created this test script

import time

yearstart = time.clock()
print yearstart

for x in range(0, 1000000):
    z = x + 6

yearend = time.clock()
print yearend
elapsed= yearend-yearstart
min = elapsed/60

print elapsed, min

And I didn’t find a problem, but my script still did. I was wanting to time an event of a known length, and so I found out about the time.sleep() function from the aforementioned article. I incorporated the sleep() function:

import time

yearstart = time.clock()
print yearstart

time.sleep(3)

yearend = time.clock()
print yearend
elapsed= yearend-yearstart
min = elapsed/60

print elapsed, min

and ran the script. You would expect to see 3 seconds as a result, or at least something close, but my output was:

0.03
0.03
0.0 0.0

That was funny (although I didn’t laugh) because yearend was not supposed to sample the clock() until after the sleep. I still don’t know why this does this, but it does. I am sure this has its uses, but this was not the use I was wanting.

Use time.time()

Still referencing the PLEAC-Python article, I tried using time.time(), which is supposed to just be the seconds since that day in 1970 and compared it to the time.clock() approach:

import time

yearstart = time.clock()
print yearstart

time.sleep(3)

yearend = time.clock()
print yearend
elapsed= yearend-yearstart
min = elapsed/60

print elapsed, min

yearstart = time.time()
print yearstart

time.sleep(3)

yearend = time.time()
print yearend

elapsed= yearend-yearstart

min = elapsed/60

print elapsed, min

And got the output:

0.03
0.03
0.0 0.0
1211338788.69
1211338791.69
3.00004386902 0.0500007311503

No Fluff Answer:

Read nothing else (on this page). This code will get you going:

import time

start = time.time()

# whatever you want to time, put between these two statements

end = time.time()

elapsed= end - start

#if you want to convert to minutes, just divide
min = elapsed/60

print "Your stuff took", elapsed, "seconds to run, which is the same as", min, "minutes"

So, this works for me.  I supose that time.clock() does not reference absolute time, which was a problem for me. Hope this helps, or at least saves you some head-scratching.

Solution: Not exactly sure, but it seems to have stopped.

There are several WordPress posts that go over an issue of using the

[/sourcecode]

tag to write sourcecode.

Personally, I was very frustrated because while writing in Python, where whitespace matters, my indents would all be lost when switching between the visual and HTML editor in WordPress.

My solution was to wrap my

[sourcecode]

tags in <pre> tags.

Check the plugin?

I originally was using the

[/sourcecode]

tag from <a href="http://code.google.com/p/syntaxhighlighter/">SyntaxHighlighter</a>, then found another one, called SyntaxHilighter Plus.

I don't have time to go over all of this, but I disabled the Plus version, re-enabled the regular SyntaxHighlighter, and made sure to wrap my

[sourcecode]

s in <pre> tags.

Quick Answer (for managed attributes only):

class dumb:
    def dummy():
        pass

def attributes(o):
    print "object:", o
    print "Initialized attribute values:"
    step=0
    for var in dir(o):
        vartype=-1
        exec("vartype = type(o."+str(var)+")")
        if not(var in o.__dict__) and not(vartype == type( dumb.dummy)) and not("__" == var[:2]):
            value = -30
            exec("value = o."+str(dir(o)[step]))
            print '%40s' % var  +": "+ str(value)
        step += 1

The whole story

Either I am just really new to python (I am) or it is just really hard when you have an object and you just want to get the public attributes.

The code above uses the dir() function to get everything from the object.  Besides both public and private attributes, this also gets user defined and inherited methods.  Then, i crop out those that are not public attributes.

Code Walkthrough (Get managed attributes only)

Managed attributes are those that are defined in an object’s definition.  Here is an example:

class Widget(object):
    """The Widget represents an object of work.  it can be processed by a worker. it is assigned to a worker by an organization."""
        self.__id=id
        self.test=35

    ### MANAGED ATTRIBUTES ###

    #id
    def id():
        """id is readonly"""
            return self.__id
        return locals()
    id = property(**id())
    #END id

    ### END MANAGED ATTRIBUTES ###

    def spoil_step(self):
        """Increases the steps that this widget has been spoiling"""
        old = self.__time_spoiling
        self.__time_spoiling += 1
        #check for sure
        if old + 1 == self.__time_spoiling:
            return self.__time_spoiling
        else:
            return False

    ####END Widget OBJECT ####

The Following list references the code at the top of the page

1. I created a dumb object with a dummy function.  This will be used to identify “instance methods”. The pass instruction is just a filler.

   class dumb:
       def dummy():
           pass
   
   

2. I created a function that takes an object, o, as input.  It then just prints out the object and lets the user know that it is about to go through it:

   def attributes(o):
       print "object:", o
       print "Initialized attribute values:"
   
   

3. I created a variable to keep track of which thing we are looking at, starting at the 0-index:

        step=0
   
   

4. Then I go through each member of the object:

        for var in dir(o):
   
   

5. I then create a variable, and assign the type of the object to this variable:

             vartype=-1
             exec("vartype = type(o."+str(var)+")")
   
   

6. Next comes the key conditional statement:

             if not(var in o.__dict__) and not(vartype == type( dumb.dummy)) and not("__" == var[:2]):
   
   

   The first part says exclude if you find it in o.__dict__, which contains the private attributes from the __init__() function. The second part excludes things that are of the same type as an instance method; so this gets rid of the object’s methods. The last part looks at the first to characters of the thing, and if it is equal to __, it is excluded.

7. Within the conditional, we just name and value of that thing, which should be only managed attributes:

                  value = -30
                  exec("value = o."+str(dir(o)[step]))
                  print '%40s' % var  +": "+ str(value)
   
   

The next page goes over how to get both the managed and public (not just the managed) attributes from an object