Python speed testing – Time Difference – milliseconds

You could simply print the difference:

print tend - tstart

I am not a Python programmer, but I do know how to use Google and here’s what I found: you use the “-” operator. To complete your code:

from datetime import datetime

tstart = datetime.now()

# code to speed test

tend = datetime.now()
print tend - tstart

Additionally, it looks like you can use the strftime() function to format the timespan calculation in order to render the time however makes you happy.

The following code should display the time detla…

from datetime import datetime

tstart = datetime.now()

# code to speed test

tend = datetime.now()
print tend - tstart

time.time() / datetime is good for quick use, but is not always 100% precise. For that reason, I like to use one of the std lib profilers (especially hotshot) to find out what’s what.

You could also use:

import time

start = time.clock()
do_something()
end = time.clock()
print "%.2gs" % (end-start)

Or you could use the python profilers.

You may want to look into the profile modules. You’ll get a better read out of where your slowdowns are, and much of your work will be full-on automated.

You might want to use the timeit module instead.

You could use timeit like this to test a script named module.py

$ python -mtimeit -s 'import module'

I know this is late, but I actually really like using:

import time
start = time.time()

##### your timed code here ... #####

print "Process time: " + (time.time() - start)

time.time() gives you seconds since the epoch. Because this is a standardized time in seconds, you can simply subtract the start time from the end time to get the process time (in seconds). time.clock() is good for benchmarking, but I have found it kind of useless if you want to know how long your process took. For example, it’s much more intuitive to say “my process takes 10 seconds” than it is to say “my process takes 10 processor clock units”

>>> start = time.time(); sum([each**8.3 for each in range(1,100000)]) ; print (time.time() - start)
3.4001404476250935e+45
0.0637760162354
>>> start = time.clock(); sum([each**8.3 for each in range(1,100000)]) ; print (time.clock() - start)
3.4001404476250935e+45
0.05

In the first example above, you are shown a time of 0.05 for time.clock() vs 0.06377 for time.time()

>>> start = time.clock(); time.sleep(1) ; print "process time: " + (time.clock() - start)
process time: 0.0
>>> start = time.time(); time.sleep(1) ; print "process time: " + (time.time() - start)
process time: 1.00111794472

In the second example, somehow the processor time shows “0” even though the process slept for a second. time.time() correctly shows a little more than 1 second.

Since Python 2.7 there’s the timedelta.total_seconds() method. So, to get the elapsed milliseconds:

>>> import datetime
>>> a = datetime.datetime.now()
>>> b = datetime.datetime.now()
>>> delta = b - a
>>> print delta
0:00:05.077263
>>> int(delta.total_seconds() * 1000) # milliseconds
5077

Here is a custom function that mimic’s Matlab’s/Octave’s tic toc functions.

Example of use:

time_var = time_me(); # get a variable with the current timestamp

... run operation ...

time_me(time_var); # print the time difference (e.g. '5 seconds 821.12314 ms')

Function :

def time_me(*arg):
    if len(arg) != 0: 
        elapsedTime = time.time() - arg[0];
        #print(elapsedTime);
        hours = math.floor(elapsedTime / (60*60))
        elapsedTime = elapsedTime - hours * (60*60);
        minutes = math.floor(elapsedTime / 60)
        elapsedTime = elapsedTime - minutes * (60);
        seconds = math.floor(elapsedTime);
        elapsedTime = elapsedTime - seconds;
        ms = elapsedTime * 1000;
        if(hours != 0):
            print ("%d hours %d minutes %d seconds" % (hours, minutes, seconds)) 
        elif(minutes != 0):
            print ("%d minutes %d seconds" % (minutes, seconds))
        else :
            print ("%d seconds %f ms" % (seconds, ms))
    else:
        #print ('does not exist. here you go.');
        return time.time()

Arrow: Better dates & times for Python

import arrow
start_time = arrow.utcnow()
end_time = arrow.utcnow()
(end_time - start_time).total_seconds()  # senconds
(end_time - start_time).total_seconds() * 1000  # milliseconds

start = datetime.now() 

#code for which response time need to be measured.

end = datetime.now()
dif = end - start
dif_micro = dif.microseconds # time in microseconds
dif_millis = dif.microseconds / 1000 # time in millisseconds

In case anyone needs something like this to analyze delays between log entries for example … etc.

def get_time_diff_between_timestruct_tuples(timestruct_tuples):
    """
    expecting input like:
    [(0, datetime.datetime(2021, 10, 27, 16, 6, 8, 590892)),
    (1, datetime.datetime(2021, 10, 27, 16, 6, 8, 591833)),
    (2, datetime.datetime(2021, 10, 27, 16, 6, 9, 434053)),
    (3, datetime.datetime(2021, 10, 27, 16, 6, 9, 878021)), ...]
    
    output like:
    [0.941, 0.84222, 0.443968, ...]
    """
    
    def seconds_mms_diff(t0, t1):
        diff = t1 - t0
        s = diff.seconds
        mms = diff.microseconds
        return float(f"{s}.{mms}")
    
    timediffs = []
    init = timestruct_tuples[0][1]
    idx = 0
    while idx < (len(timestruct_tuples)-1):
        timediffs.append(seconds_mms_diff(init, timestruct_tuples[idx+1][1]))
        idx += 1
        init = timestruct_tuples[idx][1]
    return timediffs

You need to use time.time() instead, which outputs unix time with high precision.

Use this code:

from time import time

tstart = time()
doSomething()
tend = time()
difference = tend - tstart
print("The doSomething function took {} seconds to execute".format(difference))

Assume that I have the input data as follows:

2022-09-05 02:08:06,159881
2022-09-05 02:08:06,160029
2022-09-05 02:08:06,160032
2022-09-05 02:08:06,307158
2022-09-05 02:08:06,448136
2022-09-05 02:08:06,494221
2022-09-05 02:08:06,626149
2022-09-05 02:08:06,626153

I want to calculate the delta between two consecutive rows.

How I can use above script then ?