The profiling package is an interactive continuous Python profiler. It is inspired from Unity 3D profiler. This package provides these features:

Build Status Coverage Status


Install the latest release via PyPI:

$ pip install profiling


To profile a single program, simply run the profiling command:

$ profiling

Then an interactive viewer will be executed:

If your program uses greenlets, choose greenlet timer:

$ profiling --timer=greenlet

With --dump option, it saves the profiling result to a file. You can browse the saved result by using the view subcommand:

$ profiling --dump=your-program.prf
$ profiling view your-program.prf

If your script reads sys.argv, append your arguments after --. It isolates your arguments from the profiling command:

$ profiling -- --your-flag --your-param=42

Live Profiling

If your program has a long life time like a web server, a profiling result at the end of program is not helpful enough. Probably you need a continuous profiler. It can be achived by the live-profile subcommand:

$ profiling live-profile

See a demo:


There's a live-profiling server also. The server doesn't profile the program at ordinary times. But when a client connects to the server, it starts to profile and reports the results to the all connected clients.

Start a profling server by the remote-profile subcommand:

$ profiling remote-profile --bind

And also run a client for the server by the view subcommand:

$ profiling view

Statistical Profiling

TracingProfiler, the default profiler, implements a deterministic profiler for deep call graph. Of course, it has heavy overhead. The overhead can pollute your profiling result or can make your application to be slow.

In contrast, SamplingProfiler implements a statistical profiler. Like other statistical profilers, it also has only very cheap overhead. When you profile you can choose it by just --sampling (shortly -S) option:

$ profiling live-profile -S

Timeit then Profiling

Do you use timeit to check the performance of your code?

$ python -m timeit -s 'from trueskill import *' 'rate_1vs1(Rating(), Rating())'
1000 loops, best of 3: 722 usec per loop

If you want to profile the checked code, simply use the timeit subcommand:

$ profiling timeit -s 'from trueskill import *' 'rate_1vs1(Rating(), Rating())'

Profiling from Code

You can also profile your program by profiling.tracing.TracingProfiler or profiling.sampling.SamplingProfiler directly:

from profiling.tracing import TracingProfiler

# profile your program.
profiler = TracingProfiler()
...  # run your program.

# or using context manager.
with profiler:
    ...  # run your program.

# view and interact with the result.
# or save profile data to file

Viewer Key Bindings



Tracing Profiler

Sampling Profiler


There are some additional requirements to run the test code, which can be installed by running the following command.

$ pip install $(python test/ test/requirements.txt)

Then you should be able to run pytest.

$ pytest -v

Thanks to


Written by Heungsub Lee at What! Studio in Nexon, and distributed under the BSD 3-Clause license.