“自我”参数的目的是什么？为什么需要它？

Question

考虑此示例：

class MyClass:
    def func(self, name):
        self.name = name

我知道 self 是指 myclass 的特定实例。但是，为什么 func 明确将 self 作为参数？为什么我们需要在方法的代码中使用 self ？其他一些语言使这种隐式或使用特殊语法。

---

_{对于A 语言 - agnostic 考虑设计决定的考虑指针强制性显式？。}

_{关闭调试问题其中op省略了 self 一种方法的参数并获得了 type> type> typeerror ，使用 typeError：typeError：method（）取1个位置参数，但给出了2个，但 。如果在该方法的正文中省略了 self。我可以在类中调用功能吗？。}

Answer 1

您需要使用 self。的原因是因为Python不使用特殊语法来参考实例属性。 Python决定以一种使该方法属于 自动传递的实例的方式，而不是自动传递的方法：方法的第一个参数是实例被称为。这使方法与函数完全相同，并将实际名称留给您（尽管 self 是惯例，当您使用其他内容时，人们通常会向您皱眉。）> self 对代码不是特别的，它只是另一个对象。

Python本可以做其他事情以将正常名称与属性区分开 - 像Ruby一样的特殊语法，或者需要C ++和Java之类的声明，或者可能更不同 - 但事实并非如此。 Python的全部是使事物明确的，使它显而易见，尽管它并不完全在任何地方做到这一点，但它确实做到了，例如属性。这就是为什么分配给实例属性需要知道要分配的实例的原因，这就是为什么它需要 self。。

Answer 2

假设您有一个类 classa ，其中包含方法 methoda 定义为：

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

和 objecta 是此类的实例。

现在，当调用 objecta.methoda（arg1，arg2）时，python内部将其转换为：

ClassA.methodA(objectA, arg1, arg2)

self 变量涉及对象本身。

Answer 3

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

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的第一个参数，可以作为 self 参数重复使用 length_new 。没有明确的 self ，这将是不可能的。

---

理解对明确 self 的需求的另一种方法是查看python添加一些句法糖。当您牢记时，基本上，像

v_instance.length()

内部转换为

Vector.length(v_instance)

内部的呼叫很容易看到 self 适合所在的位置。您实际上并未在Python中编写实例方法。您写的是类方法，必须将实例作为第一个参数。因此，您必须明确将实例参数放置在某个地方。

Answer 4

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

，

因此，对象的数据绑定到对象。以下是一个人想如何可视化每个对象数据可能看起来的示例。注意 self 如何替换为对象的名称。我并不是说下面的示例图是完全准确的，但是希望它可以帮助一个人可视化 self 的使用。

将对象传递到 self parameter中，以便对象可以保持保持其自己的数据。

尽管这可能不是完全准确的，但请考虑实例化的过程（创建和分配内部值）这样的对象：当制作对象时，对象将类用作其模板（对象的）自己的数据和方法。如果不将对象自己的变量名称传递到 self 参数中，则类中的属性和方法将是一个常规模板，并且不会引用（属于）对象。因此，通过将对象的名称传递到 self 参数中，这意味着，如果从一个类实例化了100个对象，那么100个对象中的每个对象都可以跟踪其（每个对象）自己的数据和方法。

摘要：类是一般的（不是超特定的）模板，一个新创建的对象可以将其自己的特定数据传递到（不一定会影响可以从同一类创建的对象的情况下必然），允许使用较少的复制代码，其目的是创建许多具有相同模式的对象。 self 用于指定A 特定对象的数据应使用而不是其他数据。

请参阅下面的插图：

Answer 5

我喜欢这个示例：

class A: 
    foo = []

a, b = A(), A()
a.foo.append(5)

b.foo  # [5]

class A: 
    def __init__(self): 
        self.foo = []

a, b = A(), A()
a.foo.append(5)

b.foo  # []

Answer 6

我将用代码证明不使用类：

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 )

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

Answer 7

以下摘录来自 python关于self 的文档：

与Modula-3中一样，没有用于从其方法引用对象成员的速记（在Python中）：方法函数是用代表对象的明确的第一个参数声明的，该函数由呼叫。

通常，方法的第一个论点称为自我。这无非是一种惯例：“自我”这个名字绝对没有特殊的意义。但是，请注意，通过不遵循《惯例》，您的代码可能不太对其他Python程序员读取，并且也可以想象，可以编写依赖此类约定的类浏览器程序。

。

有关更多信息，请参见 python文档教程。

Answer 8

除了所有已经说明的其他原因外，它还可以更轻松地访问覆盖方法。您可以调用 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"

Answer 9

它的使用类似于使用此在Java中的关键字，即为当前对象提供引用。

Answer 10

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

首先，方法属于整个类（ static方法）或类（对象方法）的对象（实例）。

在python中调用静态方法时，只需写入其中带有常规参数的方法。

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

但是，需要您制作对象的对象（IE，实例）方法（即在这种情况下是一种动物），需要 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 指的是整个类 的动物名称变量。请记住：如果您在方法中有一个新的变量创建（称为局部变量），则 self 将无法使用。该变量仅在该方法运行时存在。要定义字段（整个类的变量），您必须在类方法之外定义它们。

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

Answer 11

首先，自我是一个传统的名称，您可以将其他任何东西（连贯）代替。

它指的是对象本身，因此，当您使用该对象时，您会声明.NAME和.AGE是您将要创建的学生对象的属性（注意，而不是学生班的）。

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

代码在这里

Answer 12

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

Answer 13

在那里遵循Python Zen“明确胜于隐式”。这确实是对您的班级对象的参考。例如，在Java和PHP中，称为 this 。

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

Answer 14

我很惊讶没有人提出卢阿。 LUA还使用“自我”变量，但是可以省略但仍使用。 C ++对“ this”做同样的事情。我没有任何理由必须在每个功能中声明“自我”，但是您仍然应该能够像使用LUA和C ++一样使用它。对于一种以简短的态度而自豪的语言是奇怪的是，它要求您声明自我变量。

Answer 15

请查看以下示例，该示例清楚地说明了 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中的自我变量a>

Answer 16

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

1 ：使用自我解释

请注意，这不是关键字。

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

2：我们为什么要这样做和这样为什么我们不能像Java这样的参数将其消除，而是具有关键字

我想添加的另一件事是，可选的 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 decorator，否则 self 参数是必不可少的。

Answer 17

是因为根据Python设计的方式，替代方案几乎无效。 python旨在允许在隐式 this （a-la java/c ++）或explicit @（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 fubar 仍然可以将对象称为参数，并且可以使用相同的工作（ IS 与 c.frob 我认为）。

Answer 18

在 __ Init __ 方法中，自我指的是新创建的对象；在其他类方法中，它是指调用方法的实例。

self as hif as 只是惯例 ，请按照自己的意愿称呼它！但是在使用它时，例如要删除对象，您必须使用相同的名称： __ del __（var），其中 var 在 __ init __ Init __（ var，[...]）

您也应该查看 cls ，以使 更大的图片 。此 POST 可能会有所帮助。

Answer 19

自我就像当前对象名称或类的实例一样。

# 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

Answer 20

“ self”关键字包含类的参考，如果您想使用或不使用它，则可以通过它，但如果您注意到，每当您在Python中创建新方法时，Python都会自动为您编写自关键字。如果您做一些R＆amp; d，您会注意到，如果您在班级中创建两个方法并尝试在另一个中调用一个方法，则除非添加自我（班级的引用），否则它将无法识别方法。

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（）已包含自关键字

obj = testA()
obj.m1()

，但是如果您要调用方法m2（），因为没有自我参考，因此您可以使用以下类似的类名来直接调用M2（），

testA.m2()

但要练习以自我关键字来依靠其他好处，因为它还有其他好处，例如在内部创建全局变量等。

Answer 21

self 是不可避免的。

只有一个问题应该 self 是隐式或明确的。
guido van rossum 解决了这个问题：//neopythonic.blogspot.com/2008/10/why-explitic-self-self-has-to-stay.html“ rel =“ nofollow noreferrer”> self 必须保持。

那么， self live的何处？

如果我们只坚持功能编程，我们将不需要 self 。
输入 python oop 后，我们在那里找到 self 。

这是典型的用例类C 与方法 m1

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

So self 保留类实例的内存地址。
self 的目的是保留实例方法的参考参考。

---

_{注意，类方法有三种不同类型：}

• _{静态方法（读：functions），}
• 类方法，
• _{实例方法（提到） 。}

Answer 22

“自我”一词是指班级的实例

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

Answer 23

这是对类实例对象的明确引用。

Answer 24

来自 docs ，，

关于方法的特殊之处在于，实例对象作为函数的第一个参数传递。在我们的示例中，呼叫 xf（）完全等同于 myClass.f（x）。通常，调用带有n个参数列表的方法等同于用参数列表调用相应的函数，该函数是通过在第一个参数之前插入该方法的实例对象创建的。

。

在此之前，相关片段，

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

    def f(self):
        return 'hello world'

x = myClass（）


Answer 25

我在这个班级的人中的小2美分

，我们在这里定义了 init 方法，在这里要注意的是 self 和实例变量的记忆位置 p 是相同的＆lt; __ main __。在0x106a78fd0＆gt; 上的人对象

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() 

，如上所述，self和实例变量都是同一对象。

Answer 26

使用 self 是 Python的设计决定，从语言设计的角度来看，并非严格强制强制强制，以使实例对象明确并区分实例变量与局部变量。您可以想到 self 始终在那里隐含的替代方案，因为Guido的Blogpost回应了：

class MyClass:
    def __init__(n):  # implicit self
        self.n = n  

    def print_n():
        print(self.n)

这违背了Python的咒语“显式比隐含更好”。或使用特殊的语法来参考ruby中的实例变量。但是，Python试图将语法字符保持在最低限度（如今，它正在添加更多语法，例如sistizitment表达式和类型提示）。这在功能上与隐式 self 相同，除非您不将 self 像隐藏的变量一样。

class MyClass:
    def __init__(n):
        @n = n

    def print_n():
        print(@n)

另一个替代方法是C ++样式语法，使用隐式此和明确的类似数据级的声明（相对较新）：

class MyClass:
    n: int

    def __init__(n):
        this.n = n 

    def print_n():
        print(n)  # default to instance variable

此仅用于从实例变量中删除本地变量。如果没有混淆，则使用“类范围” n 。我认为这比在任何地方使用显式 self 更干净，但是您需要跟踪什么和ISN' t实例状态。

Answer 27

我至少要说python，可以将自我参数视为占位符。
看看这一点：

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

p1 = Person("John", 36)

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

在这种情况下，自我，许多其他人被用作说出名称值的方法。但是，在那之后，我们使用P1将其分配给我们使用的类。然后，当我们打印它时，我们使用相同的P1关键字。

希望这对Python有帮助！