Gibt es ein High-Level-Profilmodul für Python?

Question

Ich mag meinen Python-Code profilieren. Ich bin gut bewusst cProfile, und ich benutze es, aber es ist zu Low-Level. (Zum Beispiel ist es nicht einmal eine einfache Möglichkeit, den Rückgabewert aus der Funktion, die Sie Profilierung zu fangen.)

Eines der Dinge, Ich mag würde tun. Ich eine Funktion in meinem Programm teilnehmen möchten, und legen Sie es profiliert werden on the fly , während das Programm läuft

Zum Beispiel, sagen wir mal ich eine Funktion heavy_func in meinem Programm. Ich möchte das Programm starten und haben die heavy_func Funktion selbst nicht profilieren. Aber irgendwann während der Laufzeit meines Programms möchte ich ändern heavy_func sich profilieren, während es läuft. (Wenn Sie sich fragen, wie ich Sachen manipulieren kann, während das Programm läuft. Ich kann es entweder aus der Debug-Sonde oder von der Shell, die in meine GUI-Anwendung integriert sind)

Gibt es ein Modul bereits geschrieben, Sachen wie diese macht? Ich kann es selbst schreiben, aber ich wollte nur vor fragen, so dass ich nicht das Rad neu zu erfinden werden.

Answer 1

schrieb ich mein eigenes Modul für sie. Ich nannte es cute_profile. Hier ist der Code . Hier sind die Tests .

Hier ist der Blog Post zu erklären, wie es zu benutzen.

Es ist ein Teil von GarlicSim , also wenn Sie es verwenden möchten, können Sie garlicsim installieren und from garlicsim.general_misc import cute_profile tun.

Wenn Sie es auf Python 3-Code verwenden möchten, installieren Sie einfach die Python 3 Gabel von garlicsim .

Hier ist ein veraltete Auszug aus dem Code:

import functools

from garlicsim.general_misc import decorator_tools

from . import base_profile


def profile_ready(condition=None, off_after=True, sort=2):
    '''
    Decorator for setting a function to be ready for profiling.

    For example:

        @profile_ready()
        def f(x, y):
            do_something_long_and_complicated()

    The advantages of this over regular `cProfile` are:

     1. It doesn't interfere with the function's return value.

     2. You can set the function to be profiled *when* you want, on the fly.

    How can you set the function to be profiled? There are a few ways:

    You can set `f.profiling_on=True` for the function to be profiled on the
    next call. It will only be profiled once, unless you set
    `f.off_after=False`, and then it will be profiled every time until you set
    `f.profiling_on=False`.

    You can also set `f.condition`. You set it to a condition function taking
    as arguments the decorated function and any arguments (positional and
    keyword) that were given to the decorated function. If the condition
    function returns `True`, profiling will be on for this function call,
    `f.condition` will be reset to `None` afterwards, and profiling will be
    turned off afterwards as well. (Unless, again, `f.off_after` is set to
    `False`.)

    `sort` is an `int` specifying which column the results will be sorted by.
    '''


    def decorator(function):

        def inner(function_, *args, **kwargs):

            if decorated_function.condition is not None:

                if decorated_function.condition is True or \
                   decorated_function.condition(
                       decorated_function.original_function,
                       *args,
                       **kwargs
                       ):

                    decorated_function.profiling_on = True

            if decorated_function.profiling_on:

                if decorated_function.off_after:
                    decorated_function.profiling_on = False
                    decorated_function.condition = None

                # This line puts it in locals, weird:
                decorated_function.original_function

                base_profile.runctx(
                    'result = '
                    'decorated_function.original_function(*args, **kwargs)',
                    globals(), locals(), sort=decorated_function.sort
                )                
                return locals()['result']

            else: # decorated_function.profiling_on is False

                return decorated_function.original_function(*args, **kwargs)

        decorated_function = decorator_tools.decorator(inner, function)

        decorated_function.original_function = function
        decorated_function.profiling_on = None
        decorated_function.condition = condition
        decorated_function.off_after = off_after
        decorated_function.sort = sort

        return decorated_function

    return decorator

Answer 2

Es kann ein wenig knifflige, aber diese Technik sollten Sie die Hilfe finden‘, ist es das, was Sie tun wollen. Sie sind ziemlich sicher, was Routine, die Sie auf das konzentrieren möchten. Wenn das der Routine ist müssen Sie konzentrieren sich auf, es wird Ihnen Recht geben. Wenn das eigentliche Problem (e) irgendwo anders ist, wird es Ihnen zeigen, wo sie sind.

Wenn Sie eine langweilige Liste der Gründe, warum, Blick hier .