What is the Python equivalent of Matlab's tic and toc functions?

Question

What is the Python equivalent of Matlab's tic and toc functions?

Answer 1

Apart from timeit which ThiefMaster mentioned, a simple way to do it is just (after importing time):

t = time.time()
# do stuff
elapsed = time.time() - t

I have a helper class I like to use:

class Timer(object):
    def __init__(self, name=None):
        self.name = name

    def __enter__(self):
        self.tstart = time.time()

    def __exit__(self, type, value, traceback):
        if self.name:
            print('[%s]' % self.name,)
        print('Elapsed: %s' % (time.time() - self.tstart))

It can be used as a context manager:

with Timer('foo_stuff'):
   # do some foo
   # do some stuff

Sometimes I find this technique more convenient than timeit - it all depends on what you want to measure.

Answer 2

I had the same question when I migrated to python from Matlab. With the help of this thread I was able to construct an exact analog of the Matlab tic() and toc() functions. Simply insert the following code at the top of your script.

import time

def TicTocGenerator():
    # Generator that returns time differences
    ti = 0           # initial time
    tf = time.time() # final time
    while True:
        ti = tf
        tf = time.time()
        yield tf-ti # returns the time difference

TicToc = TicTocGenerator() # create an instance of the TicTocGen generator

# This will be the main function through which we define both tic() and toc()
def toc(tempBool=True):
    # Prints the time difference yielded by generator instance TicToc
    tempTimeInterval = next(TicToc)
    if tempBool:
        print( "Elapsed time: %f seconds.\n" %tempTimeInterval )

def tic():
    # Records a time in TicToc, marks the beginning of a time interval
    toc(False)

That's it! Now we are ready to fully use tic() and toc() just as in Matlab. For example

tic()

time.sleep(5)

toc() # returns "Elapsed time: 5.00 seconds."

Actually, this is more versatile than the built-in Matlab functions. Here, you could create another instance of the TicTocGenerator to keep track of multiple operations, or just to time things differently. For instance, while timing a script, we can now time each piece of the script seperately, as well as the entire script. (I will provide a concrete example)

TicToc2 = TicTocGenerator() # create another instance of the TicTocGen generator

def toc2(tempBool=True):
    # Prints the time difference yielded by generator instance TicToc2
    tempTimeInterval = next(TicToc2)
    if tempBool:
    print( "Elapsed time 2: %f seconds.\n" %tempTimeInterval )

def tic2():
    # Records a time in TicToc2, marks the beginning of a time interval
    toc2(False)

Now you should be able to time two separate things: In the following example, we time the total script and parts of a script separately.

tic()

time.sleep(5)

tic2()

time.sleep(3)

toc2() # returns "Elapsed time 2: 5.00 seconds."

toc() # returns "Elapsed time: 8.00 seconds."

Actually, you do not even need to use tic() each time. If you have a series of commands that you want to time, then you can write

tic()

time.sleep(1)

toc() # returns "Elapsed time: 1.00 seconds."

time.sleep(2)

toc() # returns "Elapsed time: 2.00 seconds."

time.sleep(3)

toc() # returns "Elapsed time: 3.00 seconds."

# and so on...

I hope that this is helpful.

Answer 3

The absolute best analog of tic and toc would be to simply define them in python.

def tic():
    #Homemade version of matlab tic and toc functions
    import time
    global startTime_for_tictoc
    startTime_for_tictoc = time.time()

def toc():
    import time
    if 'startTime_for_tictoc' in globals():
        print "Elapsed time is " + str(time.time() - startTime_for_tictoc) + " seconds."
    else:
        print "Toc: start time not set"

Then you can use them as:

tic()
# do stuff
toc()

Answer 4

Usually, IPython's %time, %timeit, %prun and %lprun (if one has line_profiler installed) satisfy my profiling needs quite well. However, a use case for tic-toc-like functionality arose when I tried to profile calculations that were interactively driven, i.e., by the user's mouse motion in a GUI. I felt like spamming tics and tocs in the sources while testing interactively would be the fastest way to reveal the bottlenecks. I went with Eli Bendersky's Timer class, but wasn't fully happy, since it required me to change the indentation of my code, which can be inconvenient in some editors and confuses the version control system. Moreover, there may be the need to measure the time between points in different functions, which wouldn't work with the with statement. After trying lots of Python cleverness, here is the simple solution that I found worked best:

from time import time
_tstart_stack = []

def tic():
    _tstart_stack.append(time())

def toc(fmt="Elapsed: %s s"):
    print fmt % (time() - _tstart_stack.pop())

Since this works by pushing the starting times on a stack, it will work correctly for multiple levels of tics and tocs. It also allows one to change the format string of the toc statement to display additional information, which I liked about Eli's Timer class.

For some reason I got concerned with the overhead of a pure Python implementation, so I tested a C extension module as well:

#include <Python.h>
#include <mach/mach_time.h>
#define MAXDEPTH 100

uint64_t start[MAXDEPTH];
int lvl=0;

static PyObject* tic(PyObject *self, PyObject *args) {
    start[lvl++] = mach_absolute_time();
    Py_RETURN_NONE;
}

static PyObject* toc(PyObject *self, PyObject *args) {
return PyFloat_FromDouble(
        (double)(mach_absolute_time() - start[--lvl]) / 1000000000L);
}

static PyObject* res(PyObject *self, PyObject *args) {
    return tic(NULL, NULL), toc(NULL, NULL);
}

static PyMethodDef methods[] = {
    {"tic", tic, METH_NOARGS, "Start timer"},
    {"toc", toc, METH_NOARGS, "Stop timer"},
    {"res", res, METH_NOARGS, "Test timer resolution"},
    {NULL, NULL, 0, NULL}
};

PyMODINIT_FUNC
inittictoc(void) {
    Py_InitModule("tictoc", methods);
}

This is for MacOSX, and I have omitted code to check if lvl is out of bounds for brevity. While tictoc.res() yields a resolution of about 50 nanoseconds on my system, I found that the jitter of measuring any Python statement is easily in the microsecond range (and much more when used from IPython). At this point, the overhead of the Python implementation becomes negligible, so that it can be used with the same confidence as the C implementation.

I found that the usefulness of the tic-toc-approach is practically limited to code blocks that take more than 10 microseconds to execute. Below that, averaging strategies like in timeit are required to get a faithful measurement.

Answer 5

You can use tic and toc from ttictoc. Install it with

pip install ttictoc

And just import them in your script as follow

from ttictoc import tic,toc
tic()
# Some code
print(toc())

Answer 6

I have just created a module [tictoc.py] for achieving nested tic tocs, which is what Matlab does.

from time import time

tics = []

def tic():
    tics.append(time())

def toc():
    if len(tics)==0:
        return None
    else:
        return time()-tics.pop()

And it works this way:

from tictoc import tic, toc

# This keeps track of the whole process
tic()

# Timing a small portion of code (maybe a loop)
tic()

# -- Nested code here --

# End
toc()  # This returns the elapse time (in seconds) since the last invocation of tic()
toc()  # This does the same for the first tic()

I hope it helps.

Answer 7

Have a look at the timeit module. It's not really equivalent but if the code you want to time is inside a function you can easily use it.

Answer 8

pip install easy-tictoc

In the code:

from tictoc import tic, toc

tic()

#Some code

toc()

---

^{Disclaimer: I'm the author of this library.}

Answer 9

Updating Eli's answer to Python 3:

class Timer(object):
    def __init__(self, name=None, filename=None):
        self.name = name
        self.filename = filename

    def __enter__(self):
        self.tstart = time.time()

    def __exit__(self, type, value, traceback):
        message = 'Elapsed: %.2f seconds' % (time.time() - self.tstart)
        if self.name:
            message = '[%s] ' % self.name + message
        print(message)
        if self.filename:
            with open(self.filename,'a') as file:
                print(str(datetime.datetime.now())+": ",message,file=file)

Just like Eli's, it can be used as a context manager:

import time 
with Timer('Count'):
    for i in range(0,10_000_000):
        pass

Output:

[Count] Elapsed: 0.27 seconds

I have also updated it to print the units of time reported (seconds) and trim the number of digits as suggested by Can, and with the option of also appending to a log file. You must import datetime to use the logging feature:

import time
import datetime 
with Timer('Count', 'log.txt'):    
    for i in range(0,10_000_000):
        pass

Answer 10

Building on Stefan and antonimmo's answers, I ended up putting

def Tictoc():
    start_stack = []
    start_named = {}

    def tic(name=None):
        if name is None:
            start_stack.append(time())
        else:
            start_named[name] = time()

    def toc(name=None):
        if name is None:
            start = start_stack.pop()
        else:
            start = start_named.pop(name)
        elapsed = time() - start
        return elapsed
    return tic, toc

in a utils.py module, and I use it with a

from utils import Tictoc
tic, toc = Tictoc()

This way

• you can simply use tic(), toc() and nest them like in Matlab
• alternatively, you can name them: tic(1), toc(1) or tic('very-important-block'), toc('very-important-block') and timers with different names won't interfere
• importing them this way prevents interference between modules using it.

(here toc does not print the elapsed time, but returns it.)

Answer 11

I changed @Eli Bendersky's answer a little bit to use the ctor __init__() and dtor __del__() to do the timing, so that it can be used more conveniently without indenting the original code:

class Timer(object):
    def __init__(self, name=None):
        self.name = name
        self.tstart = time.time()

    def __del__(self):
        if self.name:
            print '%s elapsed: %.2fs' % (self.name, time.time() - self.tstart)
        else:
            print 'Elapsed: %.2fs' % (time.time() - self.tstart)

To use, simple put Timer("blahblah") at the beginning of some local scope. Elapsed time will be printed at the end of the scope:

for i in xrange(5):
    timer = Timer("eigh()")
    x = numpy.random.random((4000,4000));
    x = (x+x.T)/2
    numpy.linalg.eigh(x)
    print i+1
timer = None

It prints out:

1
eigh() elapsed: 10.13s
2
eigh() elapsed: 9.74s
3
eigh() elapsed: 10.70s
4
eigh() elapsed: 10.25s
5
eigh() elapsed: 11.28s

Answer 12

This can also be done using a wrapper. Very general way of keeping time.

The wrapper in this example code wraps any function and prints the amount of time needed to execute the function:

def timethis(f):
    import time

    def wrapped(*args, **kwargs):
        start = time.time()
        r = f(*args, **kwargs)
        print "Executing {0} took {1} seconds".format(f.func_name,  time.time()-start)
        return r
    return wrapped

@timethis
def thistakestime():
    for x in range(10000000):
        pass

thistakestime()

Answer 13

This solution works for my profiling needs:

from time import time
import inspect

def tic():
    tic.t = time()

def toc(message=None):
    time_elapsed = time() - tic.t
    if message is None:
        message = inspect.currentframe().f_back.f_lineno
    print(message, time_elapsed)
    tic.t = time()
    return time_elapsed

Then you can just paste a lot of toc()s in your code, and you have a pretty powerful profiler. (message defaults to the caller's code line in file)

Answer 14

Based on the answer of @Maxim, here is a simplified solution:

def tictoc():
    """Python implementation of MATLAB tic-toc functionality."""
    from time import perf_counter_ns
    hashmap = {}
    def tic(key: str=None) -> None:
        """named tic method"""
        hashmap[key] = perf_counter_ns()
        return None
    def toc(key: str=None) -> float:
        """named toc method"""
        initial_ns = hashmap[key]
        current_ns = perf_counter_ns()
        elapsed_ns = current_ns - initial_ns
        elapsed_s  = elapsed_ns / (10**9)  # convert ns to s
        print(f"Elapsed time is {elapsed_s} seconds.")
        return elapsed_s  
    return tic, toc

Assuming it is stored in a file called utils.py, it is used in the following manner:

from utils import tictoc

tic, toc = tictoc()

tic()
toc()
toc()
tic()
toc()

tic('foo')
toc('foo')
toc('foo')

toc()

Unlike the original, this version does not crash when you run toc() multiple times and properly resets when running tic while retaining the key-value timer functionality. It also removes an unnecessary list/array data structure and multiple conditional branches in the code, which induce slowdowns. Hashmap lookup times are constant at O^1, which is faster than resizing arrays. Also, I have switched to the perf_counter_ns timer, which is based on perf_counter and avoids the precision loss caused by the float type.

If anyone wants to go lower level, here is a version using the Python C API:

// tictoc.c
#define PY_SSIZE_T_CLEAN  // REQUIRED
#include <Python.h>       // Python C API

#include <stdint.h>       // uint64_t
#include <time.h>         // timespec
#include <sys/time.h>     // time types
#include <stdio.h>        // printf

typedef struct {
    uint64_t initial_ns;
    uint64_t current_ns;
    uint64_t elapsed_ns;
    double elapsed_s;
} timer;

timer t;

struct timespec ts;  // C11

// Unix POSIX clock time scaled to microseconds (us; 10^6 sec)
uint64_t posix_clock_time () {
    timespec_get(&ts, TIME_UTC);
    return ts.tv_sec * 1000000000 + ts.tv_nsec;  // ns = 10^-9 s
}

// tic
static PyObject* tic(PyObject* self, PyObject* args) {
    t.initial_ns = posix_clock_time();
    Py_RETURN_NONE;
}

// toc
static PyObject* toc(PyObject* self, PyObject* args) {
    t.current_ns = posix_clock_time();
    t.elapsed_ns = t.current_ns - t.initial_ns;
    t.elapsed_s  = (double)t.elapsed_ns / (double)1000000000.0;  // s = 10^9 ns
    printf("Elapsed time is %f seconds.\n", t.elapsed_s);
    return PyFloat_FromDouble(t.elapsed_s);
}

static PyMethodDef methods[] = {
    {"tic", tic, METH_NOARGS, "Start timer"},
    {"toc", toc, METH_NOARGS, "Stop timer"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef tictoc = {
    PyModuleDef_HEAD_INIT,
    "tictoc",    // name of module
    "A timer function analogous to MATLAB's tic-toc.",  // module documentation, may be NULL
    -1,          // size of per-interpreter state of module; -1 if module keeps state in global variables
    methods
};

PyMODINIT_FUNC PyInit_tictoc(void) {
    return PyModule_Create(&tictoc);
}

Install it with a setup.py file:

# setup.py
from distutils.core import setup, Extension

module1 = Extension(
    'tictoc',
    sources = ['tictoc.c']
)

setup(name = 'tictoc',
    version = '1.0',
    description = 'The tictoc package',
    ext_modules = [module1]
)

From the command line, run python setup.py build and Bob's your uncle. This compiles to a shared library that provides basic tic-toc functionality similar to MATLAB:

from tictoc import tic, toc

tic()
toc()
toc()

tic()
toc()
toc()