这是为了最小化方法和函数之间的差异。它允许您轻松地在元类中生成方法，或在运行时向已存在的类添加方法。

e.g.

>>> 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运行时的实现更容易。

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

我认为这和PEP 227有关

Names in class scope are not accessible. Names are resolved in the innermost enclosing function scope. If a class definition occurs in a chain of nested scopes, the resolution process skips class definitions. This rule prevents odd interactions between class attributes and local variable access. If a name binding operation occurs in a class definition, it creates an attribute on the resulting class object. To access this variable in a method, or in a function nested within a method, an attribute reference must be used, either via self or via the class name.

还有另一个非常简单的答案:根据python的禅宗，“显式比隐式好”。

这是为了最小化方法和函数之间的差异。它允许您轻松地在元类中生成方法，或在运行时向已存在的类添加方法。

e.g.

>>> 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运行时的实现更容易。

也允许你这样做:(简而言之，调用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_self绑定到MagicMethod实例。奇怪的是吧?这就像在Java和c#等语言中有两个关键字this1和this2。像这样的魔术允许框架做一些事情，否则会非常冗长。

再说一次，我不想评论这些东西的道德性。我只是想展示一些如果没有显式的自我引用就很难做到的事情。