问题描述：

在 Python 中，在类上定义方法时，它看起来像这样：

class MyClass(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

但是在某些其他语言中，例如 C#，您可以使用“this”关键字引用方法绑定到的对象，而无需在方法原型中将其声明为参数。

这是 Python 中有意为之的语言设计决策吗，或者是否有一些实现细节需要将“self”作为参数传递？

解决方案 1：

我喜欢引用 Peters 的《Python 之禅》。“显式优于隐式。”

在 Java 和 C++ 中，this.可以推断出“ ”，除非变量名使其无法推断。所以有时需要它，有时不需要。

Python 选择使这样的事情明确化而不是基于规则。

此外，由于没有任何暗示或假设，因此部分实现是暴露的 self.__class__，self.__dict__并且其他“内部”结构以明显的方式可用。

解决方案 2：

它是为了尽量减少方法和函数之间的差异。它允许您轻松地在元类中生成方法，或者在运行时将方法添加到预先存在的类中。

例如

>>> class C:
...     def foo(self):
...         print("Hi!")
...
>>>
>>> def bar(self):
...     print("Bork bork bork!")
...
>>>
>>> c = C()
>>> C.bar = bar
>>> c.bar()
Bork bork bork!
>>> c.foo()
Hi!
>>>

它还（据我所知）使得 python 运行时的实现更容易。

解决方案 3：

我建议大家应该阅读Guido van Rossum关于这个主题的博客 -为什么显性自我必须保留。

当方法定义被修饰时，我们不知道是否自动为其赋予“self”参数：修饰器可以将函数转换为静态方法（没有“self”）或类方法（具有一种奇怪的 self，它引用类而不是实例），或者它可以做一些完全不同的事情（用纯 Python 编写实现“@classmethod”或“@staticmethod”的修饰器很简单）。如果不知道修饰器的作用，就无法为定义的方法赋予隐式“self”参数。

我拒绝使用像特殊大小写的“@classmethod”和“@staticmethod”这样的黑客技术。

解决方案 4：

Python 不会强迫您使用“self”。您可以给它起任何您想要的名字。您只需记住方法定义头中的第一个参数是对对象的引用。

解决方案 5：

还允许您执行以下操作：（简而言之，调用Outer(3).create_inner_class(4)().weird_sum_with_closure_scope(5)将返回 12，但会以最疯狂的方式执行。

class Outer(object):
    def __init__(self, outer_num):
        self.outer_num = outer_num

    def create_inner_class(outer_self, inner_arg):
        class Inner(object):
            inner_arg = inner_arg
            def weird_sum_with_closure_scope(inner_self, num)
                return num + outer_self.outer_num + inner_arg
        return Inner

当然，在 Java 和 C# 等语言中，这更难想象。通过明确自我引用，您可以自由地通过该自我引用引用任何对象。此外，在更静态的语言中，这种在运行时处理类的方式更难实现 - 这并不是说它一定是好是坏。只是显式的自我允许所有这些疯狂的事情存在。

此外，想象一下：我们想要自定义方法的行为（用于分析，或一些疯狂的黑魔法）。这可以让我们思考：如果我们有一个Method可以覆盖或控制其行为的类会怎么样？

嗯，就是这样：

from functools import partial

class MagicMethod(object):
    """Does black magic when called"""
    def __get__(self, obj, obj_type):
        # This binds the <other> class instance to the <innocent_self> parameter
        # of the method MagicMethod.invoke
        return partial(self.invoke, obj)


    def invoke(magic_self, innocent_self, *args, **kwargs):
        # do black magic here
        ...
        print magic_self, innocent_self, args, kwargs

class InnocentClass(object):
    magic_method = MagicMethod()

现在：InnocentClass().magic_method()将按预期运行。该方法将与innocent_self参数绑定到InnocentClass，并与magic_selfMagicMethod 实例绑定。很奇怪吧？这就像在 Java 和 C# 等语言中拥有 2 个关键字this1和this2。像这样的 Magic 允许框架执行原本会更加冗长的事情。

再次强调，我不想评论这些事情的道德问题。我只是想展示一些如果没有明确的自我参照就很难做到的事情。

解决方案 6：

我认为这与 PEP 227 有关：

类作用域中的名称不可访问。名称在最内层的封闭函数作用域中解析。如果类定义出现在嵌套作用域链中，解析过程将跳过类定义。此规则可防止类属性和局部变量访问之间的奇怪交互。如果名称绑定操作发生在类定义中，它会在生成的类对象上创建一个属性。要在方法中或方法内嵌套的函数中访问此变量，必须使用属性引用，可以通过 self 或类名进行。

解决方案 7：

我认为除了“Python 之禅”之外的真正原因是函数是 Python 中的一等公民。

这实际上使它们成为对象。现在，根本问题是，如果您的函数也是对象，那么在面向对象范式中，当消息本身是对象时，您将如何向对象发送消息？

看起来像是先有鸡还是先有蛋的问题，为了减少这种悖论，唯一可能的方法是将执行上下文传递给方法或检测它。但由于 python 可以有嵌套函数，因此不可能这样做，因为内部函数的执行上下文会发生变化。

这意味着唯一可能的解决方案是明确传递“self”（执行上下文）。

所以我相信这是一个实施问题，禅宗出现得比较晚。

解决方案 8：

正如Python 中的 self, Demystified中解释的那样

任何类似 obj.meth(args) 的东西都会变成 Class.meth(obj, args)。调用过程是自动的，而接收过程则不是（它是显式的）。这就是类中函数的第一个参数必须是对象本身的原因。

class Point(object):
    def __init__(self,x = 0,y = 0):
        self.x = x
        self.y = y

    def distance(self):
        """Find distance from origin"""
        return (self.x**2 + self.y**2) ** 0.5

调用：

>>> p1 = Point(6,8)
>>> p1.distance()
10.0

init () 定义了三个参数，但我们只传递了两个（6 和 8）。类似地，distance() 需要一个参数，但我们只传递了零个参数。

为什么 Python 没有抱怨这个参数数量不匹配？

通常，当我们调用带有一些参数的方法时，会通过将方法的对象放在第一个参数之前来调用相应的类函数。因此，任何类似 obj.meth(args) 的东西都变成 Class.meth(obj, args)。调用过程是自动的，而接收过程不是（它是显式的）。

这就是类中函数的第一个参数必须是对象本身的原因。将此参数写为 self 仅仅是一种惯例。它不是关键字，在 Python 中没有特殊含义。我们可以使用其他名称（像这样），但我强烈建议您不要这样做。大多数开发人员不赞成使用 self 以外的名称，并且会降低代码的可读性（“可读性很重要”）。...
在第一个示例中
，

self.x 是一个实例属性，而 x 是一个局部变量。它们不一样，位于不同的命名空间中。

自我将继续存在

许多人提议将self 设为 Python 中的关键字，就像 C++ 和 Java 中一样。这将消除方法中形式参数列表中显式 self 的冗余使用。虽然这个想法看起来很有希望，但它不会实现。至少在不久的将来不会。主要原因是向后兼容性。这里有一篇来自 Python 创建者自己的博客，解释了为什么显式 self 必须保留。

解决方案 9：

“self”参数保留当前调用对象。

class class_name:
    class_variable
    def method_name(self,arg):
        self.var=arg 
obj=class_name()
obj.method_name()

这里，self 参数保存的是对象 obj。因此，语句 self.var 表示 obj.var

解决方案 10：

还有另一个非常简单的答案：根据Python 之禅，“显式优于隐式”。