Un décorateur que les profils d'un appel de méthode et enregistre le résultat de profilage

Je veux créer un décorateur que les profils d'une méthode et enregistre le résultat. Comment cela peut-il être fait?

Qu'entendez-vous par "profils"? Calendrier? Ou de la recherche de code pour l'optimiser? Si ce dernier, essayez ceci.

OriginalL'auteur Weholt | 2011-03-21

9

Le décorateur ressemblerait à quelque chose comme:
```
import time
import logging

def profile(func):
    def wrap(*args, **kwargs):
        started_at = time.time()
        result = func(*args, **kwargs)
        logging.info(time.time() - started_at)
        return result

    return wrap

@profile
def foo():
    pass
```
De toute façon, si vous voulez faire un peu de sérieux profilage je vous suggère d'utiliser le profil ou cProfile paquets.

N'est-ce pas ce qui était demandé? Il n'a jamais rien demandé à propos de chronométrage. Il a fait poser sur le profilage.
Sans doute l'importation de temps, pas de timeit.

OriginalL'auteur
56

Si vous voulez bon profilage au lieu de calendrier, vous pouvez utiliser une fonction non documentée de cProfile (à partir de cette question):
```
import cProfile

def profileit(func):
    def wrapper(*args, **kwargs):
        datafn = func.__name__ + ".profile" # Name the data file sensibly
        prof = cProfile.Profile()
        retval = prof.runcall(func, *args, **kwargs)
        prof.dump_stats(datafn)
        return retval

    return wrapper

@profileit
def function_you_want_to_profile(...)
    ...
```
Si vous voulez plus de contrôle sur le nom de fichier, puis vous aurez besoin d'une autre couche d'indirection:
```
import cProfile

def profileit(name):
    def inner(func):
        def wrapper(*args, **kwargs):
            prof = cProfile.Profile()
            retval = prof.runcall(func, *args, **kwargs)
            # Note use of name from outer scope
            prof.dump_stats(name)
            return retval
        return wrapper
    return inner

@profileit("profile_for_func1_001")
def func1(...)
    ...
```
Il semble compliqué, mais si vous le suivez, étape par étape (et notez la différence, en invoquant le profiler), il devrait être clair.

C'est pas très clair ce que some_variation_on est. J'ai pensé que sa un fichier en tant que dump_stats prend un fichier? Mais il ressemble à une méthode.
c'est juste une hypothétique fonction qui prend le nom de la fonction et la transforme en un nom de fichier, par exemple. func.__name__ + .profile. Il n'a pas à être quoi que ce soit.
Vous pourriez faire cela plus clair, comme l'appel d'une méthode en dehors de la portée que pourrait être n'importe quoi et ce n'est pas encore clair que sa va être un nom de fichier jusqu'à ce que vous savez vraiment ce que sa fait! Mettre une chaîne ou d'un commentaire expliquant serait beaucoup plus utile!
Comment avez-vous lu les .profile fichier? Il ne semble pas y avoir de texte.
L'canonique des moyens de visualisation de fichiers de profil comme de 2016 est SnakeViz le Python 3-compatible successeur de RunSnakeRun. (Vous savez... just sayin'.)

OriginalL'auteur

Ici est un décorateur avec deux paramètres, le profil de sortie du fichier et le nom du champ pour trier les résultats. La valeur par défaut est le temps cumulé, ce qui est utile pour trouver les goulots d'étranglement.

def profileit(prof_fname, sort_field='cumtime'):
    """
    Parameters
    ----------
    prof_fname
        profile output file name
    sort_field
        "calls"     : (((1,-1),              ), "call count"),
        "ncalls"    : (((1,-1),              ), "call count"),
        "cumtime"   : (((3,-1),              ), "cumulative time"),
        "cumulative": (((3,-1),              ), "cumulative time"),
        "file"      : (((4, 1),              ), "file name"),
        "filename"  : (((4, 1),              ), "file name"),
        "line"      : (((5, 1),              ), "line number"),
        "module"    : (((4, 1),              ), "file name"),
        "name"      : (((6, 1),              ), "function name"),
        "nfl"       : (((6, 1),(4, 1),(5, 1),), "name/file/line"),
        "pcalls"    : (((0,-1),              ), "primitive call count"),
        "stdname"   : (((7, 1),              ), "standard name"),
        "time"      : (((2,-1),              ), "internal time"),
        "tottime"   : (((2,-1),              ), "internal time"),
    Returns
    -------
    None

    """
    def actual_profileit(func):
        def wrapper(*args, **kwargs):
            prof = cProfile.Profile()
            retval = prof.runcall(func, *args, **kwargs)
            stat_fname = '{}.stat'.format(prof_fname)
            prof.dump_stats(prof_fname)
            print_profiler(prof_fname, stat_fname, sort_field)
            print('dump stat in {}'.format(stat_fname))
            return retval
        return wrapper
    return actual_profileit


def print_profiler(profile_input_fname, profile_output_fname, sort_field='cumtime'):
    import pstats
    with open(profile_output_fname, 'w') as f:
        stats = pstats.Stats(profile_input_fname, stream=f)
        stats.sort_stats(sort_field)
        stats.print_stats()

OriginalL'auteur

Si vous avez compris comment écrire un décorateur pour cProfile, pensez à utiliser functools.enveloppements.

Ajoute simplement une ligne peut vous aider à débogage décorateurs beaucoup plus facile. Sans l'utilisation de functools.enveloppements, le nom de l'décoré de la fonction aurait été "emballé", et la docstring de auraient été perdus.

Donc la version améliorée serait

import cProfile
import functools

def profileit(func):
    @functools.wraps(func)  # <-- Changes here.
    def wrapper(*args, **kwargs):
        datafn = func.__name__ + ".profile" # Name the data file sensibly
        prof = cProfile.Profile()
        retval = prof.runcall(func, *args, **kwargs)
        prof.dump_stats(datafn)
        return retval

    return wrapper

@profileit
def function_you_want_to_profile(...)
    ...

OriginalL'auteur

J'aime la réponse de @detly. Mais parfois, c'est un problème pour une utilisation SnakeViz pour afficher le résultat.

J'ai fait une version légèrement différente qui écrit le résultat sous forme de texte dans le même fichier:

import cProfile, pstats, io

def profileit(func):
    def wrapper(*args, **kwargs):
        datafn = func.__name__ + ".profile" # Name the data file sensibly
        prof = cProfile.Profile()
        retval = prof.runcall(func, *args, **kwargs)
        s = io.StringIO()
        sortby = 'cumulative'
        ps = pstats.Stats(prof, stream=s).sort_stats(sortby)
        ps.print_stats()
        with open(datafn, 'w') as perf_file:
            perf_file.write(s.getvalue())
        return retval

    return wrapper

@profileit
def function_you_want_to_profile(...)
    ...

J'espère que cela aide quelqu'un...

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.