Kursinhalt
Optimierungstechniken in Python
Optimierungstechniken in Python
Nutzung von map() und Listenverständnis
Wann immer möglich, ist es besser, sich auf eingebaute Funktionen, Methoden oder Bibliotheksfunktionen zu verlassen, anstatt Algorithmen von Grund auf neu zu erstellen. Eingebaute und Bibliotheksfunktionen sind in der Regel für die Leistung optimiert, laufen effizienter und sind so konzipiert, dass sie eine Vielzahl von Randfällen effektiv verwalten.
Beginnen wir mit leistungsstarken Werkzeugen wie der map()-Funktion und List Comprehensions, die Ihren Code erheblich beschleunigen können. Da List Comprehensions für die Leistung optimiert sind und map() in C implementiert ist, werden sie in der Regel schneller ausgeführt als manuell geschriebene Schleifen.
List Comprehensions
List Comprehensions bieten eine prägnantere und oft schnellere Möglichkeit, Listen im Vergleich zu traditionellen for-Schleifen zu erstellen. Außerdem können sie Ihren Code leichter lesbar und verständlich machen.
Vergleichen wir die Leistung einer for-Schleife und einer List Comprehension, indem wir eine Liste generieren, in der jede Zahl von 1 bis 10000000 mit 2 multipliziert wird:
import os os.system('wget https://content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null') from decorators import timeit_decorator numbers = list(range(1, 10000001)) @timeit_decorator(number=3) def list_comprehension(): return [x * 2 for x in numbers] @timeit_decorator(number=3) def for_loop(): result = [] for x in numbers: result.append(x * 2) return result list_1 = list_comprehension() list_2 = for_loop() print(list_1 == list_2)
Verwendung von map()
Die Funktion map wendet eine angegebene Funktion auf jedes Element in einem iterierbaren Objekt (z.B. eine Liste) an.
Neben der Tatsache, dass sie prägnanter ist als das Schreiben von Schleifen, läuft sie oft schneller aufgrund von C-Level-Optimierungen in ihrer Implementierung, die den Overhead wiederholter Funktionsaufrufe reduzieren.
Während map einige Leistungsverbesserungen bieten kann, insbesondere bei der Arbeit mit eingebauten Funktionen, ist der Geschwindigkeitsunterschied im Vergleich zu List Comprehensions oft vernachlässigbar. Beide sind hoch optimiert, und für einfache Operationen ist der Leistungsvorteil von map kaum spürbar. In der Praxis sollte die Wahl zwischen den beiden mehr auf Lesbarkeit und spezifischen Anwendungsfällen basieren, wie z.B. Speichereffizienz mit map.
Vergleichen wir die Leistung von map, for-Schleifen und List Comprehensions beim Formatieren von 1000000 Kundennamen in Titel-Schreibweise (z.B. 'john doe' -> 'John Doe'):
import os os.system('wget https://content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null') from decorators import timeit_decorator customer_names = ['john doe', 'jane smith', 'alex johnson', 'ivan smith'] * 250000 @timeit_decorator(number=10) def map_function(): return list(map(str.title, customer_names)) @timeit_decorator(number=10) def list_comprehension(): return [name.title() for name in customer_names] @timeit_decorator(number=10) def for_loop(): result = [] for name in customer_names: result.append(name.title()) return result formatted_with_map = map_function() formatted_with_comprehension = list_comprehension() formatted_with_for_loop = for_loop() print(formatted_with_map == formatted_with_comprehension == formatted_with_for_loop)
Wie erwartet ist die for-Schleife der langsamste Ansatz der drei. In diesem Beispiel stellte sich heraus, dass map schneller war als die Listenverständnis, obwohl die Leistung in der Praxis je nach spezifischem Anwendungsfall variieren kann. Manchmal können Listenverständnisse map sogar übertreffen, insbesondere bei einfacheren Ausdrücken.
Danke für Ihr Feedback!
