Dans cet article, nous apprendrons comment vider un cache LRU implémenté en Python Avant de plonger en profondeur dans l'aspect codage, explorons un peu ce qu'est un cache LRU et pourquoi il est populaire
.Le cache LRU, également connu sous le nom de cache le moins récemment utilisé, est une structure de données largement utilisée en informatique pour améliorer les performances des applications en réduisant le temps nécessaire pour accéder aux données fréquemment utilisées. Le cache LRU stocke un nombre limité d'éléments et supprime les éléments les moins récemment utilisés lorsque le cache est plein. Cela permet aux éléments les plus fréquemment utilisés de rester dans le cache et d'être accessibles rapidement, tandis que les éléments les moins fréquemment utilisés sont supprimés pour laisser de la place à de nouveaux éléments.
Le cache LRU est particulièrement utile dans les applications où la récupération de données est coûteuse, comme les E/S disque ou l'accès réseau. Dans ces cas, la mise en cache des données fréquemment utilisées en mémoire peut améliorer considérablement les performances des applications en réduisant le nombre d'opérations coûteuses nécessaires pour récupérer les données.
Le cache LRU est utilisé dans une grande variété d'applications, notamment les bases de données, les serveurs Web, les compilateurs et les systèmes d'exploitation. Il est particulièrement utile dans les applications qui nécessitent un accès fréquent à une grande quantité de données, telles que les moteurs de recherche et les plateformes d'analyse de données. .
Dans Python 3.2 et supérieur, le module functools inclut une fonctionnalité puissante qui permet aux programmeurs d'interagir avec le cache LRU. Cette fonctionnalité peut être utilisée en utilisant un décorateur placé au-dessus d'une définition de classe ou de fonction. nécessitent un accès et des modifications fréquents aux variables, les performances de la fonction peuvent être considérablement améliorées.
Lorsque vous travaillez avec des fonctions qui nécessitent le traitement de grandes quantités de données ou des calculs complexes, l'utilisation d'un cache LRU peut considérablement accélérer le temps d'exécution, car le cache LRU stocke les données fréquemment utilisées en mémoire, permettant à la fonction de fonctionner. accédez et traitez rapidement les données sans encourir le coût des opérations d'E/S fastidieuses.
En utilisant le cache LRU, les programmeurs Python peuvent réduire le temps d'exécution de leurs applications et améliorer leurs performances. Ceci est particulièrement important lorsqu'ils travaillent avec des applications à grande échelle ou celles qui nécessitent un traitement de données en temps réel, où même de petites améliorations des performances peuvent être possibles. entraîner des gains significatifs.
En résumé, le module functools en Python fournit un mécanisme puissant pour interagir avec le cache LRU. En utilisant LRU Cache, les programmeurs peuvent améliorer les performances des applications en réduisant le temps requis pour les opérations coûteuses d'accès aux variables et de modification. L'utilisation du cache LRU est particulièrement bénéfique dans les applications qui nécessitent un traitement de données en temps réel ou qui gèrent de grandes quantités de données.
Maintenant que nous en savons un peu plus sur le cache LRU, utilisons-le en Python
.La méthode cache clear() du module functools en Python peut être utilisée pour vider le cache LRU (le moins récemment utilisé).
Le cache est entièrement vidé grâce à cette technique.
from functools import lru_cache @lru_cache(maxsize=128) def some_function(arg): # function implementation return result # clear the cache some_function.cache_clear()
Dans l'exemple ci-dessus, some_function est décoré avec lru_cache, qui crée un cache LRU d'une taille maximale de 128. Pour vider le cache, vous pouvez appeler la méthode cache_clear() sur l'objet fonction, qui supprimera toutes les entrées de l'objet fonction. cache.
Veuillez noter que l'appel de cache_clear() effacera le cache de tous les paramètres. Si vous souhaitez vider le cache pour un paramètre spécifique, vous pouvez utiliser une implémentation de cache différente, telle que functools.typed_lru_cache, qui vous permet d'utiliser la méthode cache_clear() avec un paramètre pour vider le cache d'un paramètre spécifique.
Écrivons maintenant un exemple fonctionnel en utilisant le code ci-dessus.
Considérez le code ci-dessous.
La traduction chinoise de
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
Dans cet exemple, la fonction fibonacci utilise lru_cache pour mémoriser ses résultats. Le cache a une taille maximale de 128, donc la fonction mémorisera les résultats des 128 appels les plus récents.
Nous appelons d'abord la fonction avec quelques arguments pour remplir le cache. Ensuite, nous vidons le cache en utilisant la méthode cache_clear() Enfin, nous appelons à nouveau la fonction avec le même argument pour voir qu'elle est recalculée au lieu d'utiliser le résultat mis en cache.
Pour exécuter le code ci-dessus, nous devons exécuter la commande ci-dessous.
Command
python3 main.py
Une fois que nous avons exécuté la commande ci-dessus, nous devrions nous attendre à une sortie similaire à celle présentée ci-dessous.
55 610 55
Si nous le souhaitons, nous pouvons également imprimer les informations sur l'état actuel du cache dans le code ci-dessus, pour ce faire, nous devons utiliser la méthode cache_info()
.Considérez le code mis à jour ci-dessous
. La traduction chinoise defrom 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())
Dans le code ci-dessus, le décorateur de cache @lru accepte le paramètre facultatif maxsize, qui spécifie la taille maximale du cache.
Si maxsize n'est pas défini, la taille du cache est illimitée.
如果缓存已满，最近最少使用的项目将被移除，以为新项目腾出空间。
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
一旦我们运行上述命令，我们应该期望输出类似于下面所示的输出。
55 610 CacheInfo(hits=14, misses=16, maxsize=128, currsize=16) 55 CacheInfo(hits=8, misses=11, maxsize=128, currsize=11)
现在我们已经看到了如何清除缓存，让我们在另一个例子中使用它。
考虑下面显示的代码。
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
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函数的性能，特别是那些计算密集型的函数或者被多次使用相同参数调用的函数。在必要时清除缓存可以帮助保持通过缓存获得的性能提升，并确保缓存在减少计算时间方面保持有效。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
