类方法中的“self”参数是什么？

您需要使用 self. 的原因是 Python 不使用 @ 语法来引用实例属性。 Python 决定以一种使方法所属的实例自动传递而不是自动接收的方式来执行方法：方法的第一个参数是方法的实例被调用。这使得方法与函数完全一样，并让您自己使用实际名称（尽管 self 是约定俗成的，当您使用其他东西时人们通常会皱眉头。）self 对代码，它只是另一个对象。

Python 可以做一些其他的事情来区分普通名称和属性——像 Ruby 那样的特殊语法，或者像 C++ 和 Java 那样需要声明，或者更不同的东西——但它没有。 Python 完全是为了让事情变得明确，让事情变得显而易见，尽管它并不完全在任何地方都这样做，但它确实可以为实例属性做到这一点。这就是为什么分配给实例属性需要知道要分配给哪个实例，这就是它需要 self. 的原因。

假设您有一个类 ClassA，其中包含定义为的方法 methodA：

def methodA(self, arg1, arg2):
    # do something

ObjectA 是此类的一个实例。

现在，当调用 ObjectA.methodA(arg1, arg2) 时，python 在内部为您将其转换为：

ClassA.methodA(ObjectA, arg1, arg2)

self 变量引用对象本身。

让我们看一个简单的向量类：

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，这是不可能的。

另一种理解显式 self 需求的方法是查看 Python 在哪里添加了一些语法糖。当你记住时，基本上，一个电话就像

v_instance.length()

内部转化为

Vector.length(v_instance)

很容易看出 self 的位置。您实际上并没有在 Python 中编写实例方法；你写的是类方法，它必须将实例作为第一个参数。因此，您必须将实例参数明确放置在某处。

实例化对象时，将对象本身传递给 self 参数。

https://i.stack.imgur.com/whCZm.png

因此，对象的数据被绑定到对象。下面是一个示例，说明您可能希望如何可视化每个对象的数据可能看起来的样子。请注意“self”是如何替换为对象名称的。我并不是说下面的这个示例图是完全准确的，但它希望能够用于可视化 self 的使用。

https://i.stack.imgur.com/5daR6.png

Object 被传递到 self 参数中，以便对象可以保留自己的数据。

虽然这可能并不完全准确，但请考虑像这样实例化对象的过程：当创建一个对象时，它使用类作为其自己的数据和方法的模板。如果不将它自己的名称传递给 self 参数，则类中的属性和方法将保留为通用模板，并且不会被引用（属于）对象。因此，通过将对象的名称传递给 self 参数，这意味着如果从一个类实例化 100 个对象，它们都可以跟踪自己的数据和方法。

请参见下图：

https://i.stack.imgur.com/oZZe5.png

我喜欢这个例子：

class A: 
    foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: [5]

class A: 
    def __init__(self): 
        self.foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: []

我将使用不使用类的代码进行演示：

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 )

[从重复的封闭问题中迁移了我的答案]

以下摘录来自 Python documentation about self：

与在 Modula-3 中一样，[在 Python 中] 没有用于从其方法中引用对象成员的简写：方法函数使用表示对象的显式第一个参数声明，该参数由调用隐式提供。通常，方法的第一个参数称为 self。这只不过是一个约定：名称 self 对 Python 绝对没有特殊含义。但是请注意，如果不遵循约定，您的代码对于其他 Python 程序员的可读性可能会降低，并且还可以想象编写依赖于这种约定的类浏览器程序。

有关详细信息，请参阅 Python documentation tutorial on classes。

除了已经说明的所有其他原因之外，它还允许更轻松地访问被覆盖的方法；您可以致电 Class.some_method(inst)。

一个有用的例子：

class C1(object):
    def __init__(self):
         print "C1 init"

class C2(C1):
    def __init__(self): #overrides C1.__init__
        print "C2 init"
        C1.__init__(self) #but we still want C1 to init the class too

>>> C2()
"C2 init"
"C1 init"

它的用法类似于Java 中使用this 关键字，即给出对当前对象的引用。

与 Java 或 C++ 不同，Python 不是为面向对象编程而构建的语言。

在 Python 中调用静态方法时，只需在其中编写一个带有常规参数的方法。

class Animal():
    def staticMethod():
        print "This is a static method"

然而，一个对象方法，它需要你创建一个变量，它是一个 Animal，在这种情况下，需要 self 参数

class Animal():
    def objectMethod(self):
        print "This is an object method which needs an instance of a class"

self 方法还用于引用类中的变量字段。

class Animal():
    #animalName made in constructor
    def Animal(self):
        self.animalName = "";


    def getAnimalName(self):
        return self.animalName

在这种情况下，self 指的是整个类的 animalName 变量。记住：如果方法中有变量，self 将不起作用。该变量仅在该方法运行时才存在。为了定义字段（整个类的变量），您必须在类方法之外定义它们。

如果您对我所说的一个字都没有理解，那么请谷歌“面向对象编程”。一旦你理解了这一点，你甚至不需要问那个问题:)。

首先，self 是一个传统名称，你可以用其他任何东西（连贯）来代替它。

它指的是对象本身，因此当您使用它时，您声明 .name 和 .age 是您要创建的 Student 对象（注意，不是 Student 类）的属性。

class Student:
    #called each time you create a new Student instance
    def __init__(self,name,age): #special method to initialize
        self.name=name
        self.age=age

    def __str__(self): #special method called for example when you use print
        return "Student %s is %s years old" %(self.name,self.age)

    def call(self, msg): #silly example for custom method
        return ("Hey, %s! "+msg) %self.name

#initializing two instances of the student class
bob=Student("Bob",20)
alice=Student("Alice",19)

#using them
print bob.name
print bob.age
print alice #this one only works if you define the __str__ method
print alice.call("Come here!") #notice you don't put a value for self

#you can modify attributes, like when alice ages
alice.age=20
print alice

Code is here

self 是对对象本身的对象引用，因此它们是相同的。 Python 方法不会在对象本身的上下文中调用。 Python 中的 self 可用于处理自定义对象模型或其他东西。

它遵循 Python 禅宗“显式胜于隐式”。它确实是对您的类对象的引用。例如，在 Java 和 PHP 中，它称为 this。

如果 user_type_name 是您模型上的一个字段，您可以通过 self.user_type_name 访问它。

我很惊讶没有人提到 Lua。 Lua 也使用 'self' 变量，但它可以省略但仍然使用。 C++ 对“this”做同样的事情。我认为没有任何理由必须在每个函数中声明“self”，但您仍然应该能够像使用 lua 和 C++ 一样使用它。对于一门以简洁而自豪的语言，它要求您声明 self 变量是很奇怪的。

使用通常称为 self 的参数并不难理解，为什么它是必要的？或者为什么明确提到它？我想，对于大多数查找这个问题的用户来说，这是一个更大的问题，或者如果不是，他们在学习 python 时肯定会有同样的问题。我建议他们阅读以下几篇博客：

1: Use of self explained

请注意，它不是关键字。

每个类方法（包括 init）的第一个参数始终是对当前类实例的引用。按照惯例，这个参数总是命名为 self。在init方法中，self指的是新创建的对象；在其他类方法中，它指的是调用其方法的实例。例如下面的代码与上面的代码相同。

2: Why do we have it this way and why can we not eliminate it as an argument, like Java, and have a keyword instead

我想补充的另一件事是，可选的 self 参数允许我在类中声明静态方法，而不是编写 self。

代码示例：

class MyClass():
    def staticMethod():
        print "This is a static method"

    def objectMethod(self):
        print "This is an object method which needs an instance of a class, and that is what self refers to"

PS：这只适用于 Python 3.x。

在以前的版本中，您必须显式添加 @staticmethod 装饰器，否则 self 参数是强制性的。

看看下面的例子，它清楚地解释了 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 用于/需要区分实例。

来源：self variable in python explained - Pythontips

是因为按照 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指的是新创建的对象；在其他类方法中，它指的是调用其方法的实例。

self，作为一个名字，只是一个约定，你想怎么称呼就怎么称呼！但是在使用它时，例如删除对象，您必须使用相同的名称：__del__(var)，其中 __init__(var,[...]) 中使用了 var

您也应该看看 cls，以了解全局。此 post 可能会有所帮助。

self 就像当前对象名称或 class 实例一样。

# 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

自我是不可避免的。

只有一个 question 应该是 self 是隐式的或显式的。 Guido van Rossum 用 self has to stay 解决了这个问题。

那么自我住在哪里呢？

如果我们只坚持函数式编程，我们就不需要 self。输入 Python OOP 后，我们会在其中找到 self。

这是使用方法 m1 的典型用例 class C

class C:
    def m1(self, arg):
        print(self, ' inside')
        pass

ci =C()
print(ci, ' outside')
ci.m1(None)
print(hex(id(ci))) # hex memory address

该程序将输出：

<__main__.C object at 0x000002B9D79C6CC0>  outside
<__main__.C object at 0x000002B9D79C6CC0>  inside
0x2b9d79c6cc0

所以 self 保存了类实例的内存地址。 self 的目的是保存实例方法的引用，并让我们显式访问该引用。

请注意，有三种不同类型的类方法：

静态方法（阅读：函数），

类方法，

实例方法（提到）。

“self”关键字包含类的引用，是否使用它取决于您，但如果您注意到，每当您在 python 中创建新方法时，python 都会自动为您编写 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 关键字，因为它还有其他好处，比如在内部创建全局变量等等。

“自我”一词是指类的实例

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

它是对类实例对象的显式引用。

从 docs，

方法的特殊之处在于实例对象作为函数的第一个参数传递。在我们的示例中，调用 xf() 完全等同于 MyClass.f(x)。通常，使用包含 n 个参数的列表调用方法等效于使用参数列表调用相应的函数，该参数列表是通过在第一个参数之前插入方法的实例对象而创建的。

在此之前的相关片段，

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

x = MyClass()

我会说至少对于 Python，self 参数可以被认为是一个占位符。看看这个：

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age)

在这种情况下，Self 和许多其他方法被用作存储名称值的方法。然而，在那之后，我们使用 p1 将它分配给我们正在使用的类。然后当我们打印它时，我们使用相同的 p1 关键字。

希望这对 Python 有所帮助！

我的小 2 美分

在这个 Person 类中，我们用 self 定义了 init 方法，这里要注意的是 self 和实例变量 p 相同<__main__.Person object at 0x106a78fd0>

class Person:

    def __init__(self, name, age):
        self.name = name 
        self.age = age 

    def say_hi(self):
        print("the self is at:", self)
        print((f"hey there, my name is {self.name} and I am {self.age} years old"))

    def say_bye(self):
        print("the self is at:", self)
        print(f"good to see you {self.name}")

p = Person("john", 78)
print("the p is at",p)
p.say_hi()  
p.say_bye()