带可交换参数的函数的@lru_cache
是Python语言中的装饰器，用于对函数进行缓存优化。当函数被调用时，@lru_cache会将函数的参数和返回值进行缓存，以便在下次相同参数调用时直接返回缓存结果，从而提高函数的执行效率。
@lru_cache装饰器可以接收一个参数，用于设置缓存的大小。默认情况下，缓存大小为128个元素，可以通过设置参数来调整缓存大小，例如@lru_cache(maxsize=256)。
带可交换参数的函数是指函数的参数具有可交换性质，即参数顺序不同但结果相同。对于这种情况，@lru_cache会自动对参数进行排序，确保相同参数的不同顺序得到相同的缓存结果。
@lru_cache适用于那些具有重复计算的函数，尤其是计算结果相对稳定且计算代价较高的函数。使用@lru_cache可以显著提高函数的执行效率，避免重复计算，特别适合于递归调用和动态规划等场景。
以下是一些使用@lru_cache的实际应用场景：
- 斐波那契数列计算：由于斐波那契数列的计算涉及大量的重复计算，使用@lru_cache可以显著提高计算速度。
- 缓存数据查询：当需要对数据库中的数据进行频繁查询时，可以使用@lru_cache缓存查询结果，减少数据库查询次数，提高响应速度。
- 网络请求结果缓存：对于需要频繁发送网络请求的场景，可以使用@lru_cache缓存请求结果，避免重复请求，减少网络开销。
腾讯云提供了云原生应用引擎（Cloud Native Application Engine，简称TKE）产品，它可以与@lru_cache结合使用，实现函数级别的缓存优化。通过TKE，可以将带有@lru_cache装饰器的函数部署在云端，实现高性能、高可靠的函数计算服务。
详细了解腾讯云的云原生应用引擎（TKE）产品，请访问以下链接：云原生应用引擎（TKE）产品介绍
相关·内容
我正在尝试为leetcode的地牢游戏问题实现一个C0版本。
我尝试使用@lru_cache()：
________________________________________________________
Executed in 14.22 secs fish external
usr time 14.13 secs 101.00 micros 14.13 secs
sys time 0.04 secs 498.00 micros 0.04 secs
并对其进行评论以使其不可用：
____________________
浏览 0提问于2021-09-26得票数 2
回答已采纳
我在返回可变对象的函数上使用Python的，如下所示：
import functools
@functools.lru_cache()
def f():
x = [0, 1, 2] # Stand-in for some long computation
return x
如果调用此函数，修改结果并再次调用它，则不会获得“新鲜”、未变异的对象：
a = f()
a.append(3)
b = f()
print(a) # [0, 1, 2, 3]
print(b) # [0, 1, 2, 3]
我知道为什么会这样，但这不是我想要的。修复方法是让调用者负责使用list.c
浏览 1提问于2019-02-27得票数 9
回答已采纳
给出了函数定义：
@functools.lru_cache(maxsize=128，typed=False)
这告诉我，maxsize是可选的。
但是，它不喜欢在调用时不带任何争论：
Python 3.6.3 (default, Oct 24 2017, 14:48:20)
[GCC 7.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import functools
>
浏览 41提问于2017-11-10得票数 33
2回答
我有这样的等级制度：
#include <boost/shared_ptr.hpp>
//base cache
template <typename KEY, typename VAL> class Cache;
//derived from base to implement LRU
template <typename KEY, typename VAL> class LRU_Cache :public Cache<KEY,VAL>{};
//specialize the above class in order to accept sh
浏览 4提问于2014-08-26得票数 2
回答已采纳
我使用的是来自lru_cache的functools装饰器，我只需要使其中的一项失效，其余的则保持不变。声明__wrapped__属性的存在是为了用不同的缓存重新包装函数。我也检查了，但我不知道如何使用它。上面写着
用户只能通过它的公共API访问lru_cache : cache_info、cache_clear和f.__wrapped__ lru_cache的内部组件是为线程安全而封装的，并允许实现更改。
是否可以从lru_cache中删除一项(安全)，或者我是否应该编写自己的缓存功能？
浏览 0提问于2020-12-24得票数 0
回答已采纳
我是新来姜戈的。如果有人能分辨出Django中的@cached_property和@lru_cache装饰器之间的区别，那将会非常有帮助。另外，我应该在什么时候使用Django中的哪个装饰器。用例将会非常有用。谢谢。
浏览 2提问于2018-03-23得票数 19
1回答
对于python应用程序，包括以下模块：
commons.py
@lru_cache(maxsize=2)
def memoized_f(x):
...
pipeline_a.py
from commons import memoized_f
x = memoized_f(10)
y = memoized_f(11)
pipeline_b.py
from commons import memoized_f
x = memoized_f(20)
y = memoized_f(21)
python是否在每个memoized_f模块中存储一个pipeline_
浏览 3提问于2020-05-27得票数 0
1回答
缓存动态生成函数
、、、、
我有两个随机变量的概率密度函数func1和func2 (包括每个变量的support )。现在我需要这两个随机变量之和的概率密度函数，我通过：
import numpy as np
import scipy.integrate
[...]
def density_add(func1, func2, support):
return np.vectorize(lambda xi: scipy.integrate.simps(func1(support) * func2(xi-support), support))
这方面的问题是巨大的冗余。许多值必须计算不止一次。所以我尝试缓存，但是由于动
浏览 5提问于2016-05-17得票数 0
回答已采纳
这里是我的情况，is_exist函数有性能问题。
def is_exist(link :str) -> bool:
if query_db(link) is True:
return True
return False
def process(link: str)
if is_exist(link) is True:
return
# do something
# put result to database
LRU缓存是一个很好的解决方案，但是经过几个小时的挣扎之后，我发现lru_cache不能满足我的要求。我想要的是
浏览 8提问于2021-08-05得票数 2
回答已采纳
我有一个，它有三个注册函数。其中一个调度在int上，运行良好。第二个在定制类型上发送，也可以正常工作。第三种类型也是自定义类型，但类是用lru_cache装饰器包装的。
(为了使事情变得更复杂，类通过对另一个类的__call__方法的方法分派，以一种迂回的方式实例化。)
@lru_cache(maxsize=None, typed=True)
class QualifiedInterval:
# stuff that works
在投球课里：
@oph_utils.method_dispatch
def augmented(self, other):
raise NotImpl
浏览 4提问于2017-06-17得票数 2
回答已采纳
谁能告诉我为什么在下面的打印语句中会出现TypeError: unhashable type：'list‘错误？由于某些原因，它不喜欢我输入到函数中的数据列表。 from random import randint
from functools import lru_cache
data = []
[data.append(randint(1,1000000)) for i in range(1,1000000)]
data = sorted(data)
low = 0
high = len(data) + 1
target = randint(1,100000)
p
浏览 12提问于2020-12-03得票数 0
回答已采纳
3回答
在python中使用可选的缓存参数缓存函数的最佳方法是什么？
我有一个函数，它执行数据库请求，不接受任何参数。大多数情况下，如果函数使用缓存的结果，这是可以的，但有时我想发送一个新的数据库请求。
from functools import lru_cache
@lru_cache
def my_database_request_function(use_cache: bool = False):
if use_cache:
# takes response from cache
else:
# makes database request
retu
浏览 5提问于2022-02-10得票数 3
因此，我在Python中为Fibonacci序列做了一个递归lambda。我使用递归，因为使用lambda最容易实现。
fib = lambda n: fib(n - 1) + fib(n - 2) if n > 1 else 1
因为使用递归，可以多次计算相同的Fibonacci值，所以我认为使用缓存装饰器会有帮助，而且我知道functools.lru_cache是一个简单的选择。
我知道您不能像普通函数那样使用@functools.lru_cache对lambda函数应用装饰器，但是当我尝试这样做时：
fib = functools.lru_cache((lambda n: fib(
浏览 5提问于2015-08-14得票数 8
回答已采纳
1回答
我正在使用调用C包装器的Python代码，但是C代码非常错误(我没有其他选择)，并且在C中管理的Python对象超出范围时会导致分段错误，因此我必须保留对创建的每个对象的引用。
有什么好的方法来制作符合人体工程学的“唯一”包装器，其中每个类只能有每组构造函数参数的一个实例。
@unique
class Test:
cls_val = 0
def __init__(self, val):
self.val = val
a = Test(1)
b = Test(1)
assert a is b
c = Test(2)
d = Test(2)
assert c
浏览 1提问于2020-02-14得票数 2
回答已采纳
2回答
我有一个代价高昂的非递归函数，我希望将结果记忆到字典中，从而通过在字典中检查结果来节省时间。
该函数有三个参数：
def slow_func(a,b,c)
目前，我正在将一个对象保存在一个deque中：
memory = deque([], 1000)
...
{(a,b,c):result}, {(a,b,c):result}, {(a,b,c):result}
我检查(a，b，c)是否在字典中，然后显示结果。
有更快的方法来保存结果吗？
编辑：
输入是不同的，几乎40%的时间。
输入a和b为numpy.ndarray。
返回是numpy.ndarray
浏览 5提问于2020-04-25得票数 1
1回答
优化函数评估缓存部分结果
、、、、
假设我有一个包含多个输入参数的复杂数学函数，P = [p1, ..., pn]。假设我可以将函数分解为块，例如：
f(P) = f1(p1, p2) * f2(p2, ... pn)
也许
f2(p2, ..., pn) = p2 * f3(p4) + f4(p5, ..., pn)
假设我必须计算f的许多P值，例如，我想要找到f的最小值。假设我已经计算了f(P)，并且需要计算f(P')，其中P'等于P，除了p1之外。在这种情况下，我不需要重新计算f2, f3, f4，而只需要重新计算f1。
是否有一个库可以帮助我实现这种缓存系统？我知道，但是它是面向统计模型的，是由块建立的。
浏览 0提问于2015-08-10得票数 1
回答已采纳
1回答
最近我遇到了，不知道它与有什么不同。
我发现了关于和lru_cache之间的区别，但没有专门针对cache和lru_cache。
浏览 5提问于2021-12-10得票数 14
回答已采纳
2回答
我有一个python类，我们称它为C。它的构造函数中有一个字符串。我怎样才能确保(在设计上)
x = C('a')
y = C('b')
z = C('a')
这种配置导致x和y指向不同的位置，而x和z指向同一位置？含义
x is y == False
x is z == True
浏览 4提问于2021-09-14得票数 2
我有一个score函数，我想根据它对列表进行排序。
通常情况下，这很容易(只获取sorted(l, key=score))，但是我需要后面的代码中的分数，而且score在计算上很昂贵(所以我想避免两次得分)。
以下是我的当前代码：
scores= map(score, l)
new_l= [el for i,el in sorted(enumerate(l), key=lambda (i,el): scores[i])]
这是可行的，但有点混乱，也不是特别可读的。
实现这一目标的最佳方法是什么？
浏览 0提问于2015-08-22得票数 1
回答已采纳
适用于下列方案：
from functools import lru_cache
@lru_cache(maxsize=256)
def task_a(a, b):
print(f'Multiplying {a} and {b}')
return a*b
print(task_a(2, 3))
print(task_a(2, 3))
print(task_a(2, 4))
print(task_a(2, 4))
print(task_a(2, 5))
print(task_a(2, 5))
我得到了以下输出：
Multiplying 2 and 3
浏览 4提问于2022-08-23得票数 0
1回答
我正在使用Python3的内置functools.lru_cache装饰器来回忆一些昂贵的功能。我想回忆尽可能多的调用，而不使用太多的内存，因为缓存太多的值会引起混乱。
是否有一种在Python中实现此功能的首选技术或库？
例如，引导我到一个的Go库。对于Python来说，类似的东西将是理想的。
注释：--我不能仅仅估计每个值使用的内存并相应地设置maxsize，因为有几个进程将并行调用修饰函数；一个解决方案需要实际动态地检查有多少内存是空闲的。
浏览 3提问于2014-05-05得票数 16
是否有某种方法可以缓存属性，直到类实例的某些输入属性发生更改？我希望在类实例的一些输入属性被更新后调用缓存属性时重新计算缓存属性(并再次缓存它们)。 如果我有一个这样的类： class C:
def __init__(self, a):
self.a=a
@cached_property
def expensive(self):
return 'some calculation which depends on the attribute "a"'
def dependent(self):
浏览 38提问于2020-06-12得票数 1
我缓存的值计算缓慢，但通常需要几次。我有一本字典，看起来像这样：
stored_values = {
hash1: slow_to_calc_value1
hash2: slow_to_calc_value2
# And so on x5000
}
我像这样使用它，如果它是以前计算过的，可以快速获取它的值。
def calculate_value_for_item(item):
item_hash = hash_item(item) # Hash the item, used as the dictionary key
stored_value = st
浏览 2提问于2022-01-20得票数 -1
回答已采纳
这里是我的代码，它定义了时间装饰器：
from functools import wraps, lru_cache
def timed(fn):
from time import perf_counter
@wraps(fn)
def inner(*args,**kwargs):
start = perf_counter()
result = fn(*args,**kwargs)
end = perf_counter()
timer = end - start
fs = '{
浏览 4提问于2020-01-10得票数 0
回答已采纳
我的程序的第一步是获取数据。在那之后，我发现自己一次又一次地将这些数据传递给所有不同的类(还有一个config字典变量)。 所以我想知道是否有一种更好的方法来存储数据，并使其可用于所有类和函数，而不是将它们作为参数传递。 谢谢 编辑:这是一个代码示例 go.py config = {
'mode' : 'single',
'data' : { },
'strategy' : { },
'view' : { }
}
stratego.start(config) stratego.p
浏览 22提问于2021-08-13得票数 0
3回答
我正在尝试测试一个通过lru_cache回传的方法(因为它是一个昂贵的数据库调用)。用pytest-mock。
代码的一个简化版本是：
class User:
def __init__(self, file):
# load a file
@lru_cache
def get(self, user_id):
# do expensive call
然后我在测试：
class TestUser:
def test_get_is_called(self, mocker):
data = mocker.ANY
浏览 1提问于2019-01-24得票数 5
回答已采纳
1回答
numpy数组的缓存修饰器
、、、、
我正在尝试为带有numpy数组输入参数的函数做一个缓存修饰器。
from functools import lru_cache
import numpy as np
from time import sleep
a = np.array([1,2,3,4])
@lru_cache()
def square(array):
sleep(1)
return array * array
square(a)
但是numpy数组是不可理解的，
TypeError Traceback (most recent call
浏览 2提问于2018-09-14得票数 12
回答已采纳
1回答
我有一个I/O跟踪文件，包含以下字段('asu‘、'block_address’、'size‘、'opcode’、'time_stamp')。数据看起来是这样的。(500多万行)
0,20941264,8192,W,0.551706
0,20939840,8192,W,0.554041
0,20939808,8192,W,0.556202
1,3436288,15872,W,1.250720
1,3435888,512,W,1.609859
1,3435889,512,W,1.634761
0,7695360,4096,R,2.346628
1,
浏览 0提问于2018-03-23得票数 3
回答已采纳
2回答
我有一个函数需要很长的时间，并且需要能够缓存它自己的结果，以便当它用相同的参数再次被调用时。参见下面的示例，该示例似乎解决了问题。我使用Python3.6
我的问题围绕着这条线：
param_sig = repr(locals())
1)是否有更多的Pythonic方法来获得传递给函数的参数的唯一签名？
2)我能否依赖Python将函数参数插入到局部变量()映射中的顺序？同样，这似乎是可行的，但是如果需要的话，我可以显式地重放一个不太优雅的签名创建者中的每个参数，例如：
param_sig = "{},{},{}".format(a,b,c)
示例代码：
import rand
浏览 6提问于2018-01-08得票数 2
回答已采纳
给定以下功能
@lru_cache(maxsize=1)
def get_response_from_api() -> List[ApiObject]:
url = _get_api_url()
response = requests.get(url).text
return json.loads(response, object_hook=_create_api_obj)
跑步时
类型预测器-忽略-缺失-导入-严格
我收到了错误消息：
错误:非类型化装饰器使函数"get_response_from_api“非类型化
我怎么才能解决这个问题
浏览 0提问于2018-05-23得票数 12
1回答
我的问题非常类似于，但在我的例子中，被接受的答案并不会在包中使用时修饰包中的所有函数，我也不知道为什么。
例如，我有一个项目设置如下：
project/
package/
__init__.py
module_a.py
module_b.py
main.py
__init__.py
from .module_a import *
from .module_b import *
import types
# This is the decorator that will be used
from functools import
浏览 13提问于2016-12-06得票数 0
回答已采纳
这里是python新手。
我正在努力实现一个递归的、回忆录的函数(关于两个变量的公式)，但我现在离它很远。
所以目前我认为我的主要问题是，在我首先调用这个函数，fun1，并进行一些操作之后，我想再次将一组经过修改的初始农具传递给这个函数。但是当我这样做的时候，错误说它只收到一个参数--一个元组。下面是错误和底部的脚本。目前，我只是尝试一次删除一个参数(p1tpn)，直到只剩下一个，但真正的情况会有所不同。
fun1(2,4,6)
I was called with 3 arguments: (2, 4, 6)
with arg <class 'tuple'>
[a
浏览 0提问于2018-01-20得票数 0
回答已采纳
2回答
考虑一个带有很多参数*x的函数f(*x)。基于这些参数(对象)，函数f组成一个相当复杂的对象o并返回它。o实现了__call__，所以o本身就是一个函数。由于o的组成相当耗时，而且在我的场景中，基于相同参数*x的多个o实例是没有意义的，因此它们将被缓存。
现在的问题是:如何有效地计算基于多参数*x的散列？目前我使用的是python字典，我连接每个x的str()表示来构建每个键。它在我的场景中工作，但感觉相当笨拙。我需要以非常高的频率调用结果对象o，所以我怀疑重复调用str()和字符串连接浪费了大量的计算时间。
浏览 5提问于2014-06-09得票数 1
2回答
我想做一个蟒蛇装潢师，它可以回忆录功能。例如，如果
@memoization_decorator
def add(a, b, negative=False):
print "Computing"
return (a + b) * (1 if negative is False else -1)
add(1, 2)
add(1, b=2)
add(1, 2, negative=False)
add(1, b=2, negative=False)
add(a=1, b=2, negative=False)
add(a=1, b=2)
我希望输出是
Comp
浏览 0提问于2016-04-21得票数 3
回答已采纳
3回答
有没有更快或更短的方法来编写下面的代码，以避免在不定义另一个变量的情况下计算两次f(x)？ # could be any function or condition
if f(x) == 0:
print(f(x))
# with additional variable
y = f(x)
if y == 0:
print(y)
浏览 31提问于2021-09-10得票数 0
回答已采纳
在Pandas中，我可以使用.apply将函数应用到两列。例如,
df = pd.DataFrame({'A':['a', 'a', 'a', 'b'], 'B':[3, 3, 2, 5], 'C':[2, 2, 2, 8]})
formula = lambda x: (x.B + x.C)**2
df.apply(formula, axis=1)
但是，请注意，前两行的结果是相同的，因为所有输入都是相同的。在具有复杂操作的大型数据集中。这些重复的计算可能会减慢我的程序。有没有一种方
浏览 0提问于2017-12-08得票数 2
2回答
我试图使用一个固定的字典向一个昂贵的函数添加一个各种缓存。就像这样：
def func(arg):
if arg in precomputed:
return precomputed[arg]
else:
return expensive_function(arg)
现在，如果我可以使用dict.get()默认值来做这样的事情，它会更干净一些：
def func(arg):
return precomputed.get(arg, expensive_function(arg))
问题是，不管expensive_function()是否成功
浏览 5提问于2020-02-21得票数 1
def hexify(summ, l, count = 0):
if sum == 0:
return 1
for i in range(16):
if i < summ and l > 1:
count += hexify(summ-i, l-1)
elif i == summ and l > 0:
count += 1
return count
hexa = str(input())[2:] #input tag eg. 0x
浏览 5提问于2022-03-14得票数 0
回答已采纳
我希望有一个可以使用functools.lru_cache的函数，但不是默认的。我正在寻找一种方法来使用可以用来禁用lru_cache的函数参数。目前，我有两个版本的函数，一个有lru_cache，一个没有。然后我有另一个函数，它用一个参数包装这些函数，该参数可以用来控制使用哪个函数
def _no_cache(foo):
print('_no_cache')
return 1
@lru_cache()
def _with_cache(foo):
print('_with_cache')
return 0
def cach
浏览 3提问于2019-06-11得票数 5
1回答
通常我会使用inspect.getargspec，但是如何获取已绑定的方法的参数呢？
例如，如何获取方法'foo‘的参数名称，如下所示：
class Foo(object):
@memoized
def foo(self, arg1, arg2):
pass
注意，Foo().foo是一个带记忆的对象
这意味着它实际上是一个functools.partial实例。
我如何获取原始函数，或者以某种方式获取参数？
如果不能，这是否表明PythonDecoratorLibrary存在设计缺陷？
浏览 0提问于2011-09-22得票数 1
回答已采纳
如何在不泄漏内存的情况下在类中使用functools的lru_cache？在下面的最小示例中，尽管超出了作用域并且没有referrer (除了lru_cache之外)，foo实例也不会被释放。
from functools import lru_cache
class BigClass:
pass
class Foo:
def __init__(self):
self.big = BigClass()
@lru_cache(maxsize=16)
def cached_method(self, x):
return x + 5
浏览 79提问于2015-11-12得票数 60
回答已采纳
假设我想要执行以下操作
def calculate_something_extremally_resource_consuming():
# execute some api calls and make insane calculations
if calculations_sucessfull:
return result
与此同时，项目中的其他地方：
if calculate_something_extremally_resource_consuming():
a = calculate_something_extremally_resource_
浏览 3提问于2017-03-16得票数 1
2回答
我有一个简单的装饰器，可以打印所有函数的参数。假设我们有一些小函数和这个函数的一个包装器，并且想要记录这个包装器函数。
问题是，由于某些原因，参数不起作用，我得到了一个错误
如何重写函数log_step，以便允许我们关闭和打开用于打印函数实参的参数？
from functools import wraps
import inspect
def log_step(func, print_params = False):
@wraps(func)
def wrapper(*args, **kwargs):
tic = dt.datetime.now()
浏览 5提问于2021-11-01得票数 1
1回答
我正在学习一些Python，并想用字典回忆录来加速一个函数。但它变慢了！这是因为Python中的字典很慢，还是因为我应该做一些事情而不是使用setdefault呢？如果是这样的话，那么在Python中推荐和/或最快的回忆法是什么呢？
D={}
d1=lambda n: D.setdefault( n, 0 if n==1 else 1+d1(n//2 if n%2==0 else n*3+1) )
d2=lambda n: 0 if n==1 else 1+d2(n//2 if n%2==0 else n*3+1)
for n in range(1,40001
浏览 13提问于2021-08-11得票数 0
2回答
我希望改进值递归计算的性能。
n = 100
def T(n,k):
q = 0
if n == 0 and k == 0:
return(1)
q = 1
if k>n or n<0:
return(0)
q = 1
if q != 1:
return(T(n-1,k-1)+n*T(n-1,k))
for i in range(n):
for n in range(i+1):
print(T(i,n))
print("****
浏览 0提问于2020-10-19得票数 1
回答已采纳
5回答
我想在我的代码中使用lru_cache，但是，我得到了以下错误：
NameError: name 'lru_cache' is not defined
我的代码中确实有一个导入函式工具，但这没有帮助。
示例代码如下：
https://docs.python.org/3/library/functools.html
@lru_cache(maxsize=None)
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)
浏览 3提问于2016-04-18得票数 8
回答已采纳
2回答
我试图对下面的代码执行Collatz算法。当我使用1-10等的范围时，效果很好.但是，如果范围是1-500,000，它太慢了，永远不会给我显示最长序列的输出。
numberArray = []
s=int(1)
f=int(10)
def collatz(n):
global count
if n == 1:
count += 1
numberArray.append(count)
return True
elif (n % 2) == 0:
count += 1
collatz(n/2
浏览 13提问于2022-02-03得票数 0
5回答
有谁能解释一下为什么TypeError
fib()使用一个位置参数，但给出了两个
当我只给它一个论点，=>，self.fib(self.n - 1)！
另外，在保持类的实例化的同时，您能提出解决方案来解决这个问题吗？
我觉得“自我”被过度使用了，特别是在我添加的更多的方法中。这还能改进吗？
只是想把我的头绕在一些基本的东西上！感谢所有反馈意见。
class math_func:
def __init__(self, n: "int" = 6, output: "list" = []):
self.n =
浏览 0提问于2019-08-24得票数 1
3回答
我想要写一个函数，它接受一个单参数函数f和一个整数k，并返回一个函数，它的行为与f相同，除非它缓存f的最后k个结果。
例如，如果回忆录是我们所追求的函数，并且让mem_f = memoize(f，2)，那么：
mem_f(arg1) -> f(arg1) is computed and cached
mem_f(arg1) -> f(arg1) is returned from cache
mem_f(arg2) -> f(arg2) is computed and cached
mem_f(arg3) -> f(arg3)
浏览 0提问于2018-12-09得票数 3
回答已采纳
我有一个昂贵的函数，我想使用缓存它，但只在特定的运行时条件下使用。
基于装饰器，没有问题：
from functools import lru_cache
@lru_cache(maxsize=32)
def myfunc(a, b):
return a * b
print(myfunc(1,2))
print(myfunc(1,2))
print(myfunc(1,3))
print(f"cache_info:{myfunc.cache_info()}")
输出：
2
2
3
cache_info:CacheInfo(hits=1, misses=2, ma
浏览 0提问于2020-05-23得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
