Python 检查方法的输入值以减少计算量

我有许多方法，它们彼此独立，但需要共同计算输出。因此，当任何方法中的一个变量发生变化时，所有方法都会在计算中调用，这既慢又昂贵。以下是我所拥有的pesudo代码：

# o represents an origin variable
# valueA represents a variable which can change
def a (o, valueA): 
    # calculations
    return resultA

def b (o, valueB):
    # calculations
    return resultA

def c (o, valueC1, valueC2):
    # calculations
    return resultA

def compute (A, B, C1, C2):
    one = self.a(o, A)
    two = self.b(one,B)
    three = self.c(two, C1, C2)
    return img

例如，当C1的值发生变化时，调用

compute

时，尽管

a

和

b

没有变化，所有方法都会被计算出来。我想用某种方法检查

A、B、C1、C2

的哪些值在每次调用

compute

之间发生了变化

我考虑过定义一个值列表，然后在下一次调用时将其与传递给

compute

的新值进行比较。如；第一次呼叫：

list=[1,2,3,4]

第二次呼叫

list=[1,3,4,5]

因此

b

和

c

需要计算，但

a

是相同的。但是，我不确定如何从比较到定义调用哪个方法

我的特定应用程序的一些背景资料，以备使用。我有一个带有滑块的wxPython窗口，用于确定图像处理的值，并在这些滑块的每次更改上绘制图像

---

将每个调用与

compute

进行比较并删除这些浪费的重复计算的最佳方法是什么

> P>您可以考虑使用DICT的方法查找先前存储的计算结果（最好在类命名空间中允许在所有实例中优化内存）。 但是，如果使用许多参数调用这些方法，内存需求可能会非常严重，在这种情况下，您可能希望采用一种模式，尝试使计算更“收缩”（由数据的变化驱动，松散地）

---

这是两种方法。我肯定会有更多的想法。

< P>你可以考虑使用DICT的方法来查找先前存储的计算结果（最好在类命名空间中允许在所有实例中优化内存）。 但是，如果使用许多参数调用这些方法，内存需求可能会非常严重，在这种情况下，您可能希望采用一种模式，尝试使计算更“收缩”（由数据的变化驱动，松散地）

---

这是两种方法。我肯定会有更多的想法。

< P>你可以考虑使用DICT的方法来查找先前存储的计算结果（最好在类命名空间中允许在所有实例中优化内存）。 但是，如果使用许多参数调用这些方法，内存需求可能会非常严重，在这种情况下，您可能希望采用一种模式，尝试使计算更“收缩”（由数据的变化驱动，松散地）

---

这是两种方法。我肯定会有更多的想法。

< P>你可以考虑使用DICT的方法来查找先前存储的计算结果（最好在类命名空间中允许在所有实例中优化内存）。 但是，如果使用许多参数调用这些方法，内存需求可能会非常严重，在这种情况下，您可能希望采用一种模式，尝试使计算更“收缩”（由数据的变化驱动，松散地）

---

这是两种方法。我相信SO会想到更多的问题。

如果我必须解决这个问题，我会使用字典，其中键是valueX（或者如果它有多个，在示例C中是一个列表），值应该是函数的结果

所以，你应该有这样的东西：

{ valueA: resultA, valueB: resultB, [valueC1, valueC2]: resultC } 

为此，必须在函数中添加：

def a(o, valueA):
    [calcs]
    dic[valueA] = resultA
    return resultA
[...]
def c(o, valueC1, valueC2)
    [calcs]
    dic[[valueC1, valueC2]] = resultC
    return resultC

并且，在计算的函数中，您可以尝试获取参数的值，如果没有获取值，则进行计算

def compute (A, B, C1, C2):
    one = dic.get(A) if dic.get(A) else self.a(o, A)
    two = dic.get(B) if dic.get(B) else self.b(one,B)
    three = dic.get([C1,C2]) if dic.get([C1,C1]) else self.c(two, C1, C2)
    return img

---

这是@holdenweb在他的评论中指出的memoize函数的“粗略”实现。

如果我必须解决这个问题，我会使用字典，其中键是valueX（或者如果它有多个，在示例C中是一个列表），值应该是函数的结果

所以，你应该有这样的东西：

{ valueA: resultA, valueB: resultB, [valueC1, valueC2]: resultC } 

为此，必须在函数中添加：

def a(o, valueA):
    [calcs]
    dic[valueA] = resultA
    return resultA
[...]
def c(o, valueC1, valueC2)
    [calcs]
    dic[[valueC1, valueC2]] = resultC
    return resultC

并且，在计算的函数中，您可以尝试获取参数的值，如果没有获取值，则进行计算

def compute (A, B, C1, C2):
    one = dic.get(A) if dic.get(A) else self.a(o, A)
    two = dic.get(B) if dic.get(B) else self.b(one,B)
    three = dic.get([C1,C2]) if dic.get([C1,C1]) else self.c(two, C1, C2)
    return img

---

这是@holdenweb在他的评论中指出的memoize函数的“粗略”实现。

如果我必须解决这个问题，我会使用字典，其中键是valueX（或者如果它有多个，在示例C中是一个列表），值应该是函数的结果

所以，你应该有这样的东西：

{ valueA: resultA, valueB: resultB, [valueC1, valueC2]: resultC } 

为此，必须在函数中添加：

def a(o, valueA):
    [calcs]
    dic[valueA] = resultA
    return resultA
[...]
def c(o, valueC1, valueC2)
    [calcs]
    dic[[valueC1, valueC2]] = resultC
    return resultC

并且，在计算的函数中，您可以尝试获取参数的值，如果没有获取值，则进行计算

def compute (A, B, C1, C2):
    one = dic.get(A) if dic.get(A) else self.a(o, A)
    two = dic.get(B) if dic.get(B) else self.b(one,B)
    three = dic.get([C1,C2]) if dic.get([C1,C1]) else self.c(two, C1, C2)
    return img

---

这是@holdenweb在他的评论中指出的memoize函数的“粗略”实现。

如果我必须解决这个问题，我会使用字典，其中键是valueX（或者如果它有多个，在示例C中是一个列表），值应该是函数的结果

所以，你应该有这样的东西：

{ valueA: resultA, valueB: resultB, [valueC1, valueC2]: resultC } 

为此，必须在函数中添加：

def a(o, valueA):
    [calcs]
    dic[valueA] = resultA
    return resultA
[...]
def c(o, valueC1, valueC2)
    [calcs]
    dic[[valueC1, valueC2]] = resultC
    return resultC

并且，在计算的函数中，您可以尝试获取参数的值，如果没有获取值，则进行计算

def compute (A, B, C1, C2):
    one = dic.get(A) if dic.get(A) else self.a(o, A)
    two = dic.get(B) if dic.get(B) else self.b(one,B)
    three = dic.get([C1,C2]) if dic.get([C1,C1]) else self.c(two, C1, C2)
    return img

这是@holdenweb在评论中指出的memoize函数的“粗糙”实现