Project Euler und andere Codierungswettbewerbe haben häufig eine maximale Laufzeit oder die Benutzer geben an, wie schnell ihre jeweilige Lösung ausgeführt wird. Bei Python sind die Ansätze manchmal etwas kludgey - dh das Hinzufügen von Timing-Code zu __main__.

Wie lässt sich feststellen, wie lange die Ausführung eines Python-Programms dauert?

Python enthält einen Profiler namens cProfile . Es gibt nicht nur die Gesamtlaufzeit an, sondern auch die Zeiten für jede Funktion separat und gibt an, wie oft jede Funktion aufgerufen wurde, sodass Sie leicht bestimmen können, wo Sie Optimierungen vornehmen sollten.

Sie können es aus Ihrem Code oder vom Interpreter wie folgt aufrufen:

import cProfile
cProfile.run('foo()')

Noch nützlicher ist, dass Sie das cProfile aufrufen können, wenn Sie ein Skript ausführen:

python -m cProfile myscript.py

Um es noch einfacher zu machen, habe ich eine kleine Batch-Datei namens 'profile.bat' erstellt:

python -m cProfile %1

Alles was ich tun muss ist laufen:

profile euler048.py

Und ich verstehe das:

1007 function calls in 0.061 CPU seconds

Ordered by: standard name
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    0.000    0.000    0.061    0.061 <string>:1(<module>)
 1000    0.051    0.000    0.051    0.000 euler048.py:2(<lambda>)
    1    0.005    0.005    0.061    0.061 euler048.py:2(<module>)
    1    0.000    0.000    0.061    0.061 {execfile}
    1    0.002    0.002    0.053    0.053 {map}
    1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler objects}
    1    0.000    0.000    0.000    0.000 {range}
    1    0.003    0.003    0.003    0.003 {sum}

BEARBEITEN: Der Link zu einer guten Video-Ressource von PyCon 2013 mit dem Titel Python- Profilerstellung wurde
ebenfalls über YouTube aktualisiert .

Vor einiger Zeit habe ich gemacht pycallgraph, die eine Visualisierung aus Ihrem Python-Code generiert. Bearbeiten: Ich habe das Beispiel aktualisiert, um mit 3.3 zu arbeiten, der neuesten Version zum Zeitpunkt dieses Schreibens.

Nach dem pip install pycallgraphInstallieren von GraphViz können Sie es über die Befehlszeile ausführen:

pycallgraph graphviz -- ./mypythonscript.py

Oder Sie können bestimmte Teile Ihres Codes profilieren:

from pycallgraph import PyCallGraph
from pycallgraph.output import GraphvizOutput

with PyCallGraph(output=GraphvizOutput()):
    code_to_profile()

Beides generiert eine pycallgraph.pngDatei ähnlich dem folgenden Bild:

Es ist erwähnenswert, dass die Verwendung des Profilers (standardmäßig) nur für den Hauptthread funktioniert und Sie keine Informationen von anderen Threads erhalten, wenn Sie diese verwenden. Dies kann ein kleines Problem sein, da es in der Profiler-Dokumentation völlig unerwähnt ist .

Wenn Sie auch Threads profilieren möchten, sollten Sie sich die threading.setprofile()Funktion in den Dokumenten ansehen .

Sie können dazu auch eine eigene threading.ThreadUnterklasse erstellen :

class ProfiledThread(threading.Thread):
    # Overrides threading.Thread.run()
    def run(self):
        profiler = cProfile.Profile()
        try:
            return profiler.runcall(threading.Thread.run, self)
        finally:
            profiler.dump_stats('myprofile-%d.profile' % (self.ident,))

und verwenden Sie diese ProfiledThreadKlasse anstelle der Standardklasse. Es gibt Ihnen vielleicht mehr Flexibilität, aber ich bin mir nicht sicher, ob es sich lohnt, insbesondere wenn Sie Code von Drittanbietern verwenden, der Ihre Klasse nicht verwenden würde.

Das Python-Wiki ist eine großartige Seite für die Profilerstellung von Ressourcen: http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code

ebenso wie die Python-Dokumente: http://docs.python.org/library/profile.html

Wie von Chris Lawlor gezeigt, ist cProfile ein großartiges Werkzeug und kann leicht zum Drucken auf dem Bildschirm verwendet werden:

python -m cProfile -s time mine.py <args>

oder zu archivieren:

python -m cProfile -o output.file mine.py <args>

PS> Wenn Sie Ubuntu verwenden, stellen Sie sicher, dass Sie das Python-Profil installieren

apt-get install python-profiler 

Wenn Sie in eine Datei ausgeben, können Sie mit den folgenden Tools schöne Visualisierungen erhalten

PyCallGraph: ein Werkzeug Aufrufgraphen Bilder erstellen zu
installieren:

 pip install pycallgraph

Lauf:

 pycallgraph mine.py args

Aussicht:

 gimp pycallgraph.png

Sie können verwenden, was Sie möchten, um die PNG-Datei anzuzeigen, ich habe Gimp verwendet
Leider bekomme ich oft

Punkt: Die Grafik ist zu groß für Kairo-Renderer-Bitmaps. Skalierung um 0,257079 passend

Das macht meine Bilder ungewöhnlich klein. Also erstelle ich im Allgemeinen SVG-Dateien:

pycallgraph -f svg -o pycallgraph.svg mine.py <args>

PS> Stellen Sie sicher, dass Sie graphviz installieren (das das Punktprogramm bereitstellt):

pip install graphviz

Alternative Grafik mit gprof2dot über @maxy / @quodlibetor:

pip install gprof2dot
python -m cProfile -o profile.pstats mine.py
gprof2dot -f pstats profile.pstats | dot -Tsvg -o mine.svg

@ Maxys Kommentar zu dieser Antwort hat mir so geholfen, dass ich denke, dass sie eine eigene Antwort verdient: Ich hatte bereits von cProfile generierte .pstats-Dateien und wollte die Dinge nicht mit pycallgraph erneut ausführen, also habe ich gprof2dot verwendet und bin hübsch geworden svgs:

$ sudo apt-get install graphviz
$ git clone https://github.com/jrfonseca/gprof2dot
$ ln -s "$PWD"/gprof2dot/gprof2dot.py ~/bin
$ cd $PROJECT_DIR
$ gprof2dot.py -f pstats profile.pstats | dot -Tsvg -o callgraph.svg

und BLAM!

Es wird Punkt verwendet (das gleiche, was Pycallgraph verwendet), sodass die Ausgabe ähnlich aussieht. Ich habe den Eindruck, dass gprof2dot weniger Informationen verliert:

Bei der Recherche zu diesem Thema bin ich auf ein praktisches Tool namens SnakeViz gestoßen . SnakeViz ist ein webbasiertes Tool zur Visualisierung von Profilen. Es ist sehr einfach zu installieren und zu verwenden. Die übliche Art, wie ich es benutze, besteht darin, eine %prunStatistikdatei mit SnakeViz zu generieren und diese dann zu analysieren.

Die hauptsächlich verwendete Technik ist das unten gezeigte Sunburst-Diagramm , in dem die Hierarchie der Funktionsaufrufe als Schichten von Bögen und Zeitinformationen angeordnet ist, die in ihren Winkelbreiten codiert sind.

Das Beste ist, dass Sie mit dem Diagramm interagieren können. Zum Vergrößern kann man beispielsweise auf einen Bogen klicken, und der Bogen und seine Nachkommen werden als neuer Sunburst vergrößert, um weitere Details anzuzeigen.

Einfachster und schnellster Weg, um herauszufinden, wohin die ganze Zeit geht.

1. pip install snakeviz

2. python -m cProfile -o temp.dat <PROGRAM>.py

3. snakeviz temp.dat

Zeichnet ein Kreisdiagramm in einem Browser. Das größte Stück ist die Problemfunktion. Sehr einfach.

Ich denke, das cProfileist großartig für die Profilerstellung, während kcachegrindes großartig ist, um die Ergebnisse zu visualisieren. Das pyprof2calltreeDazwischen übernimmt die Dateikonvertierung.

python -m cProfile -o script.profile script.py
pyprof2calltree -i script.profile -o script.calltree
kcachegrind script.calltree

So installieren Sie die erforderlichen Tools (zumindest unter Ubuntu):

apt-get install kcachegrind
pip install pyprof2calltree

Das Ergebnis:

Erwähnenswert ist auch der GUI cProfile Dump Viewer RunSnakeRun . Sie können damit sortieren und auswählen und so die relevanten Teile des Programms vergrößern. Die Größe der Rechtecke im Bild ist proportional zur benötigten Zeit. Wenn Sie mit der Maus über ein Rechteck fahren, wird dieser Aufruf in der Tabelle und überall auf der Karte hervorgehoben. Wenn Sie auf ein Rechteck doppelklicken, wird dieser Teil vergrößert. Es zeigt Ihnen, wer diesen Teil anruft und wie dieser Teil anruft.

Die beschreibenden Informationen sind sehr hilfreich. Es zeigt Ihnen den Code für dieses Bit, der hilfreich sein kann, wenn Sie mit integrierten Bibliotheksaufrufen arbeiten. Hier erfahren Sie, in welcher Datei und in welcher Zeile Sie den Code finden.

Ich möchte auch darauf hinweisen, dass das OP "Profiling" sagte, aber es scheint, dass er "Timing" meinte. Beachten Sie, dass Programme beim Profilieren langsamer ausgeführt werden.

Ein nettes Profiling-Modul ist der line_profiler (wird mit dem Skript kernprof.py aufgerufen). Es kann hier heruntergeladen werden .

Nach meinem Verständnis gibt cProfile nur Informationen über die Gesamtzeit, die in jeder Funktion verbracht wurde. Einzelne Codezeilen sind also nicht zeitgesteuert. Dies ist ein Problem im wissenschaftlichen Rechnen, da oft eine einzelne Zeile viel Zeit in Anspruch nehmen kann. Wie ich mich erinnere, hat cProfile auch nicht die Zeit erfasst, die ich in "numpy.dot" verbracht habe.

Ich habe kürzlich Thunfisch zur Visualisierung der Python-Laufzeit und zum Importieren von Profilen erstellt. Dies kann hier hilfreich sein.

Installieren mit

pip install tuna

Erstellen Sie ein Laufzeitprofil

python3 -m cProfile -o program.prof yourfile.py

oder ein Importprofil (Python 3.7+ erforderlich)

python3 -X importprofile yourfile.py 2> import.log

Führen Sie dann einfach Thunfisch für die Datei aus

tuna program.prof

Profil

line_profiler(hier bereits vorgestellt) auch inspiriert pprofile, was beschrieben wird als:

Liniengranularität, threadbewusster deterministischer und statistischer Pure-Python-Profiler

Es bietet Zeilengranularität, da line_profileres reines Python ist, als eigenständiger Befehl oder als Modul verwendet werden kann und sogar Dateien im Callgrind-Format generieren kann, mit denen es einfach analysiert werden kann [k|q]cachegrind.

vprof

Es gibt auch vprof , ein Python-Paket, das wie folgt beschrieben wird:

[...] Bereitstellung umfangreicher und interaktiver Visualisierungen für verschiedene Python-Programmmerkmale wie Laufzeit und Speichernutzung.

Es gibt viele gute Antworten, aber sie verwenden entweder die Befehlszeile oder ein externes Programm zum Profilieren und / oder Sortieren der Ergebnisse.

Ich habe wirklich eine Möglichkeit verpasst, die ich in meiner IDE (eclipse-PyDev) verwenden konnte, ohne die Befehlszeile zu berühren oder etwas zu installieren. Hier ist es also.

Profilerstellung ohne Kommandozeile

def count():
    from math import sqrt
    for x in range(10**5):
        sqrt(x)

if __name__ == '__main__':
    import cProfile, pstats
    cProfile.run("count()", "{}.profile".format(__file__))
    s = pstats.Stats("{}.profile".format(__file__))
    s.strip_dirs()
    s.sort_stats("time").print_stats(10)

Weitere Informationen finden Sie in den Dokumenten oder anderen Antworten.

Nach der Antwort von Joe Shaw, dass Multithread-Code nicht wie erwartet funktioniert, stellte ich fest, dass die runcallMethode in cProfile lediglich den profilierten Funktionsaufruf ausführt self.enable()und self.disable()aufruft, sodass Sie dies einfach selbst tun und den gewünschten Code dazwischen haben können minimale Störung des vorhandenen Codes.

In Virtaals Quelle gibt es eine sehr nützliche Klasse und einen Dekorator, die das Profiling (auch für bestimmte Methoden / Funktionen) sehr einfach machen können. Die Ausgabe kann dann in KCacheGrind sehr bequem angezeigt werden.

cProfile eignet sich hervorragend für die schnelle Profilerstellung, aber die meiste Zeit endete es für mich mit den Fehlern. Die Funktion runctx löst dieses Problem, indem sie die Umgebung und die Variablen korrekt initialisiert. Ich hoffe, sie kann für jemanden nützlich sein:

import cProfile
cProfile.runctx('foo()', None, locals())

Wenn Sie einen kumulativen Profiler erstellen möchten, dh die Funktion mehrmals hintereinander ausführen und die Summe der Ergebnisse anzeigen möchten.

Sie können diesen cumulative_profilerDekorateur verwenden:

Es ist Python> = 3.6-spezifisch, aber Sie können es entfernen, nonlocaldamit es auf älteren Versionen funktioniert.

import cProfile, pstats

class _ProfileFunc:
    def __init__(self, func, sort_stats_by):
        self.func =  func
        self.profile_runs = []
        self.sort_stats_by = sort_stats_by

    def __call__(self, *args, **kwargs):
        pr = cProfile.Profile()
        pr.enable()  # this is the profiling section
        retval = self.func(*args, **kwargs)
        pr.disable()

        self.profile_runs.append(pr)
        ps = pstats.Stats(*self.profile_runs).sort_stats(self.sort_stats_by)
        return retval, ps

def cumulative_profiler(amount_of_times, sort_stats_by='time'):
    def real_decorator(function):
        def wrapper(*args, **kwargs):
            nonlocal function, amount_of_times, sort_stats_by  # for python 2.x remove this row

            profiled_func = _ProfileFunc(function, sort_stats_by)
            for i in range(amount_of_times):
                retval, ps = profiled_func(*args, **kwargs)
            ps.print_stats()
            return retval  # returns the results of the function
        return wrapper

    if callable(amount_of_times):  # incase you don't want to specify the amount of times
        func = amount_of_times  # amount_of_times is the function in here
        amount_of_times = 5  # the default amount
        return real_decorator(func)
    return real_decorator

Beispiel

Profilerstellung der Funktion baz

import time

@cumulative_profiler
def baz():
    time.sleep(1)
    time.sleep(2)
    return 1

baz()

baz lief 5 mal und druckte dies:

         20 function calls in 15.003 seconds

   Ordered by: internal time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       10   15.003    1.500   15.003    1.500 {built-in method time.sleep}
        5    0.000    0.000   15.003    3.001 <ipython-input-9-c89afe010372>:3(baz)
        5    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

Angabe der Häufigkeit

@cumulative_profiler(3)
def baz():
    ...

Die reine (und einfachste) Lösung für den Fall, dass all diese ausgefallenen Benutzeroberflächen nicht installiert oder ausgeführt werden können:
Ignorieren Sie sie cProfilevollständig und ersetzen Sie sie durch pyinstrument, um den Aufrufbaum direkt nach der Ausführung zu erfassen und anzuzeigen.

Installieren:

$ pip install pyinstrument

Profil und Anzeigeergebnis:

$ python -m pyinstrument ./prog.py

Funktioniert mit Python2 und 3.

[EDIT] Die Dokumentation der API zum Profilieren nur eines Teils des Codes finden Sie hier .

Ich verwende yappi ( https://github.com/sumerc/yappi ). Dies ist besonders nützlich in Kombination mit einem RPC-Server, auf dem Sie (auch nur zum Debuggen) eine Methode zum Starten, Stoppen und Drucken von Profilinformationen registrieren, z. B. auf folgende Weise:

@staticmethod
def startProfiler():
    yappi.start()

@staticmethod
def stopProfiler():
    yappi.stop()

@staticmethod
def printProfiler():
    stats = yappi.get_stats(yappi.SORTTYPE_TTOT, yappi.SORTORDER_DESC, 20)
    statPrint = '\n'
    namesArr = [len(str(stat[0])) for stat in stats.func_stats]
    log.debug("namesArr %s", str(namesArr))
    maxNameLen = max(namesArr)
    log.debug("maxNameLen: %s", maxNameLen)

    for stat in stats.func_stats:
        nameAppendSpaces = [' ' for i in range(maxNameLen - len(stat[0]))]
        log.debug('nameAppendSpaces: %s', nameAppendSpaces)
        blankSpace = ''
        for space in nameAppendSpaces:
            blankSpace += space

        log.debug("adding spaces: %s", len(nameAppendSpaces))
        statPrint = statPrint + str(stat[0]) + blankSpace + " " + str(stat[1]).ljust(8) + "\t" + str(
            round(stat[2], 2)).ljust(8 - len(str(stat[2]))) + "\t" + str(round(stat[3], 2)) + "\n"

    log.log(1000, "\nname" + ''.ljust(maxNameLen - 4) + " ncall \tttot \ttsub")
    log.log(1000, statPrint)

Wenn Ihr Programm funktioniert, können Sie den Profiler jederzeit starten, indem Sie die startProfilerRPC-Methode aufrufen und Profilinformationen durch Aufrufen in eine Protokolldatei printProfilerkopieren (oder die rpc-Methode ändern, um sie an den Aufrufer zurückzugeben), und folgende Ausgabe erhalten:

2014-02-19 16:32:24,128-|SVR-MAIN  |-(Thread-3   )-Level 1000: 
name                                                                                                                                      ncall     ttot    tsub
2014-02-19 16:32:24,128-|SVR-MAIN  |-(Thread-3   )-Level 1000: 
C:\Python27\lib\sched.py.run:80                                                                                                           22        0.11    0.05
M:\02_documents\_repos\09_aheadRepos\apps\ahdModbusSrv\pyAheadRpcSrv\xmlRpc.py.iterFnc:293                                                22        0.11    0.0
M:\02_documents\_repos\09_aheadRepos\apps\ahdModbusSrv\serverMain.py.makeIteration:515                                                    22        0.11    0.0
M:\02_documents\_repos\09_aheadRepos\apps\ahdModbusSrv\pyAheadRpcSrv\PicklingXMLRPC.py._dispatch:66                                       1         0.0     0.0
C:\Python27\lib\BaseHTTPServer.py.date_time_string:464                                                                                    1         0.0     0.0
c:\users\zasiec~1\appdata\local\temp\easy_install-hwcsr1\psutil-1.1.2-py2.7-win32.egg.tmp\psutil\_psmswindows.py._get_raw_meminfo:243     4         0.0     0.0
C:\Python27\lib\SimpleXMLRPCServer.py.decode_request_content:537                                                                          1         0.0     0.0
c:\users\zasiec~1\appdata\local\temp\easy_install-hwcsr1\psutil-1.1.2-py2.7-win32.egg.tmp\psutil\_psmswindows.py.get_system_cpu_times:148 4         0.0     0.0
<string>.__new__:8                                                                                                                        220       0.0     0.0
C:\Python27\lib\socket.py.close:276                                                                                                       4         0.0     0.0
C:\Python27\lib\threading.py.__init__:558                                                                                                 1         0.0     0.0
<string>.__new__:8                                                                                                                        4         0.0     0.0
C:\Python27\lib\threading.py.notify:372                                                                                                   1         0.0     0.0
C:\Python27\lib\rfc822.py.getheader:285                                                                                                   4         0.0     0.0
C:\Python27\lib\BaseHTTPServer.py.handle_one_request:301                                                                                  1         0.0     0.0
C:\Python27\lib\xmlrpclib.py.end:816                                                                                                      3         0.0     0.0
C:\Python27\lib\SimpleXMLRPCServer.py.do_POST:467                                                                                         1         0.0     0.0
C:\Python27\lib\SimpleXMLRPCServer.py.is_rpc_path_valid:460                                                                               1         0.0     0.0
C:\Python27\lib\SocketServer.py.close_request:475                                                                                         1         0.0     0.0
c:\users\zasiec~1\appdata\local\temp\easy_install-hwcsr1\psutil-1.1.2-py2.7-win32.egg.tmp\psutil\__init__.py.cpu_times:1066               4         0.0     0.0 

Es ist möglicherweise nicht sehr nützlich für kurze Skripte, hilft jedoch bei der Optimierung von Prozessen vom Servertyp, insbesondere da die printProfilerMethode im Laufe der Zeit mehrmals aufgerufen werden kann, um z. B. verschiedene Programmnutzungsszenarien zu profilieren und zu vergleichen.

In neueren Versionen von yappi funktioniert der folgende Code:

@staticmethod
def printProfile():
    yappi.get_func_stats().print_all()

Ein neues Tool zur Profilerstellung in Python ist PyVmMonitor: http://www.pyvmmonitor.com/

Es hat einige einzigartige Funktionen wie

• Hängen Sie den Profiler an ein laufendes Programm (CPython) an
• On-Demand-Profilerstellung mit Yappi-Integration
• Profil auf einer anderen Maschine
• Unterstützung mehrerer Prozesse (Multiprocessing, Django ...)
• Live-Sampling / CPU-Ansicht (mit Zeitbereichsauswahl)
• Deterministische Profilerstellung durch cProfile / Profil-Integration
• Analysieren Sie vorhandene PStats-Ergebnisse
• Öffnen Sie DOT-Dateien
• Programmatischer API-Zugriff
• Gruppieren Sie die Stichproben nach Methode oder Zeile
• PyDev-Integration
• PyCharm-Integration

Hinweis: Es ist kommerziell, aber kostenlos für Open Source.

gprof2dot_magic

Magische Funktion gprof2dotzum Profilieren einer Python-Anweisung als DOT-Diagramm in JupyterLab oder Jupyter Notebook.

GitHub-Repo: https://github.com/mattijn/gprof2dot_magic

Installation

Stellen Sie sicher, dass Sie das Python-Paket haben gprof2dot_magic.

pip install gprof2dot_magic

Seine Abhängigkeiten gprof2dotund graphvizwerden ebenfalls installiert

Verwendungszweck

Laden Sie zuerst das gprof2dot_magicModul, um die magische Funktion zu aktivieren

%load_ext gprof2dot_magic

und profilieren Sie dann eine beliebige Zeilenanweisung als DOT-Diagramm als solches:

%gprof2dot print('hello world')

Wollten Sie schon immer wissen, was zum Teufel dieses Python-Skript macht? Rufen Sie die Inspect Shell auf. Mit Inspect Shell können Sie Globals drucken / ändern und Funktionen ausführen, ohne das ausgeführte Skript zu unterbrechen. Jetzt mit automatischer Vervollständigung und Befehlsverlauf (nur unter Linux).

Inspect Shell ist kein Debugger im PDF-Stil.

https://github.com/amoffat/Inspect-Shell

Sie könnten das (und Ihre Armbanduhr) verwenden.

So fügen Sie https://stackoverflow.com/a/582337/1070617 hinzu :

Ich habe dieses Modul geschrieben, mit dem Sie cProfile verwenden und seine Ausgabe einfach anzeigen können. Mehr hier: https://github.com/ymichael/cprofilev

$ python -m cprofilev /your/python/program
# Go to http://localhost:4000 to view collected statistics.

Siehe auch: http://ymichael.com/2014/03/08/profiling-python-with-cprofile.html, wie Sie die gesammelten Statistiken verstehen können.

Dies hängt davon ab, was Sie bei der Profilerstellung sehen möchten. Einfache Zeitmetriken können durch (bash) angegeben werden.

time python python_prog.py

Sogar '/ usr / bin / time' kann mithilfe des Flags '--verbose' detaillierte Metriken ausgeben.

Um die von jeder Funktion angegebenen Zeitmetriken zu überprüfen und besser zu verstehen, wie viel Zeit für Funktionen aufgewendet wird, können Sie das in Python integrierte cProfile verwenden.

Bei detaillierteren Metriken wie der Leistung ist die Zeit nicht die einzige Metrik. Sie können sich Gedanken über Speicher, Threads usw. machen.
Profiling-Optionen:
1. line_profiler ist ein weiterer Profiler, der häufig verwendet wird, um Timing-Metriken zeilenweise herauszufinden.
2. memory_profiler ist ein Tool zum Profilieren der Speichernutzung.
3. Heapy (aus dem Projekt Guppy) Profilieren Sie, wie Objekte im Heap verwendet werden.

Dies sind einige der häufigsten, die ich benutze. Wenn Sie jedoch mehr erfahren möchten, lesen Sie dieses Buch. Es ist ein ziemlich gutes Buch, wenn Sie mit Blick auf die Leistung beginnen. Sie können zu fortgeschrittenen Themen über die Verwendung von Cython und JIT (Just-in-Time) kompiliertem Python übergehen.

Mit einem statistischen Profiler wie austin ist keine Instrumentierung erforderlich, sodass Sie Profildaten aus einer Python-Anwendung einfach mit abrufen können

austin python3 my_script.py

Die Rohausgabe ist nicht sehr nützlich, aber Sie können sie an flamegraph.pl weiterleiten , um eine Flammengraphendarstellung dieser Daten zu erhalten, aus der hervorgeht, wo die Zeit (gemessen in Mikrosekunden in Echtzeit) verbracht wird.

austin python3 my_script.py | flamegraph.pl > my_script_profile.svg

Zum schnellen Abrufen von Profilstatistiken für Ihre Codefragmente auf einem IPython-Notizbuch. Man kann line_profiler und memory_profiler direkt in ihre Notizbücher einbetten.

Kapiert!

!pip install line_profiler
!pip install memory_profiler

Lade es!

%load_ext line_profiler
%load_ext memory_profiler

Benutze es!

%Zeit

%time print('Outputs CPU time,Wall Clock time') 
#CPU times: user 2 µs, sys: 0 ns, total: 2 µs Wall time: 5.96 µs

Gibt:

• CPU-Zeiten: Ausführungszeit auf CPU-Ebene
• sys times: Ausführungszeit auf Systemebene
• gesamt: CPU-Zeit + Systemzeit
• Wandzeit: Wanduhrzeit

% timeit

%timeit -r 7 -n 1000 print('Outputs execution time of the snippet') 
#1000 loops, best of 7: 7.46 ns per loop

• Gibt die beste Zeit aus der angegebenen Anzahl von Läufen (r) in Schleifenzeiten (n).
• Gibt Details zum System-Caching aus:
  • Wenn Code-Snippets mehrmals ausgeführt werden, speichert das System einige Operationen im Cache und führt sie nicht erneut aus, was die Genauigkeit der Profilberichte beeinträchtigen kann.

% beschneiden

%prun -s cumulative 'Code to profile' 

Gibt:

• Anzahl der Funktionsaufrufe (ncalls)
• hat Einträge pro Funktionsaufruf (verschieden)
• Zeit pro Anruf (percall)
• Zeit bis zu diesem Funktionsaufruf (cumtime)
• Name der Funktion / des Moduls mit dem Namen etc ...

% memit

%memit 'Code to profile'
#peak memory: 199.45 MiB, increment: 0.00 MiB

Gibt:

• Speichernutzung

% lprun

#Example function
def fun():
  for i in range(10):
    print(i)

#Usage: %lprun <name_of_the_function> function
%lprun -f fun fun()

Gibt:

• Linienweise Statistiken

Es gibt auch einen statistischen Profiler namens statprof. Es ist ein Sampling-Profiler, der Ihrem Code nur minimalen Overhead hinzufügt und zeilenbasierte (nicht nur funktionsbasierte) Timings liefert. Es eignet sich eher für weiche Echtzeitanwendungen wie Spiele, ist jedoch möglicherweise weniger präzise als cProfile.

Die Version in pypi ist ein bisschen alt, kann es so installieren , um mit pipdurch die Angabe der git - Repository :

pip install git+git://github.com/bos/statprof.py@1a33eba91899afe17a8b752c6dfdec6f05dd0c01

Sie können es so ausführen:

import statprof

with statprof.profile():
    my_questionable_function()

Siehe auch https://stackoverflow.com/a/10333592/320036

Ich habe gerade meinen eigenen Profiler entwickelt, der von pypref_time inspiriert ist:

https://github.com/modaresimr/auto_profiler

Durch Hinzufügen eines Dekorateurs wird ein Baum zeitaufwändiger Funktionen angezeigt

@Profiler(depth=4, on_disable=show)

Install by: pip install auto_profiler

Beispiel

import time # line number 1
import random

from auto_profiler import Profiler, Tree

def f1():
    mysleep(.6+random.random())

def mysleep(t):
    time.sleep(t)

def fact(i):
    f1()
    if(i==1):
        return 1
    return i*fact(i-1)


def show(p):
    print('Time   [Hits * PerHit] Function name [Called from] [Function Location]\n'+\
          '-----------------------------------------------------------------------')
    print(Tree(p.root, threshold=0.5))

@Profiler(depth=4, on_disable=show)
def main():
    for i in range(5):
        f1()

    fact(3)


if __name__ == '__main__':
    main()

Beispielausgabe

Time   [Hits * PerHit] Function name [Called from] [function location]
-----------------------------------------------------------------------
8.974s [1 * 8.974]  main  [auto-profiler/profiler.py:267]  [/test/t2.py:30]
├── 5.954s [5 * 1.191]  f1  [/test/t2.py:34]  [/test/t2.py:14]
│   └── 5.954s [5 * 1.191]  mysleep  [/test/t2.py:15]  [/test/t2.py:17]
│       └── 5.954s [5 * 1.191]  <time.sleep>
|
|
|   # The rest is for the example recursive function call fact
└── 3.020s [1 * 3.020]  fact  [/test/t2.py:36]  [/test/t2.py:20]
    ├── 0.849s [1 * 0.849]  f1  [/test/t2.py:21]  [/test/t2.py:14]
    │   └── 0.849s [1 * 0.849]  mysleep  [/test/t2.py:15]  [/test/t2.py:17]
    │       └── 0.849s [1 * 0.849]  <time.sleep>
    └── 2.171s [1 * 2.171]  fact  [/test/t2.py:24]  [/test/t2.py:20]
        ├── 1.552s [1 * 1.552]  f1  [/test/t2.py:21]  [/test/t2.py:14]
        │   └── 1.552s [1 * 1.552]  mysleep  [/test/t2.py:15]  [/test/t2.py:17]
        └── 0.619s [1 * 0.619]  fact  [/test/t2.py:24]  [/test/t2.py:20]
            └── 0.619s [1 * 0.619]  f1  [/test/t2.py:21]  [/test/t2.py:14]

Wenn ich nicht root auf dem Server bin, verwende ich lsprofcalltree.py und führe mein Programm folgendermaßen aus:

python lsprofcalltree.py -o callgrind.1 test.py

Dann kann ich den Bericht mit jeder Callgrind-kompatiblen Software wie qcachegrind öffnen