I have the following code in a python script:

def fun(): 
  #Code here


I want to execute this script and also find out how much time it took to execute in minutes. How do I find out how much time it took for this script to execute ? An example would be really appreciated.

from datetime import datetime
startTime = datetime.now()

#do something

#Python 2: 
print datetime.now() - startTime 

#Python 3: 
print(datetime.now() - startTime)

Do you execute the script from the command line on Linux or UNIX? In that case, you could just use

time ./script.py

import time
start = time.time()


# python 2
print 'It took', time.time()-start, 'seconds.'

# python 3
print('It took', time.time()-start, 'seconds.')

What I usually do is use clock() or time() from the time library. clock measures interpreter time, while time measures system time. Additional caveats can be found in the docs.

For example,

def fn():
    st = time()
    print 'fn took %.2f seconds' % (time() - st)

Or alternatively, you can use timeit. I often use the time approach due to how fast I can bang it out, but if you’re timing an isolate-able piece of code, timeit comes in handy.

From the timeit docs,

def test():
    "Stupid test function"
    L = []
    for i in range(100):

if __name__=='__main__':
    from timeit import Timer
    t = Timer("test()", "from __main__ import test")
    print t.timeit()

Then to convert to minutes, you can simply divide by 60. If you want the script runtime in an easily readable format, whether it’s seconds or days, you can convert to a timedelta and str it:

runtime = time() - st
print 'runtime:', timedelta(seconds=runtime)

and that’ll print out something of the form [D day[s], ][H]H:MM:SS[.UUUUUU]. You can check out the timedelta docs.

And finally, if what you’re actually after is profiling your code, Python makes available the profile library as well.

import time 

startTime = time.time()
# Your code here !
print ('The script took {0} second !'.format(time.time() - startTime))

The previous code works for me with no problem !

import sys
import timeit

start = timeit.default_timer()

#do some nice things...

stop = timeit.default_timer()
total_time = stop - start

# output running time in a nice format.
mins, secs = divmod(total_time, 60)
hours, mins = divmod(mins, 60)

sys.stdout.write("Total running time: %d:%d:%d.\n" % (hours, mins, secs))

Use the timeit module. It’s very easy. Run your example.py file so it is active in the Python Shell, you should now be able to call your function in the shell. Try it out to check it works


Good, that works, now import timeit and set up a timer

>>>import timeit
>>>t = timeit.Timer('example.fun(input)','import example')

Now we have our timer set up we can see how long it takes

some number here

And there we go, it will tell you how many seconds (or less) it took to execute that function. If it’s a simple function then you can increase it to t.timeit(number=1000) (or any number!) and then divide the answer by the number to get the average.

I hope this helps.

Pure Python

Better yet is time.perf_counter():

t0 = time.perf_counter()
t1 = time.perf_counter()

# and if you really want your answer in minutes:
print(f"In minutes: {(t1-t0)/60}")

Recommended by this guy as well (5:30).


time.perf_counter()? float

Return the value (in fractional seconds) of a performance counter,
i.e. a clock with the highest available resolution to measure a short
duration. It does include time elapsed during sleep and is
system-wide. The reference point of the returned value is undefined,
so that only the difference between the results of two calls is valid.

Use perf_counter_ns() to avoid the precision loss caused by the
float type.

New in version 3.3.

Changed in version 3.10: On Windows, the function is now system-wide.

Jupyter Notebook: %timeit & %time magic

If you are working in a Jupyter Notebook (such as Google Colab), you can use IPython Magic Commands.


import time
import numpy as np

def fun(): 

Then in a separate cell, to time the function multiple times:

%timeit fun()


10 loops, best of 5: 120 ms per loop

To time the function only once:

%time fun()


CPU times: user 0 ns, sys: 621 µs, total: 621 µs
Wall time: 114 ms

You can find more about Magic Commands here.

use the time and datetime packages.

if anybody want to execute this script and also find out how much time it took to execute in minutes

import time
from time import strftime
from datetime import datetime 
from time import gmtime

def start_time_():    
    #import time
    start_time = time.time()

def end_time_():
    #import time
    end_time = time.time()

def Execution_time(start_time_,end_time_):
   #import time
   #from time import strftime
   #from datetime import datetime 
   #from time import gmtime

start_time = start_time_()
# your code here #
[i for i in range(0,100000000)]
# your code here #
end_time = end_time_()
print("Execution_time is :", Execution_time(start_time,end_time))

The above code works for me. I hope this helps.