Python Timeit verwenden, um Ihren Code zu timen

In diesem Lernprogramm lernen Sie, wie Sie die Funktion timeit aus dem Python-Modul timeit verwenden. Sie lernen, wie Sie einfache Ausdrücke und Funktionen in Python zeitlich bestimmen können.

Das Timing Ihres Codes kann Ihnen dabei helfen, eine Schätzung der Ausführungszeit eines Codestücks zu erhalten und auch die Abschnitte des Codes zu identifizieren, die optimiert werden müssen.

Zunächst lernen wir die Syntax der Python-Funktion timeit kennen. Und dann werden wir anhand von Codebeispielen verstehen, wie Sie die Funktion verwenden können, um Codeblöcke und Funktionen in Ihrem Python-Modul zu optimieren. Lassen Sie uns beginnen.

Wie Sie die Python-Funktion timeit verwenden

Das timeit-Modul ist Teil der Python-Standardbibliothek und Sie können es importieren:

importieren Sie timeit

Die Syntax zur Verwendung der timeit-Funktion aus dem timeit-Modul lautet wie folgt:

timeit.timeit(stmt, einrichtung, zahl)

Hier:

stmt ist das Stück Code, dessen Ausführungszeit gemessen werden soll. Sie können ihn als einfache Python-Zeichenkette oder als mehrzeilige Zeichenkette angeben oder den Namen der aufrufbaren Datei übergeben.
Wie der Name schon sagt, bezeichnet setup den Teil des Codes, der nur einmal ausgeführt werden muss, oft als Voraussetzung für die Ausführung von stmt. Nehmen wir zum Beispiel an, Sie berechnen die Ausführungszeit für die Erstellung eines NumPy-Arrays. In diesem Fall ist das Importieren von Numpy der Einrichtungscode und die eigentliche Erstellung ist die Anweisung, deren Zeit gemessen werden soll.
Der Parameter number gibt an, wie oft die Anweisung ausgeführt wird. Der Standardwert von number ist 1 Million (1000000), aber Sie können diesen Parameter auch auf jeden anderen Wert Ihrer Wahl setzen.

Nachdem wir nun die Syntax für die Verwendung der Funktion timeit() kennengelernt haben, können wir mit der Codierung einiger Beispiele beginnen.

Zeitmessung einfacher Python-Ausdrücke

In diesem Abschnitt werden wir versuchen, die Ausführungszeit von einfachen Python-Ausdrücken mit timeit zu messen.

Starten Sie eine Python REPL und führen Sie die folgenden Codebeispiele aus. Hier berechnen wir die Ausführungszeit von Potenzierungs- und Bodenteilungsoperationen für 10000 und 100000 Durchläufe.

Beachten Sie, dass wir die zu messende Anweisung als Python-String übergeben und ein Semikolon verwenden, um die verschiedenen Ausdrücke in der Anweisung zu trennen.

>>> import timeit
>>> timeit.timeit('3**4;3//4',number=10000)
0.0004020999999738706

>>> timeit.timeit('3**4;3//4',number=100000)
0.0013780000000451764

Python timeit auf der Kommandozeile ausführen

Sie können timeit auch auf der Kommandozeile verwenden. Hier ist das Kommandozeilen-Äquivalent des timeit-Funktionsaufrufs:

$ python-m timeit -n [Zahl] -s [setup] [stmt]

python -m timeit bedeutet, dass wir timeit als das Hauptmodul ausführen.
n ist eine Befehlszeilenoption, die angibt, wie oft der Code ausgeführt werden soll. Dies entspricht dem Argument number im Aufruf der Funktion timeit().
Sie können die Option -s verwenden, um den Setup-Code zu definieren.

Hier schreiben wir das vorherige Beispiel mit der entsprechenden Befehlszeile um:

$ python -m timeit -n 100000 '3**4;3//4'
100000 Schleifen, beste von 5: 35,8 nsec pro Schleife

In diesem Beispiel berechnen wir die Ausführungszeit der eingebauten Funktion len(). Die Initialisierung des Strings ist der Setup-Code, der mit der Option s übergeben wird.

$ python -m timeit -n 100000 -s "string_1 = 'coding'" 'len(string_1)'
100000 Schleifen, beste von 5: 239 nsec pro Schleife

In der Ausgabe sehen Sie, dass wir die Ausführungszeit für den besten von 5 Durchläufen erhalten. Was hat das zu bedeuten? Wenn Sie timeit über die Befehlszeile ausführen, ist die Wiederholungsoption r auf den Standardwert 5 gesetzt. Das bedeutet, dass die Ausführung von stmt für die angegebene Anzahl von Malen fünfmal wiederholt wird und die beste der Ausführungszeiten zurückgegeben wird.

Analyse von String-Umkehrungsmethoden mit timeit

Wenn Sie mit Python-Strings arbeiten, möchten Sie diese vielleicht umkehren. Die beiden gängigsten Methoden zur Umkehrung von Strings sind die folgenden:

Verwendung von String-Slicing
Verwendung der Funktion reversed() und der Methode join()

Analysis-of-String-Reversal-Methods-Using-timeit

Umkehrung von Python-Strings mit String Slicing

Sehen wir uns an, wie String Slicing funktioniert und wie Sie damit eine Python-Zeichenkette umkehren können. Die Syntax some-string[start:stop] gibt einen Ausschnitt der Zeichenkette zurück, der beim Index start beginnt und bis zum Index stop-1 reicht. Lassen Sie uns ein Beispiel nehmen.

Nehmen wir die folgende Zeichenkette ‘Python’. Der String hat die Länge 6 und die Liste der Indizes ist 0, 1, 2 bis 5.

>>> Zeichenkette_1 = 'Python'

Wenn Sie sowohl den Start- als auch den Stoppwert angeben, erhalten Sie ein String-Slice, das von Start bis Stopp-1 reicht. Daher gibt string_1[1:4] ‘yth’ zurück.

>>> string_1 = 'Python'
>>> string_1[1:4]
'yth'

Wenn Sie den Startwert nicht angeben, wird der Standardstartwert Null verwendet und das Slice beginnt bei Index Null und reicht bis zu stop - 1.

Hier ist der Stoppwert 3, also beginnt das Slice bei Index 0 und geht bis zu Index 2.

>>> string_1[:3]
'Pyt'

Wenn Sie den Stopp-Index nicht einbeziehen, sehen Sie, dass das Slice beim Startindex (1) beginnt und bis zum Ende der Zeichenkette reicht.

>>> string_1[1:]
'ython'

Wenn Sie sowohl den Start- als auch den Stoppwert ignorieren, erhalten Sie einen Ausschnitt der gesamten Zeichenkette.

>>> string_1[::]
'Python'

Lassen Sie uns ein Slice mit dem Step-Wert erstellen. Setzen Sie die Start-, Stop- und Step-Werte auf 1, 5 bzw. 2. Wir erhalten einen Ausschnitt der Zeichenkette, der bei 1 beginnt und bis 4 reicht (mit Ausnahme des Endpunkts 5) und jedes zweite Zeichen enthält.

>>> string_1[1:5:2]
'yh'

Wenn Sie einen negativen Schritt verwenden, können Sie einen Ausschnitt erhalten, der am Ende der Zeichenkette beginnt. Wenn Sie den Schritt auf -2 setzen, ergibt sich für string_1[5:2:-2] das folgende Slice:

>>> string_1[5:2:-2]
'nh'

Um also eine umgekehrte Kopie der Zeichenkette zu erhalten, überspringen wir die Start- und Stoppwerte und setzen den Schritt auf -1, wie gezeigt:

>>> string_1[::-1]
'nohtyP'

Kurz gesagt: string[::-1] gibt eine umgekehrte Kopie der Zeichenkette zurück.

Umkehrung von Strings mit eingebauten Funktionen und String-Methoden

Die eingebaute Funktion reversed() in Python gibt einen umgekehrten Iterator über die Elemente des Strings zurück.

>>> string_1 = 'Python'
>>> reversed(string_1)
<reversed object at 0x00BEAF70&gt

Sie können also den umgekehrten Iterator mit einer for-Schleife durchlaufen:

for char in reversed(string_1):
 print(char)

Und greifen Sie auf die Elemente der Zeichenkette in umgekehrter Reihenfolge zu.

# Ausgabe
n
o
h
t
y
P

Als nächstes können Sie dann die Methode join() für den umgekehrten Iterator mit der folgenden Syntax aufrufen: <sep>.join(reversed(some-string)).

Der folgende Codeschnipsel zeigt ein paar Beispiele, bei denen das Trennzeichen ein Bindestrich bzw. ein Leerzeichen ist.

>>> '-'.join(reversed(string1))
'n-o-h-t-y-P'
>>> ' '.join(reversed(string1))
'n o h t y P'

Hier wollen wir kein Trennzeichen; setzen Sie also das Trennzeichen auf eine leere Zeichenkette, um eine umgekehrte Kopie der Zeichenkette zu erhalten:

>>> ''.join(reversed(string1))
'nohtyP'

Die Verwendung von ''.join(reversed(some-string)) liefert eine umgekehrte Kopie der Zeichenkette.

Vergleich der Ausführungszeiten mit timeit

Bis jetzt haben wir zwei Methoden zur Umkehrung von Python-Strings kennen gelernt. Aber welcher von beiden ist schneller? Lassen Sie es uns herausfinden.

In einem früheren Beispiel, in dem wir einfache Python-Ausdrücke gezeitet haben, hatten wir keinen Setup-Code. Hier kehren wir die Python-Zeichenkette um. Während die Umkehrung der Zeichenkette so oft ausgeführt wird, wie es die Zahl angibt, ist der Setup-Code die Initialisierung der Zeichenkette, die nur einmal ausgeführt wird.

>>> import timeit
>>> timeit.timeit(stmt = 'string_1[::-1]', setup = "string_1 = 'Python'", number = 100000)
0.04951830000001678
>>> timeit.timeit(stmt = "''.join(reversed(string_1))", setup = "string_1 = 'Python'", number = 100000)
0.12858760000000302

Bei der gleichen Anzahl von Durchläufen für die Umkehrung der gegebenen Zeichenkette ist der String-Slicing-Ansatz schneller als die Verwendung der Methode join() und der Funktion reversed().

Lesen Sie auch, wie Sie eine Liste in Python umkehren können , um sie rückwärts zu spinnen.

Timing von Python-Funktionen mit timeit

In diesem Abschnitt lernen Sie, wie Sie Python-Funktionen mit der Funktion timeit zeitlich steuern können. Die folgende Funktion hasDigit gibt aus einer Liste von Zeichenketten die Liste der Zeichenketten zurück, die mindestens eine Ziffer enthalten.

def hasDigit(somelist):
 str_with_digit = []
 for string in somelist:
 check_char = [char.isdigit() for char in string]
 if any(check_char):
 str_with_digit.append(string)
 return str_with_digit

Nun möchten wir die Ausführungszeit dieser Python-Funktion hasDigit() mit timeit messen.

Lassen Sie uns zunächst die zu messende Anweisung(stmt) identifizieren. Es ist der Aufruf der Funktion hasDigit() mit einer Liste von Strings als Argument. Als nächstes definieren wir den Setup-Code. Können Sie erraten, wie der Setup-Code aussehen soll?

Damit der Funktionsaufruf erfolgreich ausgeführt werden kann, sollte der Setup-Code Folgendes enthalten:

Die Definition der Funktion hasDigit()
Die Initialisierung der Argumentliste von Strings

Lassen Sie uns den Setup-Code in der Setup-Zeichenkette definieren, wie unten gezeigt:

setup = """
def hasDigit(somelist):
 str_with_digit = []
 for string in somelist:
 check_char = [char.isdigit() for char in string]
 if any(check_char):
 str_with_digit.append(string)
 return str_with_digit
thislist=['puffin3','7frost','blue']
 """

Als nächstes können wir die Funktion timeit verwenden und die Ausführungszeit der Funktion hasDigit() für 100000 Durchläufe ermitteln.

import timeit
timeit.timeit('hasDigit(thislist)',setup=setup,number=100000)

# Ausgabe
0.2810094920000097

Schlussfolgerung

Sie haben gelernt, wie Sie die Python-Funktion timeit verwenden können, um Ausdrücke, Funktionen und andere aufrufbare Variablen zu timen. Damit können Sie Ihren Code einem Benchmarking unterziehen, die Ausführungszeiten verschiedener Implementierungen der gleichen Funktion vergleichen und vieles mehr.

Lassen Sie uns noch einmal Revue passieren, was wir in diesem Lernprogramm gelernt haben. Sie können die Funktion timeit() mit der Syntax timeit.timeit(stmt=...,setup=...,number=...) verwenden. Alternativ können Sie timeit auch auf der Kommandozeile ausführen, um kurze Codeschnipsel zu timen.

In einem nächsten Schritt können Sie erkunden, wie Sie andere Python-Profiling-Pakete wie line-profiler und memprofiler verwenden können, um Ihren Code auf Zeit bzw. Speicher zu profilieren.

Als nächstes lernen Sie, wie Sie in Python Zeitdifferenzen berechnen können.

Bala Priya C

Autor