Kursinhalt
Optimierungstechniken in Python
Optimierungstechniken in Python
Effiziente Zeichenfolgenoperationen
Effiziente Zeichenkettenverkettung
Beim Arbeiten mit vielen Zeichenketten ist es wichtig, die effizienteste Methode zur Verkettung zu verwenden. Die wiederholte Verwendung des + (+=) Operators ist für große Datensätze ineffizient, da jedes Mal eine neue Zeichenkette erstellt wird. Stattdessen ist die Verwendung von str.join() viel schneller und speichereffizienter.
Lassen Sie uns die Leistung von zwei Ansätzen zum Verketten von Zeichenketten mit Zeilenumbrüchen in eine einzelne Zeichenkette vergleichen. Der erste verwendet eine for-Schleife mit dem += Operator, während der zweite die effizientere str.join() Methode nutzt.
import os decorators = os.system('wget https://staging-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 # Simulated lines of a report lines = [f"Line {i}" for i in range(1, 1000001)] # Inefficient concatenation @timeit_decorator(number=50) def concat_with_plus(): result = "" for line in lines: result += line + "\n" return result # Efficient concatenation @timeit_decorator(number=50) def concat_with_join(): return "\n".join(lines) + "\n" # Add final newline for consistency result_plus = concat_with_plus() result_join = concat_with_join() print(result_plus == result_join)
Vorabkompilierung von regulären Ausdrücken
Bei der Arbeit mit regulären Ausdrücken kann die Leistung zu einem Problem werden, insbesondere bei großen Datensätzen oder sich wiederholenden Musterabgleichen. In solchen Fällen ist die Vorabkompilierung des Musters eine nützliche Optimierungstechnik.
Die Vorabkompilierung stellt sicher, dass die Regex-Engine das Muster nicht jedes Mal neu kompiliert, wenn es verwendet wird, was die Leistung erheblich verbessern kann, wenn dasselbe Muster mehrmals über einen Datensatz angewendet wird. Dieser Ansatz ist besonders vorteilhaft in Szenarien wie Filtern, Validierung oder Suche in großen Textdateien.
Vergleichen wir die Leistung von zwei Ansätzen zur Validierung von Benutzernamen mit regulären Ausdrücken. Der erste Ansatz verwendet die re.match-Funktion mit dem Muster, das jedes Mal, wenn es aufgerufen wird, inline definiert ist. Der zweite, effizientere Ansatz kompiliert das Regex-Muster vorab mit re.compile und verwendet es für alle Validierungen erneut.
import os import re decorators = os.system('wget https://staging-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 # Simulated usernames usernames = ["user123", "admin!@#", "test_user", "invalid!"] * 100000 # Naive approach @timeit_decorator(number=10) def validate_with_re(): pattern = r"^\w+$" return [bool(re.match(pattern, username)) for username in usernames] # Optimized approach @timeit_decorator(number=10) def validate_with_compiled_re(): compiled_pattern = re.compile(r"^\w+$") return [bool(compiled_pattern.match(username)) for username in usernames] result_without_precompiling = validate_with_re() result_with_precompiling = validate_with_compiled_re() print(result_without_precompiling == result_with_precompiling)
1. Sie erstellen einen Bericht mit 10000 Zeilen, wobei jede Zeile eine Transaktionszusammenfassung darstellt. Welche Methode ist am effizientesten, um diese Zeilen zu einem einzigen String mit ; dazwischen zu kombinieren?
2. Warum ist das Vorkompilieren eines regulären Ausdrucks mit re.compile() oft schneller als die Verwendung von re.match() mit einem Inline-Muster?
Danke für Ihr Feedback!
