想想这个例子:
class MyClass:
def func(self, name):
self.name = name
我知道self引用MyClass的特定实例。但是为什么func必须显式地包含self作为参数呢?为什么我们需要在方法的代码中使用self ?其他一些语言将其隐式化，或者使用特殊的语法。
有关设计决策的语言无关性考虑，请参见强制显式使用this/self指针的好处是什么?
要关闭OP省略方法的self形参并获得TypeError的调试问题，请使用TypeError: method()接受1个位置参数，但给出了2个。如果OP省略了self。在方法体中得到一个NameError，考虑如何在类中调用函数?
当前回答
让我们看一个简单的向量类:
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
我们需要一个计算长度的方法。如果我们想在类中定义它会是什么样子呢?
def length(self):
return math.sqrt(self.x ** 2 + self.y ** 2)
当我们将它定义为全局方法/函数时，它应该是什么样子?
def length_global(vector):
return math.sqrt(vector.x ** 2 + vector.y ** 2)
所以整个结构保持不变。我怎样才能利用这个呢?假设我们还没有为Vector类编写length方法，我们可以这样做:
Vector.length_new = length_global
v = Vector(3, 4)
print(v.length_new()) # 5.0
这是因为length_global的第一个参数可以重用为length_new中的self参数。如果没有显式的自我，这是不可能的。
另一种理解显式self需求的方法是查看Python在哪里添加了一些语法糖。当你记住的时候，基本上，一个电话就像
v_instance.length()
在内部转化为
Vector.length(v_instance)
很容易看出自我在哪里。实际上你不用在Python中编写实例方法;你所写的是类方法，它必须以一个实例作为第一个参数。因此，必须显式地将实例参数放置在某个位置。
其他回答
从医生那里，
方法的特殊之处在于实例对象是作为函数的第一个参数传递的。在我们的例子中，调用x.f()完全等价于MyClass.f(x)。一般来说，调用带有n个参数列表的方法相当于调用带有参数列表的相应函数，该参数列表是通过在第一个参数之前插入方法的实例对象创建的。
在此之前的相关片段，
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'
x = 我的类（）
因为按照python的设计，其他的选择几乎行不通。Python被设计为允许在隐式this (a-la Java/ c++)或显式@ (a-la ruby)都不能工作的上下文中定义方法或函数。让我们看一个带有python约定的显式方法的例子:
def fubar(x):
self.x = x
class C:
frob = fubar
现在fubar函数不能工作了，因为它假定self是一个全局变量(在frob中也是如此)。另一种方法是使用替换的全局作用域(其中self是对象)执行方法。
隐式方法是
def fubar(x)
myX = x
class C:
frob = fubar
这意味着myX将被解释为fubar(以及frob)中的局部变量。这里的替代方案是使用替换的局部作用域执行方法，该作用域在调用之间保留，但这将消除方法局部变量的可能性。
然而，目前的情况很好:
def fubar(self, x)
self.x = x
class C:
frob = fubar
在这里，当作为方法调用时，frob将通过self参数接收它所调用的对象，fubar仍然可以以对象作为参数调用并且工作相同(我认为它与C.frob相同)。
我将用不使用类的代码演示:
def state_init(state):
state['field'] = 'init'
def state_add(state, x):
state['field'] += x
def state_mult(state, x):
state['field'] *= x
def state_getField(state):
return state['field']
myself = {}
state_init(myself)
state_add(myself, 'added')
state_mult(myself, 2)
print( state_getField(myself) )
#--> 'initaddedinitadded'
类只是一种避免始终传递这种“状态”的方法(以及其他一些不错的事情，如初始化、类组合、很少需要的元类，以及支持自定义方法来覆盖操作符)。
现在让我们使用内置的python类机制来演示上面的代码，以展示它们基本上是相同的东西。
class State(object):
def __init__(self):
self.field = 'init'
def add(self, x):
self.field += x
def mult(self, x):
self.field *= x
s = State()
s.add('added') # self is implicitly passed in
s.mult(2) # self is implicitly passed in
print( s.field )
[把我的答案从重复的封闭式问题中迁移过来]
看看下面的例子，它清楚地解释了self的目的
class Restaurant(object):
bankrupt = False
def open_branch(self):
if not self.bankrupt:
print("branch opened")
#create instance1
>>> x = Restaurant()
>>> x.bankrupt
False
#create instance2
>>> y = Restaurant()
>>> y.bankrupt = True
>>> y.bankrupt
True
>>> x.bankrupt
False
Self用于/需要用于区分实例。
来源:python中的self变量解释- Pythontips
假设你有一个类ClassA，它包含一个方法methodA，定义为:
def methodA(self, arg1, arg2):
# do something
objectA是这个类的一个实例。
现在当objectA。当调用methodA(arg1, arg2)时，python会在内部将其转换为:
ClassA.methodA(objectA, arg1, arg2)
self变量引用对象本身。
