我不是100％确定这被称为懒惰评估或不，但我希望在Python中做到这一点。防止类实例被评估，直到它的参数已被设置

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

var = myClass(param1, param2)只有全局变量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...

PARAM1和PARAM2被填充是以通过wxPython的向导内部行为的用户全局变量。问题是myInstance无法在初始化时进行评估，因为PARAM1和PARAM2尚不存在。但是，字典键在初始化时与各种功能相关联，因为它们不会随时间而改变。

想法？

来源

2012-07-11 Michael Markieta

你可以在这里提供更多的细节吗？没有办法阻止'myClass（param1，param2）'立即评估param1和param2。具体取决于你需要做什么，你可能能够将你的一些对象包装在一个lambda表达式中，并在稍后对它们进行评估。但是你需要展示一个完整的例子（即使它是假的）。 – BrenBarn 2012-07-11 17:28:14

没有更多的细节，这并不是真正的问题。 – Marcin 2012-07-11 17:39:43

“我正在关联var0 = var.func”。除非在这里有更多的事情发生，否则稍后在应用程序中调用'var.func'会更简单很多。 – JAB 2012-07-11 17:40:54

我用@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)

来源

2012-07-11 23:37:00

这是一个坏主意

但是，这里的一些代码，会做你想要什么，我想......

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，直到它实际上是在课堂上使用。但是，一般来说，你不想这样做。推迟实例创建，直到您要传递的变量已被定义为止。

来源

2012-07-11 17:36:47 mgilson

不，你不想这样做。

如果您真的需要这样做，您应该做的是使用promise或future来延迟对这些表达式的评估。这是因为即使存在变量var，表达式var.func也只会评估，如果var持有成员func的对象。 python有许多承诺或未来的图书馆 - 我建议你自己谷歌，以便选择最适合你的图书馆。

但是，更好的方法是直到类存在或设置全局变量时才执行这些操作。

不幸的是，由于您几乎没有提供任何细节，因此不可能提供更具体的建议。

来源

2012-07-11 17:38:32 Marcin

而不是

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

来源

2012-07-11 18:56:16

防止类实例被评估，直到它的参数已被设置

更新

回答

相关问题