Y at-il un module de profilage de haut niveau pour Python?

Question

Je veux mon profil code Python. Je suis bien conscient de cProfile, et je l'utilise, mais il est trop bas niveau. (Par exemple, il n'y a même pas un moyen simple d'attraper la valeur de retour de la fonction que vous profilage.)

L'une des choses que je voudrais faire. Je veux prendre une fonction dans mon programme et mis à profiler à la volée lors de l'exécution du programme

Par exemple, disons que j'ai une heavy_func fonction dans mon programme. Je veux démarrer le programme et ont la fonction heavy_func pas se profiler. Mais quelque temps au cours de l'exécution de mon programme, je veux changer heavy_func de se profiler alors qu'il est en cours d'exécution. (Si vous vous demandez comment je peux manipuler des choses alors que le programme est en cours d'exécution. Je peux le faire soit à partir de la sonde de débogage ou de la coquille qui est intégrée dans mon application GUI)

Y at-il un module déjà écrit qui fait des trucs comme ça? Je peux écrire moi-même, mais je voulais juste demander avant, donc je ne vais pas réinventer la roue.

Answer 1

J'ai écrit mon propre module pour cela. Je l'ai appelé cute_profile. Voici le de code. Voici les essais .

Voici le blog poster expliquant comment l'utiliser.

Il fait partie de GarlicSim , donc si vous voulez l'utiliser, vous pouvez install garlicsim et faire from garlicsim.general_misc import cute_profile.

Si vous voulez utiliser le code Python 3, il suffit d'installer le Python 3 fourchette de garlicsim .

Voici un dépassée extrait du 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

Il peut être un peu hallucinant, mais cette technique devrait vous aider à trouver les « goulots d'étranglement », ce qui est ce que vous voulez faire. Vous êtes assez sûr de ce que la routine que vous voulez vous concentrer sur. Si c'est la routine, vous devez vous concentrer sur, il vous donnera raison. Si le problème réel (s) sont un autre endroit, il vous montrera où ils sont.

Si vous voulez une liste fastidieuse de raisons pour lesquelles, .