Jupyter Notebook Timeit: A Tutorial on Profiling Code


In Python programming, it’s important to optimize code for efficient execution. One way to do this is by profiling the code to identify and eliminate potential bottlenecks. Jupyter Notebook provides a tool called “timeit” that allows you to measure the execution time of small code snippets. This can be useful in identifying which parts of your code are taking the most time to execute.

Timeit in Base Python

You technically don’t need Jupyter Notebook to use timeit, in fact, using timeit is simple. All you need to do is import the module and call its “timeit” function, passing in the code snippet as a string and the number of times you want it to run. The function will then return the average time it took for the snippet to execute.

import timeit

timeit.timeit('x = sum(range(10))')

In this example, we’re measuring the execution time of a simple operation: summing up all integers from 0 to 9 using the built-in “sum” function. The function will run this operation a default of one million times, which is enough to get an accurate measurement of its execution time.

The output of this code will be the average time it took for the operation to run, measured in seconds. By default, timeit will also print out the number of loops and iterations it performed, as well as the best and worst times recorded.

In addition to measuring simple operations like this one, you can also use timeit to compare different implementations of a function or algorithm. By running each implementation through timeit and comparing their execution times, you can determine which one is more efficient and should be used in your final code.

Overall, timeit is a powerful tool that can help you optimize your Python code for faster execution. Whether you’re working on a small script or a large project, taking the time to profile your code with timeit can pay off in big performance gains.

What is Profiling?

Profiling is a technique used to measure the performance of code and identify areas that can be optimized for better efficiency. In other words, profiling helps us understand how long different parts of our code take to execute and where we should focus our efforts to improve its speed.

There are different types of profiling techniques, but one common method is to use timing functions. Python has a built-in module called `timeit` that provides an easy way to time small bits of Python code.

The `timeit` module has both a command line interface and a callable one. The command line interface allows you to time small bits of code from your terminal or command prompt, while the callable interface allows you to integrate timing into your Python code.

To use `timeit` in a Jupyter notebook, we can simply import it and use the `%timeit` magic command followed by the code we want to time. The `%timeit` command runs the code multiple times and returns the average execution time.

Here’s an example:

import timeit

def my_function():
    return [x**2 for x in range(1000)]

%timeit my_function()

In this example, we define a function that generates a list of 1000 squared numbers using a list comprehension. We then use the `%timeit` magic command to time how long it takes to execute the `my_function()` function.

When we run this code in a Jupyter notebook, we get output that looks something like this:

This tells us that on average, it takes 168 microseconds (or 0.168 milliseconds) to execute our function. It also tells us that the function was executed 1000 times (the default number of loops used by `%timeit`) and that the reported time is the best of 7 runs.

By profiling our code with `timeit`, we can identify parts of our code that are taking longer to execute than we’d like and work on optimizing them for better performance.

Why Use Timeit in Jupyter Notebook?

When it comes to optimizing code, it’s important to identify which parts of your code are taking up the most time. This is where profiling comes in. Profiling allows you to analyze your code’s performance and identify areas where improvements can be made.

One tool for profiling code in Jupyter Notebook is the timeit module. The timeit module provides a simple way to measure the execution time of small bits of Python code.

Using timeit in Jupyter Notebook has several benefits. First, it’s easy to use and requires minimal setup. Second, it provides accurate timing information by running the code multiple times and averaging the results. Finally, it allows you to compare the performance of different implementations and make informed decisions about which approach to use.

In the next section, we’ll dive into how to use timeit in Jupyter Notebook to profile your Python code.

Using Timeit in Jupyter Notebook

Python developers often need to optimize their code for better performance. Profiling the code is one of the ways to identify the bottlenecks and optimize the code accordingly. Jupyter Notebook provides a simple and efficient way to profile your Python code using the Timeit module. In this section, we will discuss how to use Timeit in Jupyter Notebook to profile your Python code.

Step 1: Importing Timeit

The first step is to import the Timeit module in your Jupyter Notebook. You can do this by running the following command:

import timeit

Step 2: Writing the Code to be Profiled

The next step is to write the code that you want to profile. For example, let’s say you want to profile a simple function that sorts a list of integers. Here’s an example of such a function:

def sort_list():
    my_list = [4, 2, 7, 1, 3, 5, 8, 6]

Step 3: Using Timeit to Profile the Code

Once you have written your code, you can use Timeit to profile it. The Timeit module provides three functions that you can use for profiling: timeit(), repeat(), and best(). Let’s take a closer look at each of these functions.

The Timeit Function

The timeit() function takes two arguments: the code that you want to profile and the number of times you want to run it. Here’s an example of how to use timeit() to profile our sort_list() function:

timeit.timeit('sort_list()', globals=globals(), number=1000)

In this example, we are running our sort_list() function 1000 times and measuring the time it takes to run.

The Repeat Function

The repeat() function takes the same arguments as timeit(), but it runs the code multiple times and returns a list of the execution times. Here’s an example:

timeit.repeat('sort_list()', globals=globals(), number=1000, repeat=5)

In this example, we are running our sort_list() function 1000 times and repeating this process 5 times.

The Best Function

The best() function is similar to repeat(), but it returns only the best execution time. Here’s an example:

timeit.best('sort_list()', globals=globals(), number=1000, repeat=5)

In this example, we are running our sort_list() function 1000 times and repeating this process 5 times. The best() function returns only the best execution time out of the 5 repetitions.

Step 4: Interpreting the Results

Once you have run your code using Timeit, you will get a list of execution times. You can use these results to identify bottlenecks in your code and optimize it accordingly. The results will also help you compare different implementations of the same functionality and choose the one that performs better.


In conclusion, Jupyter Notebook’s built-in `timeit` module is a powerful tool for profiling code and measuring its performance. By using `timeit`, you can quickly identify which parts of your code are taking the most time to execute and optimize them accordingly.

It is important to note that `timeit` measures the time taken for a given piece of code to run on your computer, which means that results may vary depending on the hardware and software environment. It is also important to consider other factors that may affect performance, such as memory usage and input size.

Overall, `timeit` is a valuable tool for any Python programmer looking to improve the efficiency of their code. By taking the time to profile your code and optimize it where necessary, you can create faster and more reliable programs that will benefit both you and your users.
Interested in learning more? Check out our Introduction to Python course!

How to Become a Data Scientist PDF

Your FREE Guide to Become a Data Scientist

Discover the path to becoming a data scientist with our comprehensive FREE guide! Unlock your potential in this in-demand field and access valuable resources to kickstart your journey.

Don’t wait, download now and transform your career!

Pierian Training
Pierian Training
Pierian Training is a leading provider of high-quality technology training, with a focus on data science and cloud computing. Pierian Training offers live instructor-led training, self-paced online video courses, and private group and cohort training programs to support enterprises looking to upskill their employees.

You May Also Like

Data Science, Tutorials

Guide to NLTK – Natural Language Toolkit for Python

Introduction Natural Language Processing (NLP) lies at the heart of countless applications we use every day, from voice assistants to spam filters and machine translation. It allows machines to understand, interpret, and generate human language, bridging the gap between humans and computers. Within the vast landscape of NLP tools and techniques, the Natural Language Toolkit […]

Machine Learning, Tutorials

GridSearchCV with Scikit-Learn and Python

Introduction In the world of machine learning, finding the optimal set of hyperparameters for a model can significantly impact its performance and accuracy. However, searching through all possible combinations manually can be an incredibly time-consuming and error-prone process. This is where GridSearchCV, a powerful tool provided by Scikit-Learn library in Python, comes to the rescue. […]

Python Basics, Tutorials

Plotting Time Series in Python: A Complete Guide

Introduction Time series data is a type of data that is collected over time at regular intervals. It can be used to analyze trends, patterns, and behaviors over time. In order to effectively analyze time series data, it is important to visualize it in a way that is easy to understand. This is where plotting […]