更新

Question

我不是百分之百确定这是否被称为懒惰评估，但我希望在Python中这样做。

我有一个“设置向导”，用户将通过该向导创建一些全局变量，这些变量将用作类中的参数。

在全局变量param1和param2存在之前，不应评估

var = myClass(param1, param2)。但是，我需要var存在，因为我正在关联var0 = var.func，myClass中的一个函数。稍后在应用程序中，调用var0并执行func（）。

更新

以下是我的一些代码：

class myClass:

    def __init__(self, param1, param2):
        self.param1 = param1
        self.param2 = param2
    #------------------------------------------------------------------------
    def myFunction(self):
        """
        Some work here using self.param1 and self.param2
        """
    def myFunction2(self):
        """
        Some work here using self.param1 and self.param2
        """
    def myFunction3(self):
        """
        Some work here using self.param1 and self.param2
        """

myInstance = myClass(PARAM1, PARAM2)

myDict = {}
myDict["key1"] = myInstance.myFunction
myDict["key2"] = myInstance.myFunction2
myDict["key3"] = myInstance.myFunction3
# and so on...

用户通过wxPython向导中的操作将

PARAM1和PARAM2填充为全局变量。问题是在初始化时无法评估myInstance，因为PARAM1和PARAM2尚不存在。但是，字典键在初始化时与各种功能相关联，因为它们不会随着时间的推移而改变。

想法？

Answer 1

不，你不想这样做。

如果你真的需要这样做，你应该做的是使用承诺或期货来推迟对这些表达的评估。这是因为即使变量var存在，只有var.func包含具有成员var的对象时，表达式func才会毫无例外地进行评估。 python有许多承诺或未来的库 - 我建议你自己谷歌，以便选择最适合你的。

但是，更好的方法是在类存在或设置全局变量之前不执行任何这些操作。

不幸的是，由于您几乎没有提供您正在做的事情的细节，因此无法提供更具体的建议。

Answer 2

这是一个糟糕的想法

但是，这里有一些代码会做你想做的事情......

class myClass(object):
    @property
    def var0(self):
        return param1

a=myClass()
try:
    print (a.var0) #NameError because param1 isn't defined yet.
except NameError:
    pass

param1="foo"   
print a.var0

我们可以使它更“聪明”（见下文） - 现在你只需要传递一个字符串，其中包含将在某个时刻创建的变量的名称。

class myClass(object):
    def __init__(self,varname):
        self.varname=varname
    @property
    def var0(self):
        return globals()[self.varname]

a=myClass('param1')
try:
    print (a.var0) #KeyError now
except KeyError:
    pass

param1="foo"
print a.var0

这会延迟访问全局变量param1，直到它实际用于该类。但是，通常，您不想这样做。将实例创建推迟到定义了要传递的变量之后。

Answer 3

而不是

var = MyClass(p1, p2)

p1 = get_p1()
p2 = get_p2()

# magic happens

为什么不

var = MyClass()

p1 = get_p1()
var.p1 = p1

p2 = get_p2()
var.p2 = p2

Answer 4

我在我的代码中使用@staticmethod装饰器来解决这个问题，但我不会接受它作为答案，因为我不知道这是否是目前最好的答案!!

class myClass:
    #------------------------------------------------------------------------
    @staticmethod
    def myFunction(param1, param2):
        """
        Some work here using param1 and param2
        """
    @staticmethod
    def myFunction2(param1, param2):
        """
        Some work here using param1 and param2
        """
    @staticmethod
    def myFunction3(param1, param2):
        """
        Some work here using param1 and param2
        """

myDict = {}
myDict["key1"] = myClass.myFunction
myDict["key2"] = myClass.myFunction2
myDict["key3"] = myClass.myFunction3
# and so on...

在用户通过设置向导并填充PARAM1和PARAM2之后，我可以遍历字典并通过传递PARAM1和相关函数来计算相应的值对。 PARAM2喜欢这样：

for k in myDict.keys():
    myDict[k](PARAM1, PARAM2)

在设置参数之前，防止对类实例进行求值

更新

4 个答案: