Dalam artikel ini, kita akan belajar cara mengosongkan cache LRU yang dilaksanakan dalam Python Sebelum kita menyelami lebih dalam aspek pengekodan, mari kita terokai sedikit tentang apa itu LRU cache adalah dan mengapa ia popular
.LRU Cache, juga dikenali sebagai cache yang paling kurang digunakan baru-baru ini, ialah struktur data yang digunakan secara meluas dalam sains komputer untuk meningkatkan prestasi aplikasi dengan mengurangkan masa yang diperlukan untuk mengakses data yang kerap digunakan. Cache LRU menyimpan bilangan item yang terhad dan memadam item yang paling kurang digunakan baru-baru ini apabila cache menjadi penuh. Ini membolehkan item yang paling kerap digunakan kekal dalam cache dan diakses dengan cepat, manakala item yang kurang kerap digunakan dialih keluar untuk memberi ruang kepada item baharu.
LRU cache amat berguna dalam aplikasi yang mengambil data adalah mahal, seperti cakera I/O atau akses rangkaian. Dalam kes ini, caching data yang kerap digunakan dalam ingatan boleh meningkatkan prestasi aplikasi dengan ketara dengan mengurangkan bilangan operasi mahal yang diperlukan untuk mendapatkan semula data.
Cache LRU digunakan dalam pelbagai jenis aplikasi, termasuk pangkalan data, pelayan web, penyusun dan sistem pengendalian Ia amat berguna dalam aplikasi yang memerlukan akses kerap kepada sejumlah besar data, seperti enjin carian dan platform analitik data.
Dalam Python 3.2 dan ke atas, modul functools termasuk ciri berkuasa yang membolehkan pengaturcara berinteraksi dengan Cache LRU. Ciri ini boleh digunakan dengan menggunakan penghias yang diletakkan di atas definisi kelas atau fungsi ini kepada fungsi yang memerlukan akses berubah dan perubahan yang kerap, prestasi fungsi boleh dipertingkatkan dengan ketara.
Apabila bekerja dengan fungsi yang memerlukan pemprosesan sejumlah besar data atau pengiraan yang kompleks, penggunaan Cache LRU boleh mempercepatkan masa pelaksanaan Ini kerana Cache LRU menyimpan data yang kerap−digunakan dalam memori, membenarkan fungsi untuk mengakses dan memproses data dengan pantas tanpa memerlukan kos masa−memakan operasi I/O.
Dengan menggunakan Cache LRU, pengaturcara Python boleh mengurangkan masa pelaksanaan aplikasi mereka dan meningkatkan prestasi mereka Ini amat penting apabila bekerja dengan aplikasi berskala besar atau yang memerlukan pemprosesan data masa nyata, di mana peningkatan kecil dalam prestasi boleh menghasilkan keuntungan yang ketara.
Ringkasnya, modul functools dalam Python menyediakan mekanisme yang berkuasa untuk berinteraksi dengan LRU Cache. Dengan menggunakan LRU Cache, pengaturcara boleh meningkatkan prestasi aplikasi dengan mengurangkan masa yang diperlukan untuk capaian berubah yang mahal dan menukar operasi. Menggunakan Cache LRU amat berfaedah dalam aplikasi yang memerlukan pemprosesan data masa nyata atau mengendalikan sejumlah besar data.
Sekarang kita tahu serba sedikit tentang cache LRU, mari kita gunakannya dalam Python
.Kaedah cache clear() modul functools dalam Python boleh digunakan untuk mengosongkan cache LRU (paling kurang digunakan).
Cache dikosongkan sepenuhnya menggunakan teknik ini.
from functools import lru_cache @lru_cache(maxsize=128) def some_function(arg): # function implementation return result # clear the cache some_function.cache_clear()
Dalam contoh di atas, some_function dihiasi dengan lru_cache, yang mencipta cache LRU dengan saiz maksimum 128. Untuk mengosongkan cache, anda boleh memanggil kaedah cache_clear() pada objek fungsi, yang akan mengalih keluar semua entri daripada cache.
Sila ambil perhatian bahawa memanggil cache_clear() akan mengosongkan cache semua parameter. Jika anda ingin mengosongkan cache untuk parameter tertentu, anda boleh menggunakan pelaksanaan cache yang berbeza, seperti functools.typed_lru_cache, yang membolehkan anda menggunakan kaedah cache_clear() dengan parameter untuk mengosongkan cache bagi parameter tertentu.
Sekarang mari tulis contoh yang berfungsi menggunakan kod di atas.
Pertimbangkan kod yang ditunjukkan di bawah.
Terjemahan bahasa Cina bagi
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
Dalam contoh ini, fungsi fibonacci menggunakan lru_cache untuk memoize hasilnya Cache mempunyai saiz maksimum 128, jadi fungsi akan mengingati keputusan 128 panggilan terkini.
.Kami mula-mula memanggil fungsi dengan beberapa argumen untuk mengisi cache Kemudian, kami mengosongkan cache menggunakan kaedah cache_clear() Akhir sekali, kami memanggil fungsi itu semula dengan argumen yang sama untuk melihat bahawa ia dikira semula dan bukannya menggunakan hasil cache.
Untuk menjalankan kod di atas, kita perlu menjalankan arahan yang ditunjukkan di bawah.
Perintah
python3 main.py
Sebaik sahaja kita menjalankan arahan di atas, kita harus mengharapkan output yang serupa dengan yang ditunjukkan di bawah.
55 610 55
Jika kita mahu, kita juga boleh mencetak maklumat keadaan semasa cache juga dalam kod di atas, untuk melakukan itu kita perlu menggunakan kaedah cache_info()
.Pertimbangkan kod dikemas kini yang ditunjukkan di bawah. Terjemahan bahasa Cina bagi
Contohfrom 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())
Jika saiz maksimum tidak ditentukan, saiz cache adalah tidak terhad.
如果缓存已满，最近最少使用的项目将被移除，以为新项目腾出空间。
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函数的性能，特别是那些计算密集型的函数或者被多次使用相同参数调用的函数。在必要时清除缓存可以帮助保持通过缓存获得的性能提升，并确保缓存在减少计算时间方面保持有效。
Atas ialah kandungan terperinci Kosongkan cache LRU dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
