¿Hay un módulo de perfiles de alto nivel para Python?

Question

Quiero perfil my código Python. Soy bien consciente de cProfile, y lo uso, pero es demasiado bajo nivel. (Por ejemplo, no hay ni siquiera una forma sencilla de capturar el valor de retorno de la función que está perfilado.)

Una de las cosas que me gustaría hacer:. Quiero tener una función en mi programa y la pusieron a estar perfilada sobre la marcha mientras se ejecuta el programa

Por ejemplo, digamos que tengo una heavy_func función en mi programa. Quiero empezar el programa y tienen la función heavy_func no perfilarse. Pero en algún momento durante el tiempo de ejecución de mi programa, yo quiero cambiar heavy_func a perfilarse mientras se está ejecutando. (Si usted se pregunta cómo puedo manipular la materia mientras que el programa se está ejecutando:. Puedo hacerlo bien desde la sonda de depuración o de la cáscara que está integrado en mi aplicación GUI)

¿Hay un módulo escrito ya que no hace cosas como esta? Puedo escribir yo mismo pero yo sólo quería preguntar antes, así que no voy a reinventar la rueda.

Answer 1

escribí mi propio módulo para ello. Lo llamé cute_profile. Aquí está el código . Aquí están las pruebas .

esta es la pagina post explicando cómo usarlo.

Es parte de GarlicSim , así que si quieres usarlo puede instalar garlicsim y hacer from garlicsim.general_misc import cute_profile.

Si desea usarlo en código Python 3, sólo tiene que instalar el Python 3 tenedor de garlicsim .

Aquí hay un anticuado extracto del código:

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

Puede ser una endiablada, pero poco esta técnica debe ayudar a encontrar los 'cuellos de botella', que eso es lo que quiere hacer. Estás bastante seguro de lo que la rutina que desea enfocar. Si esa es la rutina que necesita centrarse en, resultará que la derecha. Si el verdadero problema (s) están en otra parte, se le mostrará dónde están.

Si desea una lista de razones por las tediosa, aquí .