LRU-Cache in Python löschen

In diesem Artikel erfahren Sie, wie Sie einen in Python implementierten LRU-Cache löschen. Bevor wir uns eingehend mit dem Codierungsaspekt befassen, wollen wir uns ein wenig darüber informieren, was ein LRU-Cache ist und warum er beliebt ist

LRU-Cache, auch bekannt als Least-Recent-Used-Cache, ist eine Datenstruktur, die in der Informatik häufig verwendet wird, um die Leistung von Anwendungen zu verbessern, indem die Zeit verkürzt wird, die für den Zugriff auf häufig verwendete Daten erforderlich ist. Der LRU-Cache speichert eine begrenzte Anzahl von Elementen und löscht die zuletzt verwendeten Elemente, wenn der Cache voll ist. Dadurch bleiben die am häufigsten verwendeten Elemente im Cache und können schnell darauf zugegriffen werden, während weniger häufig verwendete Elemente entfernt werden, um Platz für neue Elemente zu schaffen.

LRU-Cache ist besonders nützlich in Anwendungen, bei denen das Abrufen von Daten teuer ist, wie z. B. Festplatten-E/A oder Netzwerkzugriff. In diesen Fällen kann das Zwischenspeichern häufig verwendeter Daten im Speicher die Anwendungsleistung erheblich verbessern, indem die Anzahl teurer Vorgänge zum Abrufen der Daten reduziert wird.

Der LRU-Cache wird in einer Vielzahl von Anwendungen verwendet, darunter Datenbanken, Webserver, Compiler und Betriebssysteme. Er ist besonders nützlich in Anwendungen, die häufigen Zugriff auf große Datenmengen erfordern, wie z. B. Suchmaschinen und Datenanalyseplattformen .

Interaktion mit dem LRU-Cache in Python

In Python 3.2 und höher enthält das Functools-Modul eine leistungsstarke Funktion, die es Programmierern ermöglicht, mit dem LRU-Cache zu interagieren. Diese Funktion kann durch die Verwendung eines Dekorators verwendet werden, der über einer Klassen- oder Funktionsdefinition platziert wird Wenn häufig Variablenzugriffe und -änderungen erforderlich sind, kann die Leistung der Funktion erheblich verbessert werden.

Bei der Arbeit mit Funktionen, die die Verarbeitung großer Datenmengen oder komplexer Berechnungen erfordern, kann die Verwendung eines LRU-Cache die Ausführungszeit erheblich verkürzen. Dies liegt daran, dass der LRU-Cache häufig verwendete Daten im Speicher speichert und dies der Funktion ermöglicht Greifen Sie schnell auf die Daten zu und verarbeiten Sie sie, ohne dass die Kosten für zeitaufwändige E/A-Vorgänge anfallen.

Durch die Verwendung des LRU-Cache können Python-Programmierer die Ausführungszeit ihrer Anwendungen verkürzen und ihre Leistung verbessern. Dies ist besonders wichtig, wenn sie mit großen Anwendungen oder Anwendungen arbeiten, die eine Echtzeit-Datenverarbeitung erfordern, wo bereits kleine Leistungsverbesserungen möglich sind zu erheblichen Gewinnen führen.

Zusammenfassend bietet das Functools-Modul in Python einen leistungsstarken Mechanismus für die Interaktion mit dem LRU-Cache. Durch die Verwendung des LRU-Cache können Programmierer die Anwendungsleistung verbessern, indem sie den Zeitaufwand für teure Variablenzugriffe und Änderungsvorgänge reduzieren. Der Einsatz von LRU Cache ist besonders vorteilhaft bei Anwendungen, die eine Echtzeit-Datenverarbeitung erfordern oder große Datenmengen verarbeiten.

Da wir nun ein wenig über den LRU-Cache wissen, wollen wir ihn in Python nutzen

Die Cache-Clear()-Methode des Functools-Moduls in Python kann verwendet werden, um den LRU-Cache (zuletzt verwendet) zu löschen.

Der Cache wird mit dieser Technik vollständig geleert.

Beispielcode-Snippet

from functools import lru_cache

@lru_cache(maxsize=128)
def some_function(arg):
	# function implementation
	return result

# clear the cache
some_function.cache_clear()

Erklärung

Im obigen Beispiel wird „some_function“ mit „lru_cache“ dekoriert, wodurch ein LRU-Cache mit einer maximalen Größe von 128 erstellt wird. Um den Cache zu leeren, können Sie die Methode „cache_clear()“ für das Funktionsobjekt aufrufen, wodurch alle Einträge aus dem entfernt werden Cache.

Bitte beachten Sie, dass der Aufruf von cache_clear() den Cache für alle Parameter löscht. Wenn Sie den Cache für einen bestimmten Parameter leeren möchten, können Sie eine andere Cache-Implementierung verwenden, z. B. functools.typed_lru_cache, mit der Sie die Methode „cache_clear()“ mit einem Parameter verwenden können, um den Cache für einen bestimmten Parameter zu leeren.

Jetzt schreiben wir ein funktionierendes Beispiel mit dem obigen Code.

Beachten Sie den unten gezeigten Code.

Die chinesische Übersetzung von

Beispiel

lautet:

Beispiel

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
	"""Return the nth Fibonacci number."""
	if n < 2:
    	return n
	return fibonacci(n-1) + fibonacci(n-2)

# Call the function with some arguments to populate the cache
print(fibonacci(10))  # Output: 55
print(fibonacci(15))  # Output: 610

# Clear the cache
fibonacci.cache_clear()

# Call the function again to see that it's recomputed
print(fibonacci(10))  # Output: 55

Erklärung

In diesem Beispiel verwendet die Fibonacci-Funktion lru_cache, um ihre Ergebnisse zu speichern. Der Cache hat eine maximale Größe von 128, sodass die Funktion die Ergebnisse der letzten 128 Aufrufe speichert.

Wir rufen die Funktion zunächst mit einigen Argumenten auf, um den Cache zu füllen. Anschließend leeren wir den Cache mit der Methode „cache_clear()“ und rufen schließlich die Funktion erneut mit demselben Argument auf, um sicherzustellen, dass sie neu berechnet wird, anstatt das zwischengespeicherte Ergebnis zu verwenden.

Um den obigen Code auszuführen, müssen wir den unten gezeigten Befehl ausführen.

Befehl

python3 main.py

Sobald wir den obigen Befehl ausführen, sollten wir eine Ausgabe erwarten, die der unten gezeigten ähnelt.

Ausgabe

55
610
55

Wenn wir möchten, können wir auch die aktuellen Statusinformationen des Caches im obigen Code ausdrucken, dazu müssen wir die Methode „cache_info()“ verwenden

Beachten Sie den unten gezeigten aktualisierten Code

Die chinesische Übersetzung von

Beispiel

lautet:

Beispiel

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
	"""Return the nth Fibonacci number."""
	if n < 2:
    	return n
	return fibonacci(n-1) + fibonacci(n-2)

# Call the function with some arguments to populate the cache
print(fibonacci(10))  # Output: 55
print(fibonacci(15))  # Output: 610

print(fibonacci.cache_info())

# Clear the cache
fibonacci.cache_clear()

# Call the function again to see that it's recomputed
print(fibonacci(10))  # Output: 55

print(fibonacci.cache_info())

Erklärung

Im obigen Code akzeptiert der @lru-Cache-Dekorator den optionalen Parameter maxsize, der die maximale Größe des Caches angibt.

Wenn maxsize nicht definiert ist, ist die Cachegröße unbegrenzt.

如果缓存已满，最近最少使用的项目将被移除，以为新项目腾出空间。

The function object itself houses the cache that @lru cache uses.

Accordingly, the cache is private to the function and is not shared by other versions of the function. Also, the different part here is the cache_info() method, which is used to print information about the LRU cache used by the fibonacci function. This includes the number of cache hits and misses, as well as the size of the cache.

要运行上述代码，我们需要运行下面显示的命令。

Command

python3 main.py

一旦我们运行上述命令，我们应该期望输出类似于下面所示的输出。

Output

55
610
CacheInfo(hits=14, misses=16, maxsize=128, currsize=16)
55
CacheInfo(hits=8, misses=11, maxsize=128, currsize=11)

现在我们已经看到了如何清除缓存，让我们在另一个例子中使用它。

考虑下面显示的代码。

Example

的中文翻译为：

示例

from functools import lru_cache

@lru_cache(maxsize=128)
def edit_distance(s1, s2):
	"""
	Compute the edit distance between two strings using dynamic programming.
	"""
	if not s1:
    	return len(s2)
	elif not s2:
    	return len(s1)
	elif s1[0] == s2[0]:
    	return edit_distance(s1[1:], s2[1:])
	else:
    	d1 = edit_distance(s1[1:], s2) + 1  # deletion
    	d2 = edit_distance(s1, s2[1:]) + 1  # insertion
    	d3 = edit_distance(s1[1:], s2[1:]) + 1  # substitution
    	return min(d1, d2, d3)

# Call the function with some arguments to populate the cache
print(edit_distance("kitten", "sitting"))  # Output: 3
print(edit_distance("abcde", "vwxyz"))	# Output: 5

# Clear the cache
edit_distance.cache_clear()

# Call the function again to see that it's recomputed
print(edit_distance("kitten", "sitting"))  # Output: 3

Explanation

In this example, the edit_distance function computes the edit distance between two strings using dynamic programming. The function is recursive and has three base cases: if one of the strings is empty, the edit distance is the length of the other string; if the first characters of the two strings are the same, the edit distance is the edit distance between the rest of the strings; otherwise, the edit distance is the minimum of the edit distances for the three possible operations: deletion, insertion, and substitution.

为了提高函数的性能，我们使用lru_cache来缓存其结果。缓存的最大大小为128，因此函数将记住最近128次调用的结果。这样可以避免为相同的参数重新计算编辑距离。

We first call the function with some arguments to populate the cache. Then, we clear the cache using the cache_clear() method. Finally, we call the function again with the same argument to see that it's recomputed instead of using the cached result.

请注意，edit_distance函数只是一个示例，计算两个字符串之间的编辑距离还有更高效的方法（例如使用Wagner−Fischer算法）。这个示例的目的是演示如何使用lru_cache来记忆递归函数的结果。

结论

总之，在某些情况下，清除Python中的LRU（最近最少使用）缓存可能是重要的，以管理内存并确保缓存保持最新。LRU缓存是Python的functools模块提供的内置缓存机制，可以根据函数的参数缓存函数的结果。@lru_cache装饰器用于为函数启用缓存，可以指定maxsize来设置缓存大小的限制。

修饰的函数对象的cache clear()方法可用于清除LRU缓存。通过清除所有缓存结果，该技术使缓存保持最新，同时释放内存。如果函数被更新或输入数据经常变化，清除缓存可能是必要的。

总的来说，LRU缓存提供了一种简单而有效的方法来提高Python函数的性能，特别是那些计算密集型的函数或者被多次使用相同参数调用的函数。在必要时清除缓存可以帮助保持通过缓存获得的性能提升，并确保缓存在减少计算时间方面保持有效。

Das obige ist der detaillierte Inhalt vonLRU-Cache in Python löschen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!