So verwenden Sie reguläre Python-Ausdrücke, um Code auswendig zu lernen

In Python sind reguläre Ausdrücke ein sehr leistungsfähiges Textverarbeitungswerkzeug. Es kann zum Anpassen und Ersetzen bestimmter Formate im Text verwendet werden, wodurch die Textverarbeitung effizienter und komfortabler wird.

Beim Schreiben von umfangreichem Code stoßen wir häufig auf Situationen, in denen ein Auswendiglernen erforderlich ist. Unter Speicherung versteht man das Zwischenspeichern der während der Funktionsausführung generierten Ergebnisse, sodass die zwischengespeicherten Ergebnisse direkt in nachfolgenden Aufrufen verwendet werden können, wodurch wiederholte Berechnungen vermieden und die Effizienz der Codeausführung verbessert werden. In Python können wir Dekoratoren verwenden, um Memoisierungsfunktionen zu implementieren, und reguläre Ausdrücke können uns dabei helfen, Memoisierungs-Caches besser zu verwalten.

In diesem Artikel erfahren Sie, wie Sie reguläre Python-Ausdrücke zum Speichern von Code verwenden. Zunächst müssen wir die grundlegende Verwendung von Dekoratoren verstehen.

1. Decorator-Grundlagen

Decorator ist eine Syntaxstruktur, die einer Funktion zusätzliche Funktionalität hinzufügen kann, ohne den Funktionscode zu ändern. Normalerweise handelt es sich um eine Funktion, die die dekorierte Funktion als Parameter verwendet und deren Rückgabewert eine neue Funktion ist. Diese neue Funktion führt automatisch einige zusätzliche Vorgänge aus, wenn die dekorierte Funktion aufgerufen wird.

Das Folgende ist ein einfaches Decorator-Beispiel, mit dem die Ausführungszeit einer Funktion berechnet werden kann:

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print('Function "{}" takes {}s to execute.'.format(func.__name__, end_time - start_time))
        return result
    return wrapper

@timer
def foo():
    time.sleep(1)
    return 'Done'

foo()

Im obigen Code ist ein Decorator-Timer definiert, der eine Funktion als Parameter akzeptiert und einen neuen Funktionswrapper zurückgibt. Wenn die Wrapper-Funktion die dekorierte Funktion ausführt, berechnet sie zunächst die Ausführungszeit der Funktion, gibt dann die Ausführungszeit aus und gibt schließlich das Ausführungsergebnis der dekorierten Funktion zurück.

Wenn Sie einen Dekorator verwenden, müssen Sie vor der dekorierten Funktion nur die Namenssyntax @decorator hinzufügen.

2. Implementierung der Memoisierung

Im Folgenden stellen wir vor, wie Dekoratoren zur Implementierung der Memoisierungsfunktion verwendet werden. Konkret möchten wir in der Lage sein, die Eingabeparameter und Ausgabeergebnisse einer Funktion zwischenzuspeichern, sodass nachfolgende Aufrufe die zwischengespeicherten Ergebnisse direkt und ohne Neuberechnung verwenden können. Um diese Funktion zu erreichen, können wir eine spezielle Datenstruktur im Python-Wörterbuch verwenden. Wir verwenden die Funktionseingabeparameter als Schlüssel des Wörterbuchs, die Funktionsausgabeergebnisse als Werte des Wörterbuchs und speichern sie in einer globalen Variablen. Überprüfen Sie bei jedem Aufruf der dekorierten Funktion zunächst, ob das entsprechende Ausgabeergebnis bereits im Wörterbuch vorhanden ist. Wenn es vorhanden ist, wird das zwischengespeicherte Ergebnis direkt zurückgegeben. Andernfalls wird die Funktionsberechnung durchgeführt und das Ausgabeergebnis dem Wörterbuch hinzugefügt .

Das Folgende ist ein einfaches Memoize-Dekorator-Beispiel:

import functools

memory = {}

def memoize(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        key = (args, tuple(kwargs.items()))
        if key not in memory:
            memory[key] = func(*args, **kwargs)
        return memory[key]
    return wrapper

@memoize
def add(x, y):
    print('Adding {} and {}...'.format(x, y))
    return x + y

print(add(2, 3))    # Adding 2 and 3... 5
print(add(2, 3))    # 5

Im obigen Code ist ein Memoize-Dekorator definiert. Seine Funktion besteht darin, das Cache-Schlüssel-Wert-Paar im globalen Variablenspeicher zu speichern, damit es bei nachfolgenden Aufrufen überprüft werden kann . Zwischengespeicherte Ergebnisse sind vorhanden. Wenn die dekorierte Funktion aufgerufen wird, werden die Eingabeparameter zunächst in Tupel und Wörterbücher umgewandelt und dann als Schlüssel-Wert-Paare verwendet, um festzustellen, ob ein zwischengespeichertes Ergebnis vorliegt. Wenn es nicht vorhanden ist, wird die dekorierte Funktion aufgerufen, um das Ergebnis zu berechnen, und das Ergebnis wird dem Cache-Wörterbuch hinzugefügt. Wenn es vorhanden ist, wird das zwischengespeicherte Ergebnis direkt zurückgegeben. Für dekorierte Funktionen verwenden wir functools.wraps, um die Vererbung von Dokumentzeichenfolgen und Funktionsnamen zu implementieren.

Der obige Code eignet sich für die Verwendung gewöhnlicher Datentypen als Funktionseingabeparameter. In der tatsächlichen Entwicklung können wir jedoch auf komplexere Datentypen wie Listen, Tupel, Mengen usw. stoßen. An diesem Punkt müssen wir reguläre Ausdrücke verwenden, um den Datentyp in eine Zeichenfolge umzuwandeln, damit er als Schlüssel zum Zwischenspeichern von Schlüssel-Wert-Paaren verwendet werden kann.

3. Verwendung regulärer Ausdrücke

Regulärer Ausdruck ist ein Ausdruck, der zum Abgleichen und Verarbeiten von Zeichenfolgen verwendet werden kann. In Python können wir reguläre Ausdrücke mithilfe des re-Moduls verwenden. Hier ist ein einfaches Beispiel für einen regulären Ausdruck:

import re

pattern = r'd+'
text = '123abc456def789'
match = re.search(pattern, text)
print(match.group())    # 123

Im obigen Code definieren wir ein reguläres Ausdrucksmuster, das d+ enthält, was bedeutet, dass eine oder mehrere Zahlen übereinstimmen. Dann verwenden wir die Funktion re.search, um das Muster im Zeichenfolgentext abzugleichen und ein Match-Objekt zurückzugeben. Das Match-Objekt enthält Informationen wie die übereinstimmende Zeichenfolge, Start- und Endpositionen usw. Wir können die übereinstimmende Zeichenfolge über die Gruppenmethode erhalten.

Bei der Implementierung der Memoisierungsfunktion können wir die Eingabeparameter in Zeichenfolgen umwandeln und reguläre Ausdrücke verwenden, um Zahlen, Buchstaben, Symbole und andere Informationen in den Parametern als Schlüssel zum Zwischenspeichern von Schlüssel-Wert-Paaren zu extrahieren. Hier ist ein Beispielcode:

import re
import functools

memory = {}

def memoize(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_str = ', '.join(map(str, args))
        kwargs_str = ', '.join('{}={}'.format(k, v) for k, v in kwargs.items())
        key_str = args_str + ', ' + kwargs_str
        match = re.search(r'd+', key_str)
        key = match.group()
        if key not in memory:
            memory[key] = func(*args, **kwargs)
        return memory[key]
    return wrapper

@memoize
def add(x, y):
    print('Adding {} and {}...'.format(x, y))
    return x + y

print(add(2, 3))    # Adding 2 and 3... 5
print(add(2, 3))    # 5

print(add(2, 4))    # Adding 2 and 4... 6
print(add(2, 4))    # 6

print(add(1, y=2))  # Adding 1 and 2... 3
print(add(1, y=2))  # 3

Im obigen Code konvertieren wir die Eingabeparameter in Zeichenfolgen und verwenden reguläre Ausdrücke, um daraus Zahlen als Schlüssel von Schlüssel-Wert-Paaren zu extrahieren. Wenn der entsprechende Schlüssel bereits im Cache-Wörterbuch vorhanden ist, wird das Ergebnis direkt zurückgegeben. Andernfalls wird eine Funktionsberechnung durchgeführt und das Ergebnis dem Cache-Wörterbuch hinzugefügt.

4. Zusammenfassung

In diesem Artikel wird erläutert, wie Sie reguläre Python-Ausdrücke zum Speichern von Code verwenden. Durch die Verwendung von Dekoratoren und regulären Ausdrücken können wir den Cache der Funktionsausführungsergebnisse besser verwalten, wiederholte Berechnungen vermeiden und die Effizienz der Codeausführung verbessern. In praktischen Anwendungen müssen wir auch Probleme wie Cache-Ablauf und Kapazitätskontrolle berücksichtigen, um die Speichertechnologie besser nutzen zu können.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie reguläre Python-Ausdrücke, um Code auswendig zu lernen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!