Skip to content

Mastering Python Timers: Effortlessly Managing Time with Timer Python


Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language, pure Python programs may run more slowly than their counterparts in compiled languages like C, Rust, and Java. In this tutorial, you’ll learn how to use a Python timer to monitor how quickly your programs are running.

In this tutorial, you’ll learn how to use:

  • time.perf_counter() to measure time in Python
  • Classes to keep state
  • Context managers to work with a block of code
  • Decorators to customize a function

You’ll also gain background knowledge into how classes, context managers, and decorators work. As you explore examples of each concept, you’ll be inspired to use one or several of them in your code, for timing code execution, as well as in other applications. Each method has its advantages, and you’ll learn which to use depending on the situation. Plus, you’ll have a working Python timer that you can use to monitor your programs!

Python Timers

First, you’ll take a look at some example code that you’ll use throughout the tutorial. Later, you’ll add a Python timer to this code to monitor its performance. You’ll also learn some of the simplest ways to measure the running time of this example.

Python Timer Functions

If you check out the built-in time module in Python, then you’ll notice several functions that can measure time:

  • monotonic()
  • perf_counter()
  • process_time()
  • time()

Python 3.7 introduced several new functions, like thread_time(), as well as nanosecond versions of all the functions above, named with an _ns suffix. For example, perf_counter_ns() is the nanosecond version of perf_counter().

To begin, let’s focus on perf_counter(). This function is used to measure the elapsed time in seconds, with the highest available resolution. It is commonly used to measure performance or the execution time of a piece of code.

Let’s see an example:

import time
start_time = time.perf_counter()
# Code to measure execution time
end_time = time.perf_counter()
execution_time = end_time - start_time
print(f"Execution Time: {execution_time} seconds")

In the above example, the time.perf_counter() function is used to get the starting time before the execution of the code to be measured. Then, time.sleep(1) is used to pause the execution for 1 second. Afterwards, the time.perf_counter() function is used again to get the ending time. The difference between the starting time and ending time gives us the execution time.

This is a basic example of how a Python timer can be implemented using the time.perf_counter() function. It allows you to measure the execution time of a specific section of your code. You can modify the code inside the timer to measure the execution time of different portions of your program.

Your First Python Timer

Now that you have a basic understanding of how the time.perf_counter() function works, you can create your own Python timer.

Here’s an example of a simple Python timer class:

import time
class Timer:
def __enter__(self):
self.start_time = time.perf_counter()
return self
def __exit__(self, *args):
self.end_time = time.perf_counter()
self.execution_time = self.end_time - self.start_time
print(f"Execution Time: {self.execution_time} seconds")

In this example, the Timer class is created with two methods: __enter__() and __exit__(). The __enter__() method is called when the timer is started, and it sets the start_time attribute to the current time using time.perf_counter(). It returns the instance of the class, which allows you to use it in a context manager.

The __exit__() method is called when the timer is exited. It calculates the end_time using time.perf_counter() and calculates the execution_time by subtracting the start_time from the end_time. Finally, it prints the execution time.

Here’s how you can use the Python timer class:

with Timer() as t:
# Code to measure execution time

In this example, the with statement is used to create a context manager for the timer. The code to be timed is placed inside the with block.

The output will be:

Execution Time: 1.000123456789 seconds

By using the Python timer class, you can easily measure the execution time of different sections of your code. You can also nest with statements to time multiple portions of your program.


In this tutorial, you learned how to use a Python timer to monitor the performance of your code. You explored different methods, such as the time.perf_counter() function, the Python timer class, context managers, and decorators.

Monitoring the execution time of your code is crucial for performance optimization and identifying bottlenecks. With the knowledge gained from this tutorial, you can now incorporate timers into your Python programs to monitor and improve their efficiency.