想想这个例子:
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，考虑如何在类中调用函数?
当前回答
因为按照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相同)。
其他回答
在__init__方法中，self指向新创建的对象;在其他类方法中，它引用被调用方法的实例。
自我，作为一个名字，只是一个惯例，你想怎么叫就怎么叫!但是当使用它时，例如删除对象，你必须使用相同的名称:__del__(var)，其中var在__init__(var，[…])中使用。
你也应该看一看cls，以获得更大的图景。这篇文章可能会有帮助。
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
“self”这个词指的是一个类的实例
class foo:
def __init__(self, num1, num2):
self.n1 = num1 #now in this it will make the perimeter num1 and num2 access across the whole class
self.n2 = num2
def add(self):
return self.n1 + self.n2 # if we had not written self then if would throw an error that n1 and n2 is not defined and we have to include self in the function's perimeter to access it's variables
以下摘自关于self的Python文档:
As in Modula-3, there are no shorthands [in Python] for referencing the object’s members from its methods: the method function is declared with an explicit first argument representing the object, which is provided implicitly by the call. Often, the first argument of a method is called self. This is nothing more than a convention: the name self has absolutely no special meaning to Python. Note, however, that by not following the convention your code may be less readable to other Python programmers, and it is also conceivable that a class browser program might be written that relies upon such a convention.
有关更多信息，请参阅Python类文档教程。
The reason you need to use self. is because Python does not use special syntax to refer to instance attributes. Python decided to do methods in a way that makes the instance to which the method belongs be passed automatically, but not received automatically: the first parameter of methods is the instance the method is called on. That makes methods entirely the same as functions, and leaves the actual name to use up to you (although self is the convention, and people will generally frown at you when you use something else.) self is not special to the code, it's just another object.
Python could have done something else to distinguish normal names from attributes -- special syntax like Ruby has, or requiring declarations like C++ and Java do, or perhaps something yet more different -- but it didn't. Python's all for making things explicit, making it obvious what's what, and although it doesn't do it entirely everywhere, it does do it for instance attributes. That's why assigning to an instance attribute needs to know what instance to assign to, and that's why it needs self..
