Python 类方法 : when is self not needed

Question

我正在尝试使用类重写一些代码。在某些时候，我想要的是使用对象的每个实例的参数值为成员函数分配一个特定的定义。

来自其他语言(JavaScript、C++、Haskell、Fortran 等)，我正在努力理解一些关于 Python 的东西。一件事是类方法中 self 的以下区别。

例如，下面的代码显然是行不通的:

class fdf:
    def f(x):
        return 666

class gdg(fdf):
    def sq():
        return 7*7

hg = gdg()
hf = fdf()
print(hf.f(),hg.f(),hg.sq())

给出错误“sq() 采用 0 个位置参数，但给出了 1 个”。

据我所知，原因是在执行时函数被传递给调用对象(调用 sq 的实例)的引用作为第一个参数，然后我们可能会传递任何其他参数/​​参数已经定义/调用了 sq 。所以解决办法很简单:把sq的代码改成def sq(self):。事实上，Python tutorial 1 似乎 建议对象方法应始终以 self 作为第一个参数来定义。这样做我们得到预期的 666 666 49。到目前为止一切顺利。

但是，当我尝试像这样实现我的类时:

class Activation:
    def nonLinearBipolarStep(self,x,string=None):
        if not string: return (-1 if x<0 else 1 )
        else: return ('-' if x<0 else '1')

    default='bipolar'
    activationFunctions = {
        'bipolar': nonLinearBipolarStep ,
    }
    def _getActivation(self,func=default):
        return self.activationFunctions.get(func,self.activationFunctions.get(self.default))

    def __init__(self,func=None):
        if func == None: func=self.default 
        self.run = self._getActivation(func)


ag = Activation()
print(ag.run(4))

我得到了错误

nonLinearBipolarStep() missing 1 required positional argument: 'x'

但是，解决方法(解决方案？？)是将不带参数 self (!) 的 step 函数定义为

def nonLinearBipolarStep(x,string=None):

然后我得到了 1 的预期行为(至少对于这个简单的测试)。所以，这里不仅不需要 self，而且在这里使用它甚至是不正确的!

但是根据上面提到的教程，或者像this 这样的线程中的答案。 2或 this 3 ，在我看来这段代码不应该工作......或者应该在某些时候产生一些意想不到的后果(？)。确实，如果我在定义中删除对 self 的所有引用_getActivation 我收到错误消息 _getActivation() takes from 0 to 1 positional arguments but 2 were given 根据该规则我可以​​理解。

线程"Why is self not used in this method" 4没有给我提供明确的答案:上面代码的哪些语法细节告诉我不需要 self？例如，该代码与本教程示例有何不同

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

?实例化此类按预期工作，但如果没有定义，它会提示缺少参数(我知道它可以是任何标签)。

这让我怀疑我的代码是否没有以某种方式隐藏定时炸弹:self 是否作为 x 的值传递？它按预期工作，所以我会说不，但后来我面临着这个难题。

我想我遗漏了该语言的一些关键思想。我承认我也在为引用 OP 的问题而苦苦挣扎 3在问^。

[^]:在 JS 中，只需在函数体中使用 this，并且函数本身被定义为对象原型(prototype)的成员或实例成员，然后被正确分配使用。 ..这个。

编辑:线很长。对于那些浏览寻求帮助的人，如果您是 Python 的新手，那么您可能需要检查所选的解决方案及其注释。但是，如果您已经了解 Python 中的绑定(bind)/未绑定(bind)方法，您只想直接检查描述符的使用，如 Blckknght 的回答中所述。我最终在要运行的作业中使用 __get__ 在我的代码中选择了这种方式。

Answer 1

什么是self ？

在 Python 中，每个普通 方法都被迫接受一个通常名为 self 的参数。 .这是类的一个实例——一个对象。这就是 Python 方法与类的状态交互的方式。

您可以随意重命名此参数。但它将始终具有相同的值:

>>> class Class:
    def method(foo): # 
        print(foo)

        
>>> cls = Class()
>>> cls.method()
<__main__.F object at 0x03E41D90>
>>> 

但为什么我的示例有效？

但是，您可能对这段代码的工作方式有何不同感到困惑:

>>> class Class:
    def method(foo):
        print(foo)

    methods = {'method': method}
    
    def __init__(self):
        self.run = self.methods['method']

        
>>> cls = Class()
>>> cls.run(3)
3
>>> 

这是因为 Python 中绑定(bind)和未绑定(bind)方法之间的区别。

当我们在 __init__() 中执行此操作时:

self.run = self.methods['method']

我们指的是unbound 方法method .这意味着我们对 method 的引用未绑定(bind)到 Class 的任何特定实例，因此，Python 不会强制 method接受一个对象实例。因为它没有人可以给。

上面的代码和这样做是一样的:

>>> class Class:
    def method(foo):
        print(foo)

        
>>> Class.method(3)
3
>>> 

在这两个示例中，我们都调用了方法 method类对象 Class ，并且不是 Class 的实例对象。

我们可以通过检查 repr 来进一步了解这种区别对于绑定(bind)和未绑定(bind)方法:

>>> class Class:
    def method(foo):
        print(foo)

        
>>> Class.method
<function Class.method at 0x03E43D68>
>>> cls = Class()
>>> cls.method
<bound method Class.method of <__main__.Class object at 0x03BD2FB0>>
>>> 

如您所见，在第一个示例中我们执行 Class.method , Python 显示: <function Class.method at 0x03E43D68> .我对你撒了一点谎。当我们有一个类的未绑定(bind)方法时，Python 将它们视为普通函数。所以method只是一个未绑定(bind)到“类”的任何实例的函数。

但是在第二个例子中，当我们创建一个 Class 的实例时, 然后访问 method它的对象，我们看到打印:<bound method Class.method of <__main__.Class object at 0x03BD2FB0>> .

要注意的关键部分是bound method Class.method .这意味着 method **绑定(bind)**到cls - Class 的一个特定实例.

一般说明

正如@jonshapre 所提到的，像您的示例中那样编写代码会导致混淆(正如这个问题所证明的那样)和错误。如果您简单地定义 nonLinearBipolarStep() 会更好在Activation 之外 ，并从 Activation.activation_functions 的内部引用它:

def nonLinearBipolarStep(self,x,string=None):
        if not string: return (-1 if x<0 else 1 )
        else: return ('-' if x<0 else '1')

class Activation:

    activation_functions = {
        'bipolar': nonLinearBipolarStep,
    }

    ...

I guess a more specific question would be: what should I pay attention to on that code in order to become evident that ag.run(x) would be a call to an unbound function?

如果你还想让nonLinearBipolarStep不受约束，那么我建议只是小心。如果您认为您的方法会产生最干净的代码，那就去做吧，但请确保您知道自己在做什么以及您的代码将具有的行为。

如果您仍想向您类(class)的用户表明 ag.run()将是静态的，您可以在某个地方的文档字符串中记录它，但这是用户根本不应该关心的事情。