Kursinhalt

Optimierungstechniken in Python

1. Verstehen und Messen der Leistung

Einführung in die Python-Performance Grundlagen der Zeitmessung und des Benchmarkings Messung der Funktionsleistung Herausforderung: Implementierung von Benchmarking

2. Effiziente Nutzung von Datenstrukturen

Listen und NumPy-Arrays Mengen und Tupel Herausforderung: Optimale Datenstrukturen Wählen Verwendung des Collections-Moduls Herausforderung: Umgang Mit Kundenanfragen

3. Leistungssteigerung mit Integrierten Werkzeugen

Nutzung von map() und Listenverständnis Umgang Mit Großen Dateien Maximierung der SortierEffizienz Effiziente Zeichenfolgenoperationen

Grundlagen der Zeitmessung und des Benchmarkings

Da wir in diesem Kurs nicht die Analyse der Zeitkomplexität betonen, konzentrieren wir uns auf empirische (praktische) Methoden, um die tatsächliche Leistung von Code zu messen. Eine der einfachsten Möglichkeiten, die Leistung eines Code-Snippets zu messen, ist die Verwendung der eingebauten Funktion time.time().

Diese Funktion gibt die aktuelle Zeit in Sekunden seit der Epoche (dem Referenzpunkt des Systems für die Zeit) zurück. Indem Sie time.time() vor und nach einem Codeabschnitt aufrufen, können Sie die Differenz berechnen, um zu sehen, wie lange die Ausführung dauert.


              123456789101112131415
            
import time

# Record the start time
start_time = time.time() 

# Code you want to measure
result = [x**2 for x in range(1000000)]

# Record the end time
end_time = time.time()

# Calculate the difference to get the execution time
execution_time = end_time - start_time

print(f'Execution time: {execution_time} seconds')

Während die Verwendung von time.time() einfach und effektiv für grobe Schätzungen ist, hat sie mehrere Einschränkungen:

Niedrige Auflösung: die Genauigkeit von time.time() kann je nach Betriebssystem variieren, was zu ungenauen Ergebnissen bei kleinen Operationen führen kann;
Overhead: es umfasst andere im Hintergrund laufende Systemprozesse, die die Messung verfälschen können;
Wiederholt sich nicht: für genauere Messungen ist es oft notwendig, denselben Code mehrmals auszuführen, um ein durchschnittliches Ergebnis zu erhalten, was time.time() nicht automatisch handhabt.

Vorteile der Verwendung von timeit

Das timeit-Modul ist ein fortschrittlicheres Werkzeug, das entwickelt wurde, um die Einschränkungen von time.time() zu überwinden und eine zuverlässige Möglichkeit zu bieten, die Ausführungszeit kleiner Code-Snippets zu messen, die oft als Mikro-Benchmarking bezeichnet werden.

Die Hauptvorteile von timeit sind:

Hohe Präzision: timeit verwendet time.perf_counter() im Hintergrund, einen hochauflösenden Timer, der die während des Schlafens und Wartens auf I/O verbrachte Zeit einschließt, was es für kurze Intervalle genauer macht als time.time();
Automatische Wiederholung: timeit führt den Code automatisch mehrmals aus und berechnet die durchschnittliche Ausführungszeit. Dies hilft, die Auswirkungen von Hintergrundprozessen zu mindern und bietet eine zuverlässigere Messung der Code-Leistung;
Minimaler Overhead: timeit ist so konzipiert, dass es in einer sauberen Umgebung läuft und die Garbage Collection vorübergehend deaktiviert, um sicherzustellen, dass die Messungen sich auf den zu benchmarkenden Code konzentrieren, ohne durch Speicherverwaltungsoperationen gestört zu werden.


              1234567
            
import timeit
# Code snippet to test
code_snippet = 'result = [x**2 for x in range(1000000)]'
# Running timeit to measure execution time
iterations = 30
execution_time = timeit.timeit(code_snippet, number=iterations)
print(f'Average Execution Time: {execution_time / iterations} seconds')

In diesem Beispiel führt timeit.timeit() den als String angegebenen Code (code_snippet Variable) 30 Mal aus (angegeben durch den number Parameter) und gibt die gesamte Ausführungszeit für alle 30 Durchläufe zurück. Indem wir die Gesamtzeit durch die Anzahl der Iterationen (30) teilen, können wir die durchschnittliche Ausführungszeit für einen einzelnen Durchlauf berechnen.

Auswahl der Anzahl der Iterationen

Die Auswahl der Anzahl der Iterationen hängt von der Komplexität des Codes ab, den Sie benchmarken, und der Genauigkeit, die Sie in den Timing-Ergebnissen benötigen. Wenn Sie Ihren Code mit unterschiedlichen Iterationszahlen ausführen, können Sie die Stabilität der Ergebnisse beurteilen; wenn die Ausführungszeiten konsistent sind, haben Sie wahrscheinlich eine optimale Iterationszahl gefunden.

Für sehr schnelle Code-Snippets (Millisekunden oder weniger) sollten Sie 1000+ Iterationen anstreben, um zuverlässige Durchschnittswerte zu erhalten. Für mäßig getimte Codes (einige Millisekunden bis Sekunden) sollten 100 bis 500 Iterationen ausreichen. Für länger laufende Codes (mehrere Sekunden oder mehr) bieten 10 bis 50 Iterationen normalerweise einen guten Kompromiss zwischen Genauigkeit und der für das Benchmarking aufgewendeten Zeit.

1. Welche Funktion bietet hohe Präzision und führt den Code automatisch mehrmals aus, um eine durchschnittliche Ausführungszeit zu berechnen?

2. Warum könnte die Verwendung von `time.time()` für die Leistungsbewertung weniger zuverlässig sein als `timeit.timeit()`?

War alles klar?

Danke für Ihr Feedback!