Если вы просто хотите измерить время, прошедшее между двумя точками, вы можете использовать time.time():

import time

start = time.time()
print("hello")
end = time.time()
print(end - start)

Это дает время выполнения в секундах.

Другой вариант, начиная с версии 3.3, может заключаться в использовании perf_counter или _ 4_, в зависимости от ваших требований. До версии 3.3 рекомендовалось использовать time.clock (спасибо Янтарь). Однако в настоящее время он устарел:

В Unix вернуть текущее время процессора в виде числа с плавающей запятой, выраженного в секундах. Точность и, по сути, само определение значения «процессорного времени» зависит от одноименной функции Си.

В Windows эта функция возвращает часы настенных часов, прошедшие с момента первого вызова этой функции, в виде числа с плавающей запятой на основе функции Win32 QueryPerformanceCounter(). Разрешение обычно лучше одной микросекунды.

Не рекомендуется, начиная с версии 3.3: поведение этой функции зависит от платформы: вместо этого используйте perf_counter() или process_time(), в зависимости от ваших требований, чтобы иметь четко определенное поведение.

Используйте timeit.default_timer вместо timeit.timeit. Первый автоматически обеспечивает лучшие часы, доступные на вашей платформе и версии Python:

from timeit import default_timer as timer

start = timer()
# ...
end = timer()
print(end - start) # Time in seconds, e.g. 5.38091952400282

timeit.default_timer назначается time.time () или времени .clock () в зависимости от ОС. В Python 3.3+ default_timer равен time.perf_counter () на всех платформах. См. Python - time.clock () vs. time.time () - точность?

Смотрите также:

• Оптимизация кода
• Как оптимизировать скорость

Только Python 3:

Поскольку time.clock () устарел в Python 3.3, вы захотите использовать time.perf_counter() для общесистемной синхронизации, или time.process_time() для синхронизации всего процесса, как вы раньше используйте time.clock():

import time

t = time.process_time()
#do some stuff
elapsed_time = time.process_time() - t

Новая функция process_time не будет включать время, прошедшее во время сна.

Время измерения в секундах:

from timeit import default_timer as timer
from datetime import timedelta

start = timer()
end = timer()
print(timedelta(seconds=end-start))

Вывод:

0:00:01.946339

Учитывая функцию, которую вы хотите использовать,

test.py:

def foo(): 
    # print "hello"   
    return "hello"

Самый простой способ использовать timeit - вызвать его из командной строки:

% python -mtimeit -s'import test' 'test.foo()'
1000000 loops, best of 3: 0.254 usec per loop

Не пытайтесь использовать time.time или time.clock (наивно) для сравнения скорости функций. Они могут дать вводящие в заблуждение результаты.

PS. Не помещайте операторы печати в функцию, которую вы хотите отсчитать; в противном случае измеренное время будет зависеть от скорость терминала.

Это интересно сделать с помощью диспетчера контекста, который автоматически запоминает время начала при входе в блок with, а затем фиксирует время окончания при выходе из блока. С помощью небольшой уловки вы даже можете получить текущий счет прошедшего времени внутри блока с помощью той же функции диспетчера контекста.

В основной библиотеке этого нет (но, вероятно, должно быть). Оказавшись на месте, вы можете делать такие вещи, как:

with elapsed_timer() as elapsed:
    # some lengthy code
    print( "midpoint at %.2f seconds" % elapsed() )  # time so far
    # other lengthy code

print( "all done at %.2f seconds" % elapsed() )

Вот код contextmanager, достаточный для решения этой задачи:

from contextlib import contextmanager
from timeit import default_timer

@contextmanager
def elapsed_timer():
    start = default_timer()
    elapser = lambda: default_timer() - start
    yield lambda: elapser()
    end = default_timer()
    elapser = lambda: end-start

И немного исполняемого демонстрационного кода:

import time

with elapsed_timer() as elapsed:
    time.sleep(1)
    print(elapsed())
    time.sleep(2)
    print(elapsed())
    time.sleep(3)

Обратите внимание, что по замыслу этой функции возвращаемое значение elapsed() фиксируется при выходе из блока, и последующие вызовы возвращают ту же продолжительность (около 6 секунд в этом игрушечном примере).

Я предпочитаю это. timeit документ слишком запутан.

from datetime import datetime 

start_time = datetime.now() 

# INSERT YOUR CODE 

time_elapsed = datetime.now() - start_time 

print('Time elapsed (hh:mm:ss.ms) {}'.format(time_elapsed))

Обратите внимание, что здесь не происходит никакого форматирования, я просто написал hh:mm:ss в распечатке, чтобы можно было интерпретировать time_elapsed

Вот еще один способ сделать это:

>> from pytictoc import TicToc
>> t = TicToc() # create TicToc instance
>> t.tic() # Start timer
>> # do something
>> t.toc() # Print elapsed time
Elapsed time is 2.612231 seconds.

По сравнению с традиционным способом:

>> from time import time
>> t1 = time()
>> # do something
>> t2 = time()
>> elapsed = t2 - t1
>> print('Elapsed time is %f seconds.' % elapsed)
Elapsed time is 2.612231 seconds.

Установка:

pip install pytictoc

Дополнительные сведения см. На странице PyPi.

Вот мои выводы после того, как я прочитал здесь много хороших ответов, а также несколько других статей.

Во-первых, если вы спорите между timeit и time.time, у timeit есть два преимущества:

1. timeit выбирает лучший таймер, доступный для вашей ОС и версии Python.
2. timeit отключает сборку мусора, однако это не то, что вам нужно или не нужно.

Теперь проблема в том, что timeit не так просто использовать, потому что он требует настройки, и все становится некрасиво, когда у вас есть куча импорта. В идеале вам просто нужен декоратор или используйте with блок и измеряйте время. К сожалению, для этого нет ничего встроенного, поэтому у вас есть два варианта:

Вариант 1. Используйте библиотеку бюджета времени

timebudget - это универсальная и очень простая библиотека, которую можно использовать всего в одной строке кода после установки pip.

@timebudget  # Record how long this function takes
def my_method():
    # my code

Вариант 2. Используйте мой небольшой модуль

Ниже я создал небольшой служебный модуль синхронизации под названием Timing.py . Просто перетащите этот файл в свой проект и начните им пользоваться. Единственная внешняя зависимость - это runstats, опять же небольшого размера.

Теперь вы можете задать время для любой функции, просто поставив перед ней декоратор:

import timing

@timing.MeasureTime
def MyBigFunc():
    #do something time consuming
    for i in range(10000):
        print(i)

timing.print_all_timings()

Если вы хотите отследить часть кода, просто поместите ее в блок with:

import timing

#somewhere in my code

with timing.MeasureBlockTime("MyBlock"):
    #do something time consuming
    for i in range(10000):
        print(i)

# rest of my code

timing.print_all_timings()

Преимущества:

Есть несколько полуобеспеченных версий, поэтому я хочу выделить несколько основных моментов:

1. Используйте таймер из timeit вместо time.time по причинам, описанным ранее.
2. Вы можете отключить сборщик мусора на время, если хотите.
3. Декоратор принимает функции с именованными или безымянными параметрами.
4. Возможность отключения печати во время блока (используйте with timing.MeasureBlockTime() as t, а затем t.elapsed).
5. Возможность держать gc включенным для синхронизации блока.

Использование time.time для измерения выполнения дает вам общее время выполнения ваших команд, включая время, затраченное другими процессами на вашем компьютере. Это время, когда пользователь замечает, но это нехорошо, если вы хотите сравнить разные фрагменты кода / алгоритмы / функции / ...

Дополнительная информация о timeit:

• Использование модуля timeit
• timeit - время выполнения небольших фрагментов кода Python

Если вы хотите глубже понять профилирование:

• http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code
• Как профилировать скрипт Python?

Обновление: я много использовал http://pythonhosted.org/line_profiler/ во время в прошлом году и считаю его очень полезным и рекомендую использовать его вместо модуля профиля Pythons.

Самый простой способ рассчитать продолжительность операции:

import time

start_time = time.monotonic()

<operations, programs>

print('seconds: ', time.monotonic() - start_time)

Официальные документы здесь.

Модули python cProfile и pstats предлагают отличную поддержку для измерения времени, затраченного на выполнение определенных функций, без необходимости добавлять какой-либо код вокруг существующих функций.

Например, если у вас есть скрипт python timeFunctions.py:

import time

def hello():
    print "Hello :)"
    time.sleep(0.1)

def thankyou():
    print "Thank you!"
    time.sleep(0.05)

for idx in range(10):
    hello()

for idx in range(100):
    thankyou()

Чтобы запустить профилировщик и сгенерировать статистику для файла, вы можете просто запустить:

python -m cProfile -o timeStats.profile timeFunctions.py

При этом используется модуль cProfile для профилирования всех функций в timeFunctions.py и сбор статистики в файле timeStats.profile. Обратите внимание, что нам не нужно было добавлять какой-либо код в существующий модуль (timeFunctions.py), и это можно сделать с любым модулем.

Получив файл статистики, вы можете запустить модуль pstats следующим образом:

python -m pstats timeStats.profile

Это запускает интерактивный браузер статистики, который дает вам много хороших функций. Для вашего конкретного случая использования вы можете просто проверить статистику своей функции. В нашем примере проверка статистики для обеих функций показывает нам следующее:

Welcome to the profile statistics browser.
timeStats.profile% stats hello
<timestamp>    timeStats.profile

         224 function calls in 6.014 seconds

   Random listing order was used
   List reduced from 6 to 1 due to restriction <'hello'>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       10    0.000    0.000    1.001    0.100 timeFunctions.py:3(hello)

timeStats.profile% stats thankyou
<timestamp>    timeStats.profile

         224 function calls in 6.014 seconds

   Random listing order was used
   List reduced from 6 to 1 due to restriction <'thankyou'>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      100    0.002    0.000    5.012    0.050 timeFunctions.py:7(thankyou)

Фиктивный пример мало что дает, но дает представление о том, что можно сделать. Лучшее в этом подходе - то, что мне не нужно редактировать какой-либо из моего существующего кода, чтобы получить эти числа и, очевидно, помочь с профилированием.

Вот еще один диспетчер контекста для кода времени -

Использование:

from benchmark import benchmark

with benchmark("Test 1+1"):
    1+1
=>
Test 1+1 : 1.41e-06 seconds

или, если вам нужна временная стоимость

with benchmark("Test 1+1") as b:
    1+1
print(b.time)
=>
Test 1+1 : 7.05e-07 seconds
7.05233786763e-07

benchmark.py:

from timeit import default_timer as timer

class benchmark(object):

    def __init__(self, msg, fmt="%0.3g"):
        self.msg = msg
        self.fmt = fmt

    def __enter__(self):
        self.start = timer()
        return self

    def __exit__(self, *args):
        t = timer() - self.start
        print(("%s : " + self.fmt + " seconds") % (self.msg, t))
        self.time = t

По материалам http://dabeaz.blogspot.fr/2010/02/context-manager-for-timing-benchmarks.html

Вот крошечный класс таймера, который возвращает строку «чч: мм: сс»:

class Timer:
  def __init__(self):
    self.start = time.time()

  def restart(self):
    self.start = time.time()

  def get_time_hhmmss(self):
    end = time.time()
    m, s = divmod(end - self.start, 60)
    h, m = divmod(m, 60)
    time_str = "%02d:%02d:%02d" % (h, m, s)
    return time_str

Использование:

# Start timer
my_timer = Timer()

# ... do something

# Get time string:
time_hhmmss = my_timer.get_time_hhmmss()
print("Time elapsed: %s" % time_hhmmss )

# ... use the timer again
my_timer.restart()

# ... do something

# Get time:
time_hhmmss = my_timer.get_time_hhmmss()

# ... etc

Используйте модуль профилировщика. Это дает очень подробный профиль.

import profile
profile.run('main()')

он выводит что-то вроде:

          5 function calls in 0.047 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.000    0.000 :0(exec)
        1    0.047    0.047    0.047    0.047 :0(setprofile)
        1    0.000    0.000    0.000    0.000 <string>:1(<module>)
        0    0.000             0.000          profile:0(profiler)
        1    0.000    0.000    0.047    0.047 profile:0(main())
        1    0.000    0.000    0.000    0.000 two_sum.py:2(twoSum)

Я нашел это очень информативным.

(Только с Ipython) вы можете использовать % timeit для измерить среднее время обработки:

def foo():
    print "hello"

а потом:

%timeit foo()

результат будет примерно таким:

10000 loops, best of 3: 27 µs per loop

Мне нравится простой (python 3):

from timeit import timeit

timeit(lambda: print("hello"))

Вывод составляет микросекунды для одного выполнения:

2.430883963010274

Объяснение: timeit по умолчанию выполняет анонимную функцию 1 миллион раз, и результат отображается в секундах. Следовательно, результат для 1 однократного выполнения будет такой же, но в среднем за микросекунды.

Для медленных операций добавьте меньшее количество итераций, иначе вы можете ждать бесконечно:

import time

timeit(lambda: time.sleep(1.5), number=1)

Вывод всегда составляет секунды для общего количества итераций:

1.5015795179999714

на python3:

from time import sleep, perf_counter as pc
t0 = pc()
sleep(1)
print(pc()-t0)

элегантный и короткий.

Еще один способ использовать timeit:

from timeit import timeit

def func():
    return 1 + 1

time = timeit(func, number=1)
print(time)

Чтобы получить представление о рекурсивном вызове каждой функции, выполните:

%load_ext snakeviz
%%snakeviz

Достаточно взять эти 2 строки кода из записной книжки Jupyter и создать красивую интерактивную диаграмму. Например:

Вот код. Опять же, две строки, начинающиеся с %, являются единственными дополнительными строками кода, необходимыми для использования snakeviz:

# !pip install snakeviz
%load_ext snakeviz
import glob
import hashlib

%%snakeviz

files = glob.glob('*.txt')
def print_files_hashed(files):
    for file in files:
        with open(file) as f:
            print(hashlib.md5(f.read().encode('utf-8')).hexdigest())
print_files_hashed(files)

Также кажется возможным запускать snakeviz вне ноутбуков. Дополнительная информация на сайте snakeviz.

Что-то вроде супер позднего ответа, но, возможно, для кого-то это служит какой-то цели. Я считаю, что это очень чистый способ сделать это.

import time

def timed(fun, *args):
    s = time.time()
    r = fun(*args)
    print('{} execution took {} seconds.'.format(fun.__name__, time.time()-s))
    return(r)

timed(print, "Hello")

Имейте в виду, что print - это функция в Python 3, а не в Python 2.7. Однако он работает с любой другой функцией. Ваше здоровье!

Вот довольно хорошо документированный декоратор с полным набором подсказок, который я использую как общую утилиту:

from functools import wraps
from time import perf_counter
from typing import Any, Callable, Optional, TypeVar, cast

F = TypeVar("F", bound=Callable[..., Any])


def timer(prefix: Optional[str] = None, precision: int = 6) -> Callable[[F], F]:
    """Use as a decorator to time the execution of any function.

    Args:
        prefix: String to print before the time taken.
            Default is the name of the function.
        precision: How many decimals to include in the seconds value.

    Examples:
        >>> @timer()
        ... def foo(x):
        ...     return x
        >>> foo(123)
        foo: 0.000...s
        123
        >>> @timer("Time taken: ", 2)
        ... def foo(x):
        ...     return x
        >>> foo(123)
        Time taken: 0.00s
        123

    """
    def decorator(func: F) -> F:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            nonlocal prefix
            prefix = prefix if prefix is not None else f"{func.__name__}: "
            start = perf_counter()
            result = func(*args, **kwargs)
            end = perf_counter()
            print(f"{prefix}{end - start:.{precision}f}s")
            return result
        return cast(F, wrapper)
    return decorator

Пример использования:

from timer import timer


@timer(precision=9)
def takes_long(x: int) -> bool:
    return x in (i for i in range(x + 1))


result = takes_long(10**8)
print(result)

Выход:

takes_long: 4.942629056s
True

Доктесты можно проверить с помощью:

$ python3 -m doctest --verbose -o=ELLIPSIS timer.py

И тип подсказывает:

$ mypy timer.py

Вы можете использовать timeit.

Вот пример того, как протестировать naive_func, который принимает параметр, с помощью Python REPL:

>>> import timeit                                                                                         

>>> def naive_func(x):                                                                                    
...     a = 0                                                                                             
...     for i in range(a):                                                                                
...         a += i                                                                                        
...     return a                                                                                          

>>> def wrapper(func, *args, **kwargs):                                                                   
...     def wrapper():                                                                                    
...         return func(*args, **kwargs)                                                                  
...     return wrapper                                                                                    

>>> wrapped = wrapper(naive_func, 1_000)                                                                  

>>> timeit.timeit(wrapped, number=1_000_000)                                                              
0.4458435332577161  

Вам не нужна функция-оболочка, если функция не имеет параметров.

Мы также можем преобразовать время в удобочитаемое время.

import time, datetime

start = time.clock()

def num_multi1(max):
    result = 0
    for num in range(0, 1000):
        if (num % 3 == 0 or num % 5 == 0):
            result += num

    print "Sum is %d " % result

num_multi1(1000)

end = time.clock()
value = end - start
timestamp = datetime.datetime.fromtimestamp(value)
print timestamp.strftime('%Y-%m-%d %H:%M:%S')

print_elapsed_time функция ниже

def print_elapsed_time(prefix=''):
    e_time = time.time()
    if not hasattr(print_elapsed_time, 's_time'):
        print_elapsed_time.s_time = e_time
    else:
        print(f'{prefix} elapsed time: {e_time - print_elapsed_time.s_time:.2f} sec')
        print_elapsed_time.s_time = e_time

используйте это таким образом

print_elapsed_time()
.... heavy jobs ...
print_elapsed_time('after heavy jobs')
.... tons of jobs ...
print_elapsed_time('after tons of jobs')

результат

after heavy jobs elapsed time: 0.39 sec
after tons of jobs elapsed time: 0.60 sec  

Плюсы и минусы этой функции в том, что вам не нужно передавать время начала

Я сделал для этого библиотеку, если вы хотите измерить функцию, вы можете просто сделать это так

from pythonbenchmark import compare, measure
import time

a,b,c,d,e = 10,10,10,10,10
something = [a,b,c,d,e]

@measure
def myFunction(something):
    time.sleep(0.4)

@measure
def myOptimizedFunction(something):
    time.sleep(0.2)

myFunction(input)
myOptimizedFunction(input)

https://github.com/Karlheinzniebuhr/pythonbenchmark

Как измерить время между двумя операциями. Сравните время двух операций.

import time

b = (123*321)*123
t1 = time.time()

c = ((9999^123)*321)^123
t2 = time.time()

print(t2-t1)

7.987022399902344e-05

Хотя в вопросе это строго не задается, довольно часто требуется простой и единообразный способ постепенного измерения времени, прошедшего между несколькими строками кода.

Если вы используете Python 3.8 или выше, вы можете использовать выражения присваивания (он же оператор моржа), чтобы добиться этого довольно элегантным способом:

import time

start, times = time.perf_counter(), {}

print("hello")
times["print"] = -start + (start := time.perf_counter())

time.sleep(1.42)
times["sleep"] = -start + (start := time.perf_counter())

a = [n**2 for n in range(10000)]
times["pow"] = -start + (start := time.perf_counter())

print(times)

=>

{'print': 2.193450927734375e-05, 'sleep': 1.4210970401763916, 'power': 0.005671024322509766}

Этот уникальный подход на основе классов предлагает печатаемое строковое представление, настраиваемое округление и удобный доступ к истекшему времени в виде строки или числа с плавающей запятой. Он был разработан с помощью Python 3.7.

import datetime
import timeit


class Timer:
    """Measure time used."""
    # Ref: https://stackoverflow.com/a/57931660/

    def __init__(self, round_ndigits: int = 0):
        self._round_ndigits = round_ndigits
        self._start_time = timeit.default_timer()

    def __call__(self) -> float:
        return timeit.default_timer() - self._start_time

    def __str__(self) -> str:
        return str(datetime.timedelta(seconds=round(self(), self._round_ndigits)))

Использование:

# Setup timer
>>> timer = Timer()

# Access as a string
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:03.
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:04.

# Access as a float
>>> timer()
6.841332235
>>> timer()
7.970274425

Измеряйте время выполнения небольших фрагментов кода.

Единица времени: измеряется в секундах с плавающей запятой.

import timeit
t = timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))')
t.timeit()
t.repeat()
>[1.2934070999999676, 1.3335035000000062, 1.422568500000125]

Метод repeat () позволяет вызывать timeit () несколько раз и возвращать список результатов.

repeat(repeat=3)¶

С помощью этого списка мы можем взять среднее значение за все времена.

По умолчанию timeit () временно отключает сборку мусора на время. time.Timer () решает эту проблему.

Плюсы:

timeit.Timer () делает независимые тайминги более сопоставимыми. Gc может быть важным компонентом производительности измеряемой функции. Если это так, gc (сборщик мусора) можно повторно включить в качестве первого оператора в строке настройки. Например:

timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))',setup='gc.enable()')

Источник Документы Python!

В качестве лямбды получите прошедшее время и отметки времени:

import datetime
t_set = lambda: datetime.datetime.now().astimezone().replace(microsecond=0)
t_diff = lambda t: str(t_set() - t)
t_stamp = lambda t=None: str(t) if t else str(t_set())

На практике:

>>> 
>>> t_set()
datetime.datetime(2021, 3, 21, 1, 25, 17, tzinfo=datetime.timezone(datetime.timedelta(days=-1, seconds=61200), 'PDT'))
>>> t = t_set()
>>> t_diff(t)
'0:00:14'
>>> t_diff(t)
'0:00:23'
>>> t_stamp()
'2021-03-21 01:25:57-07:00'
>>> t_stamp(t)
'2021-03-21 01:25:22-07:00'
>>> 

Если вы хотите иметь возможность удобно синхронизировать функции, вы можете использовать простой декоратор:

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        original_return_val = func(*args, **kwargs)
        end = time.time()
        print("time elapsed in ", func.__name__, ": ", end - start, sep='')
        return original_return_val

    return wrapper

Вы можете использовать его для функции, которую хотите отсрочить следующим образом:

@timing_decorator
def function_to_time():
    time.sleep(1)

Затем каждый раз, когда вы вызываете function_to_time, он будет печатать, сколько времени это заняло, и имя функции, для которой требуется время.

на основе решения contextmanager, предоставленного https://stackoverflow.com/a/30024601/5095636, ниже - бесплатная версия лямбда , поскольку flake8 предупреждает об использовании лямбда в соответствии с E731:

from contextlib import contextmanager
from timeit import default_timer

@contextmanager
def elapsed_timer():
    start_time = default_timer()

    class _Timer():
      start = start_time
      end = default_timer()
      duration = end - start

    yield _Timer

    end_time = default_timer()
    _Timer.end = end_time
    _Timer.duration = end_time - start_time

тестовое задание:

from time import sleep

with elapsed_timer() as t:
    print("start:", t.start)
    sleep(1)
    print("end:", t.end)

t.start
t.end
t.duration

Модуль timeit хорош для синхронизации небольшого фрагмента кода Python. Его можно использовать как минимум в трех формах:

1- Как модуль командной строки

python2 -m timeit 'for i in xrange(10): oct(i)' 

2- Для короткого кода передайте его в качестве аргументов.

import timeit
timeit.Timer('for i in xrange(10): oct(i)').timeit()

3- Для более длинного кода:

import timeit
code_to_test = """
a = range(100000)
b = []
for i in a:
    b.append(i*2)
"""
elapsed_time = timeit.timeit(code_to_test, number=100)/100
print(elapsed_time)

Время также можно измерить с помощью магической функции% timeit следующим образом:

%timeit -t -n 1 print("hello")

n 1 предназначен для выполнения функции только 1 раз.

Помимо %timeit в ipython вы также можете использовать %%timeit для многострочных фрагментов кода:

In [1]: %%timeit
   ...: complex_func()
   ...: 2 + 2 == 5
   ...:
   ...:

1 s ± 1.93 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Также его можно использовать в блокноте jupyter таким же образом, просто введите magic %%timeit в начале ячейки.