\nimport time\n\nstart = time.time() #start time\n\nfor i in range(1000000):\n pass\n\nend = time.time()\nprint("Elapsed time is {}".format(end-start))\n<\/pre><\/div>\n\n\nExplanation – <\/strong><\/p>\n\n\n\nFirstly, we start with importing the time module. This module contains all the basic time functions<\/strong> which we’ll use in this section. At the start of the code, we’ll declare the start variable as time.time()<\/code>. This will store the current time of CPU in float number <\/strong>from the epoch. We’ll use this start variable as a reference point to measure the time. The next part contains all the codes you want to use (In this example, we’ve used a for loops). Similarly, record the end time of the CPU (Default time) and check the total execution time by using end – start.<\/strong><\/p>\n\n\n\nThis will print the time taken by the code in seconds. With the use of this technique, you can check the time taken by your code. The only problem with this method is that the CPU time can be changed while the code is running. <\/strong>This will result in problematic behavior in python timer.<\/p>\n\n\n\n<\/span>Function time.Thread_time<\/span><\/h3>\n\n\n\ntime.thread_time()<\/code> returns the sum of system and CPU time (float) in the current running thread<\/strong>. Moreover, it doesn’t include the time you spend in time.sleep()<\/code> function. As the function is thread-specific, you can use this function to record the time differences as long as the time references belong to the same thread<\/strong>.<\/p>\n\n\n\nExample – <\/strong><\/p>\n\n\n\nimport time\nimport threading\nend = None\nstart = None\ndef hello():\n global start, end\n start = time.thread_time()\n x = 0 \n while x < 10000000:\n pass\n x += 1\n end = time.thread_time()\n\nt = threading.Thread(target = hello, args = ())\nt.start() \nt.join()\n\nprint("The time spent is {}".format(end - start))\n<\/pre><\/div>\n\n\nExplanation – <\/strong><\/p>\n\n\n\nAs the thread_time returns thread-specific time, we have to make sure to use references in the same thread<\/strong>. For this purpose, we’ve instantiated the thread of function ‘hello<\/strong>‘ and calculated the time taken by the thread inside it. However, make sure that you cannot get the current time by calling thread_time() <\/strong>because it returns a fractional value. But you can definitely check the difference between two consecutive references as long as they belong in the same thread.<\/strong><\/p>\n\n\n\n<\/span>Function time.Process_time<\/span><\/h3>\n\n\n\ntime.process_time() <\/code>returns the time reference in fractional seconds (float) of the sum of system time and CPU time of current progress<\/strong>. Same as thread_time, this function doesn’t measure the time spent in time.sleep()<\/code> function. Moreover, this function creates a reference based on the process. As a result of this, only the time difference between two consecutive references will make sense.<\/strong><\/p>\n\n\n\nExample – <\/strong><\/p>\n\n\n\nfrom time import process_time, sleep\n\niterations = 100000\n\nstart = process_time() \n \nfor i in range(iterations):\n print(i, end=" ")\n \n# Stop the stopwatch \/ counter \nend = process_time()\nprint(end, start)\nprint("Elapsed time in seconds:", end-start)\n<\/pre><\/div>\n\n\nExplanation – <\/strong><\/p>\n\n\n\nWe start with importing the process_time function and record the start and end time between the code. The only difference between legacy time.time()<\/code> and time.proces_time()<\/code> is that the processing time records the time references of the current process<\/strong>, whereas time()<\/code> records the system’s absolute time.<\/p>\n\n\n\n<\/span>Function time.Perf_counter<\/span><\/h3>\n\n\n\nPerf Counter stands for Performance Counter<\/strong>. This function returns the high-resolution value of the time<\/strong>, which is valid for a short period of time<\/strong>. This function is used to get the precise time count between two references<\/strong>. As other python timer functions don’t include sleep time, perf_counter<\/code> also doesn’t include it. Let’s move to an example – <\/p>\n\n\n\nExample – <\/strong><\/p>\n\n\n\nfrom time import perf_counter, sleep\n \n# integer input from user, 2 input in single line\nn = 3\n \n# Start the stopwatch \/ counter \nstart = perf_counter() \n \nfor i in range(n): \n sleep(1)\n\nend = perf_counter() \n \n \nprint("Elapsed time in seconds:", end-start) \n<\/pre><\/div>\n\n\nExplanation – <\/strong><\/p>\n\n\n\nYou can use the perf counter in the same way as the process timer or thread timer. The only difference is, perf counter will return a high precise value of the time elapsed. But make sure that you use this between small processes<\/strong>, as it uses high precision<\/strong>. We’ve used a simple loop to check the time taken by it.<\/p>\n\n\n\n<\/span>Function time.monotonic<\/span><\/h3>\n\n\n\nMonotonic is a python timer that cant go backward<\/strong>. When executing a python script, the time can be changed by the user and can make a huge difference in the implementation of the timer in python. But monotonic timer ensures that the time references adjust to the external changes.<\/strong><\/p>\n\n\n\nExample – <\/strong><\/p>\n\n\n\nfrom time import monotonic, sleep\n \n# integer input from user, 2 input in single line\nn = 3\n \n# Start the stopwatch \/ counter \nstart = monotonic() \n \nfor i in range(n): \n sleep(1)\n\nend = monotonic() \n \n \nprint("Elapsed time in seconds:", end-start) \n<\/pre><\/div>\n\n\nExplanation – <\/strong><\/p>\n\n\n\nWe first import the monotonic function<\/strong> from the time module. Then create two references named start and end<\/strong> in the top and bottom side of the code. This will measure the time between the two references <\/strong>and avoid all the external changes to the system times.<\/p>\n\n\n\n<\/span>Custom Python Timer Classes<\/span><\/h2>\n\n\n\nYou can create your own custom Timer class to do things according to your need. One main advantage of creating a custom class is you can manage all the time in a single line. You don’t need to import the time class every time and record the references. Moreover, you can dump your data and record all the past time executions to choose the best algorithm for you.<\/p>\n\n\n\n
This section will create a custom class to manage the time and log all the time differences in your codes. Let’s dive right into it – <\/p>\n\n\n\n
Timer.py – <\/strong><\/p>\n\n\n\nWe’ll begin with importing the time module. Then initialize the python Timer class and start defining the attributes and methods. So far, we’ve only included the basic attribute to keep a start reference of the class. To make it more complex, you can create multiple attributes. So far, there are three methods listed below –<\/p>\n\n\n\n
start<\/strong> – (Optional) To start the timer.<\/li>log <\/strong>– To log the current elapsed time concerning start time.<\/li>milestone <\/strong>– To reset the timer and start its count from 0.<\/li><\/ol>\n\n\n\nimport time\n\nclass Timer:\n\n def __init__(self):\n self.start = time.time()\n\n def start(self):\n self.start = time.time()\n\n def log(self):\n logger = time.time() - self.start\n print('Time log -',logger)\n\n def milestone(self):\n self.start = time.time()\n\n<\/pre><\/div>\n\n\nexample.py –<\/strong><\/p>\n\n\n\nExamples of usage of the above class are given below. As you can view, you can keep your code clean<\/strong> by creating a custom Timer class and increase flexibility.<\/p>\n\n\n\nimport timer\n\ntime = timer.Timer()\nfor i in range(1000000):\n\tpass\n\tp = 1\ntime.log()\nfor i in range(1000000):\n\tpass\n\tp = 1\ntime.log()\n<\/pre><\/div>\n\n\nOutput – <\/p>\n\n\n\n
Time log - 0.054854631423950195\nTime log - 0.10871052742004395<\/code><\/pre>\n\n\n\n<\/span>Python Timer using Threading<\/span><\/h2>\n\n\n\nWhen we want to perform some operation or want our function to run after a certain amount of time, we make use of the Python Timer class. <\/em>The timer class is a subclass of the threading class. <\/strong>Technically, you can say that we create Timer objects when we want actions (functions) bounded by the time.<\/em> <\/p>\n\n\n\n For example, suppose we want to organize a quiz, where the participant has to answer each question in 10 seconds. Here, we can create a timer that will run in the background, and meanwhile, the participant will be thinking about the answer. Now, let us understand how to create a timer object<\/strong>. <\/p>\n\n\n\n<\/span>Syntax of Timer Class in Python<\/span><\/h3>\n\n\n\nIf you have not understood what Timer class does, you can think of it in this way \u2013 A Timer Class calls a function after the specified number of seconds<\/strong>. <\/p>\n\n\n\nTo start a timer, we need to call the start()<\/strong>(just like normal threads), and to stop the timer while it is still in the background, we can call cancel()<\/strong>. <\/p>\n\n\n\nTo use the Timer class, we need to import threading<\/em><\/strong> class <\/p>\n\n\n\nthreading.Timer(interval, function, args=None, kwargs=None) <\/strong><\/p>\n\n\n\n<\/span>Parameters- <\/span><\/h3>\n\n\n\nInterval<\/strong>– The time (in seconds) you want to wait before calling the next function. It can either be in float or integer. For example, for 3 seconds, interval=3. <\/p>\n\n\n\nFunction<\/strong> – The function you want to call after the specified interval of time. <\/p>\n\n\n\nA pervasive way to describe *args and **kwargs<\/strong> parameters is- create a timer object that runs the function with arguments’ args’ and keyword arguments’ kwargs’ after interval seconds have passed<\/em>. Args should be in the form of a list<\/strong> and0 keyword args or kwargs in the form of a dictionary<\/strong>. <\/p>\n\n\n\n<\/span>Return Type- <\/span><\/h3>\n\n\n\nIt just calls the function specified in the parameters. <\/p>\n\n\n\n
<\/span>Methods in Timer class <\/span><\/h3>\n\n\n\nstart()<\/strong> – It signifies the beginning of execution of the timer. <\/li>Cancel ()<\/strong>– During the timer’s execution, we can call the cancel if we want to stop it (). <\/li><\/ol>\n\n\n\n<\/span>Creating a Timer Object <\/span><\/h3>\n\n\n\na. Understanding the basics<\/strong><\/p>\n\n\n\nTo understand the Timer object’s working, let us create a small program to help us understand the class’s basics. <\/p>\n\n\n
\n# Importing the Timer subclass from the threading Class\nfrom threading import Timer\n\n# creating a basic function that will print "hello"\ndef hello():\n print ("hello, world")\n\n# creating the object of the Timer subclass\n# Here, 5 sec means that the execution of the function="hello" after 5 seconds\nt = Timer(interval=5.0, function=hello)\n\n# starting the execution\nt.start() # after 30 seconds, "hello, world" will be printed\n<\/pre><\/div>\n\n\nOutput-\nhello, world<\/pre>\n\n\n\nYou will better understand the functioning of the above program when you try to run it on your own system<\/a>. <\/p>\n\n\n\nb. Using the cancel method<\/strong><\/p>\n\n\n\n