想想这个例子:
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，考虑如何在类中调用函数?
当前回答
在__init__方法中，self指向新创建的对象;在其他类方法中，它引用被调用方法的实例。
自我，作为一个名字，只是一个惯例，你想怎么叫就怎么叫!但是当使用它时，例如删除对象，你必须使用相同的名称:__del__(var)，其中var在__init__(var，[…])中使用。
你也应该看一看cls，以获得更大的图景。这篇文章可能会有帮助。
其他回答
"self"关键字保存类的引用，这取决于你是否想要使用它，但如果你注意到，每当你在python中创建一个新方法时，python会自动为你写self关键字。如果你做了一些研究，你会注意到，如果你在一个类中创建了两个方法，并试图在另一个方法中调用一个方法，它不会识别方法，除非你添加self(类的引用)。
class testA:
def __init__(self):
print('ads')
def m1(self):
print('method 1')
self.m2()
def m2(self):
print('method 2')
以下代码抛出无法解决的引用错误。
class testA:
def __init__(self):
print('ads')
def m1(self):
print('method 1')
m2() #throws unresolvable reference error as class does not know if m2 exist in class scope
def m2(self):
print('method 2')
现在让我们看看下面的例子
class testA:
def __init__(self):
print('ads')
def m1(self):
print('method 1')
def m2():
print('method 2')
现在，当您创建类testA的对象时，您可以像这样使用类对象调用方法m1()，因为方法m1()包含了self关键字
obj = testA()
obj.m1()
但是如果你想调用方法m2()，因为它没有自我引用，所以你可以像下面这样直接使用类名调用m2()
testA.m2()
但是要坚持使用self关键字，因为它还有其他好处，比如在内部创建全局变量等等。
它的使用类似于Java中this关键字的使用，即给出对当前对象的引用。
我将用不使用类的代码演示:
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 )
[把我的答案从重复的封闭式问题中迁移过来]
让我们看一个简单的向量类:
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中编写实例方法;你所写的是类方法，它必须以一个实例作为第一个参数。因此，必须显式地将实例参数放置在某个位置。
Self的作用类似于当前对象名或类的实例。
# Self explanation.
class classname(object):
def __init__(self,name):
self.name=name
# Self is acting as a replacement of object name.
#self.name=object1.name
def display(self):
print("Name of the person is :",self.name)
print("object name:",object1.name)
object1=classname("Bucky")
object2=classname("ford")
object1.display()
object2.display()
###### Output
Name of the person is : Bucky
object name: Bucky
Name of the person is : ford
object name: Bucky
