1

我怀疑类方法对某些变量集的作用与相应的非类函数的作用不同。这是一个例子。假设我们有一组变量：A、B、C，我们想根据一些算法随着时间的推移修改它们。有两种可能的实现：

1）与类：

   class variables:
       def __init__(self):
           self.A = 0.0
           self.B = 0.0
           self.C = 0.0
       def changeA(self):
           self.A = some function of A, B and C         
       def changeB(self):
           self.B = some function of A, B and C
       def changeC(self):
           self.C = some function of A, B and C

并多次调用：

    ob = variables()
    i = 0 
    while i<N:
        ob.changeA()
        ob.changeB()
        ob.changeC()
        i = i + 1

2）没有类

    A, B, C = 0.0, 0.0, 0.0
    def changeA(A,B,C):
        A = some function of A, B and C (same as in class method)
        return A
    def changeB(A,B,C):
        B = some function of A, B and C (same as in class method)
        return B
    def changeC(A,B,C):
        C = some function of A, B and C (same as in class method)
        return C

并多次调用：

    i = 0 
    while i<N:
        A = changeA(A,B,C)
        B = changeB(A,B,C)
        C = changeC(A,B,C)
        i = i + 1

在我看来，两种方法的结果必须相同。唯一的区别是变量 A、B 和 C 已知的命名空间（对象中的本地或函数实现的全局 - 但在这两种情况下，方法都可以访问所需的变量）。但是，两种方法的结果似乎不同。所以我的问题是在类方法实现/理解中我缺少什么吗？

更具体地说，方法changeA的实现示例：

作为类方法：

    (... inside the class)
    def changeA(self):
        self.A = self.A + 2.0*self.B - 3.0*self.C*(self.B-self.A)

作为一个函数：

    def changeA(A,B,C):
        A = A + 2.0*B - 3.0*C*(B-A)
        return A
4

1 回答 1

0

我想说的是，在第一种情况下，每次variables创建一个新实例时A，B和的值都会C被重置，而在第二种方法中它们似乎是全局的，情况并非如此。根据您使用这些实例的方式，结果可能会受到影响。

编辑：在评论中OP的问题之后，这里是如何定义类变量：

>>> class Variables:
    A = 0.0
    B = 0.0
    C = 0.0

    def changeA(self):
           Variables.A = Variables.A + Variables.B * Variables.C


>>> v = Variables()
>>> v.changeA()
>>> v.A
0.0
>>> Variables.A
0.0
>>>

如您所见，不再需要定义__init__方法。您可以通过instance.A或访问这些变量class.A。

于 2012-06-25T13:56:11.057 回答