จุดประสงค์ของคำว่า 'ตัวเอง' คืออะไร?

วัตถุประสงค์ของselfคำใน Python คืออะไร? ฉันเข้าใจว่ามันหมายถึงวัตถุเฉพาะที่สร้างขึ้นจากคลาสนั้น แต่ฉันไม่สามารถดูได้ว่าทำไมจึงต้องเพิ่มอย่างชัดเจนในทุกฟังก์ชั่นเป็นพารามิเตอร์ เพื่อแสดงใน Ruby ฉันสามารถทำสิ่งนี้:

class myClass
    def myFunc(name)
        @name = name
    end
end

ซึ่งฉันเข้าใจค่อนข้างง่าย อย่างไรก็ตามใน Python ฉันต้องรวมself:

class myClass:
    def myFunc(self, name):
        self.name = name

ทุกคนสามารถพูดคุยกับฉันผ่านสิ่งนี้ได้ไหม? มันไม่ใช่สิ่งที่ฉันได้เจอในประสบการณ์ของฉัน

เหตุผลที่คุณต้องใช้self.คือเพราะ Python ไม่ได้ใช้@ไวยากรณ์เพื่ออ้างถึงคุณลักษณะของอินสแตนซ์ Python ตัดสินใจที่จะทำวิธีการในวิธีที่ทำให้อินสแตนซ์ซึ่งเป็นของวิธีการที่ถูกส่งโดยอัตโนมัติ แต่ไม่ได้รับโดยอัตโนมัติ: พารามิเตอร์แรกของวิธีการเป็นตัวอย่างที่วิธีการที่เรียกว่า นั่นทำให้วิธีการทั้งหมดเหมือนกับฟังก์ชั่นและปล่อยให้ชื่อจริงใช้กับคุณ (แม้ว่าจะselfเป็นแบบแผนและคนทั่วไปจะขมวดคิ้วคุณเมื่อคุณใช้อย่างอื่น) selfไม่ใช่รหัสพิเศษมันเป็นเพียงวัตถุอื่น .

Python อาจทำอย่างอื่นเพื่อแยกความแตกต่างชื่อปกติจากแอตทริบิวต์ - ไวยากรณ์พิเศษอย่าง Ruby มีหรือต้องการการประกาศเช่น C ++ และ Java ทำหรืออาจจะเป็นสิ่งที่แตกต่างกันมากขึ้น แต่ก็ไม่ได้ Python ทั้งหมดสำหรับการทำสิ่งที่ชัดเจนทำให้มันชัดเจนว่าอะไรคืออะไรและแม้ว่ามันจะไม่ได้ทำทุกที่ แต่มันก็ทำเพื่อคุณสมบัติเช่นกัน 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)

ดังนั้นโครงสร้างทั้งหมดยังคงเหมือนเดิม ฉันจะใช้สิ่งนี้ได้อย่างไร หากเราสันนิษฐานว่าสักครู่ที่เราไม่ได้เขียนlengthวิธีสำหรับVectorชั้นเรียนของเราเราสามารถทำสิ่งนี้ได้:

Vector.length_new = length_global
v = Vector(3, 4)
print(v.length_new()) # 5.0

งานนี้เพราะพารามิเตอร์แรกของlength_globalสามารถนำมาใช้เป็นพารามิเตอร์ในself นี้จะไม่เป็นไปได้โดยชัดเจนlength_newself

อีกวิธีในการทำความเข้าใจความต้องการที่ชัดเจนselfก็คือการดูว่า Python เติมน้ำตาลในประโยคไว้ที่ใด เมื่อคุณจำไว้ว่าโดยทั่วไปแล้วการโทรเช่น

v_instance.length()

ถูกแปลงภายในเป็น

Vector.length(v_instance)

มันง่ายที่จะดูว่าselfพอดีที่ไหนคุณไม่ได้เขียนวิธีการเช่นใน Python; สิ่งที่คุณเขียนคือวิธีการเรียนซึ่งจะต้องใช้อินสแตนซ์เป็นพารามิเตอร์แรก ดังนั้นคุณจะต้องวางพารามิเตอร์อินสแตนซ์ที่ใดที่หนึ่งอย่างชัดเจน

สมมติว่าคุณมีคลาสClassAที่มีวิธีการที่methodAกำหนดเป็น:

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

และObjectAเป็นตัวอย่างของชั้นนี้

ตอนนี้เมื่อObjectA.methodA(arg1, arg2)ถูกเรียกใช้ python จะแปลงภายในให้คุณเป็น:

ClassA.methodA(ObjectA, arg1, arg2)

selfตัวแปรหมายถึงวัตถุเอง

เมื่อวัตถุถูกยกตัวอย่างวัตถุจะถูกส่งไปยังพารามิเตอร์ของตนเอง

ด้วยเหตุนี้ข้อมูลของวัตถุที่ถูกผูกไว้กับวัตถุ ด้านล่างเป็นตัวอย่างของวิธีที่คุณอาจต้องการเห็นภาพข้อมูลของวัตถุแต่ละชิ้นที่อาจมีลักษณะอย่างไร แจ้งให้ทราบว่า 'ตัวเอง' ถูกแทนที่ด้วยชื่อวัตถุ ฉันไม่ได้พูดถึงแผนภาพตัวอย่างด้านล่างนี้ว่าถูกต้องทั้งหมด แต่หวังว่าจะมีจุดประสงค์ในการแสดงภาพการใช้งานของตัวเอง

Object ถูกส่งไปยังพารามิเตอร์ของตัวเองเพื่อให้วัตถุสามารถเก็บข้อมูลของตัวเองไว้ได้

แม้ว่าสิ่งนี้อาจไม่ถูกต้องทั้งหมด แต่ให้คิดว่ากระบวนการของการสร้างอินสแตนซ์ของวัตถุเช่นนี้: เมื่อวัตถุถูกทำให้ใช้คลาสเป็นแม่แบบสำหรับข้อมูลและวิธีการของตัวเอง โดยไม่ต้องผ่านชื่อของตัวเองลงในพารามิเตอร์ตัวเองคุณสมบัติและวิธีการในชั้นเรียนจะยังคงเป็นแม่แบบทั่วไปและจะไม่ถูกอ้างถึงวัตถุ (เป็นของ) ดังนั้นโดยการส่งชื่อของวัตถุไปยังพารามิเตอร์ของตัวเองนั่นหมายความว่าหากวัตถุ 100 ชิ้นถูกยกตัวอย่างจากคลาสหนึ่งพวกเขาสามารถติดตามข้อมูลและวิธีการของตัวเองได้

ดูภาพประกอบด้านล่าง:

ฉันชอบตัวอย่างนี้:

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'

คลาสเป็นเพียงวิธีหนึ่งในการหลีกเลี่ยงการส่งผ่านสิ่ง "สถานะ" นี้ตลอดเวลา (และสิ่งที่ดีอื่น ๆ เช่นการเริ่มต้นองค์ประกอบของคลาส metaclasses ที่ไม่ค่อยต้องการและสนับสนุนวิธีการที่กำหนดเองเพื่อแทนที่โอเปอเรเตอร์)

ตอนนี้เรามาสาธิตโค้ดข้างต้นโดยใช้เครื่องจักรระดับไพ ธ อนในตัวเพื่อแสดงให้เห็นว่ามันเหมือนกัน

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 เกี่ยวกับตนเอง :

ใน Modula-3 ไม่มีการจดชวเลข [ใน Python] สำหรับการอ้างอิงสมาชิกของออบเจ็กต์จากวิธีการ: ฟังก์ชันเมธอดถูกประกาศด้วยอาร์กิวเมนต์แรกที่ชัดเจนที่แสดงถึงออบเจกต์ซึ่งมีการเรียกโดยปริยาย

บ่อยครั้งที่อาร์กิวเมนต์แรกของวิธีการนั้นเรียกว่าตัวเอง นี่คืออะไรมากกว่าแบบแผน: ชื่อตัวเองไม่มีความหมายพิเศษกับ Python อย่างไรก็ตามโปรดทราบว่าหากไม่ปฏิบัติตามอนุสัญญารหัสของคุณอาจอ่านได้ง่ายกว่าโปรแกรมเมอร์ Python รายอื่นและเป็นไปได้ว่าโปรแกรมคลาสเบราว์เซอร์อาจถูกเขียนขึ้นโดยอาศัยการประชุมดังกล่าว

สำหรับข้อมูลเพิ่มเติมโปรดดูที่การกวดวิชาเอกสารหลามในชั้นเรียน

เช่นเดียวกับเหตุผลอื่น ๆ ทั้งหมดที่ระบุไว้แล้วจะช่วยให้เข้าถึงวิธีการแทนที่ได้ง่ายขึ้น 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"

การใช้งานจะคล้ายกับการใช้thisคำหลักใน Java คือการอ้างอิงถึงวัตถุปัจจุบัน

Python ไม่ใช่ภาษาที่สร้างขึ้นสำหรับการเขียนโปรแกรมเชิงวัตถุซึ่งแตกต่างจาก Java หรือ C ++

เมื่อเรียกใช้เมธอดสแตติกใน Python เพียงแค่เขียนเมธอดที่มีอาร์กิวเมนต์ปกติอยู่ภายใน

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

อย่างไรก็ตามวิธีการวัตถุที่คุณต้องสร้างตัวแปรซึ่งเป็นสัตว์ในกรณีนี้ต้องมีการโต้แย้งตัวเอง

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

วิธีการตนเองยังใช้เพื่ออ้างถึงเขตข้อมูลตัวแปรภายในชั้นเรียน

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


    def getAnimalName(self):
        return self.animalName

ในกรณีนี้ตนเองอ้างถึงตัวแปร animalName ของคลาสทั้งหมด โปรดจำไว้ว่า: หากคุณมีตัวแปรภายในเมธอดหนึ่งตัวจะไม่ทำงาน ตัวแปรนั้นมีอยู่เพียงในขณะที่วิธีนั้นกำลังทำงานอยู่ สำหรับการกำหนดเขตข้อมูล (ตัวแปรของคลาสทั้งหมด) คุณจะต้องกำหนดนอกคลาสของเมธอด

หากคุณไม่เข้าใจคำเดียวที่ฉันกำลังพูด Google ก็คือ "การเขียนโปรแกรมเชิงวัตถุ" เมื่อคุณเข้าใจสิ่งนี้คุณไม่จำเป็นต้องถามคำถาม :)

มันอยู่ที่นั่นเพื่อติดตาม Python Zen“ ชัดเจนดีกว่านัย” มันเป็นการอ้างอิงถึงคลาสวัตถุของคุณ ใน Java และ PHP, thisตัวอย่างเช่นมันเรียกว่า

ถ้าเป็นเขตในรูปแบบของคุณคุณสามารถเข้าถึงได้โดยuser_type_nameself.user_type_name

ประการแรกตัวเองเป็นชื่อธรรมดาคุณสามารถใส่อะไรก็ได้ลงไปแทน

มันหมายถึงวัตถุเองดังนั้นเมื่อคุณใช้มันคุณจะประกาศว่า. 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

รหัสอยู่ที่นี่

selfเป็นการอ้างอิงวัตถุไปยังวัตถุนั้นเองพวกมันเหมือนกัน Python ไม่ได้เรียกวิธีการในบริบทของวัตถุเอง selfใน Python อาจใช้เพื่อจัดการกับโมเดลวัตถุที่กำหนดเองหรือบางสิ่ง

การใช้อาร์กิวเมนต์ที่เรียกว่าตามอัตภาพselfนั้นไม่ยากที่จะเข้าใจเช่นเดียวกับทำไมมันถึงจำเป็น? หรือว่าทำไมพูดถึงอย่างชัดเจน? ฉันคิดว่าเป็นคำถามที่ใหญ่กว่าสำหรับผู้ใช้ส่วนใหญ่ที่ค้นหาคำถามนี้หรือหากไม่ใช่พวกเขาจะมีคำถามเดียวกันกับที่พวกเขาเรียนรู้ภาษาไพ ธ อน ฉันแนะนำให้อ่านบล็อกเหล่านี้:

1: อธิบายการใช้ตนเอง

โปรดทราบว่ามันไม่ใช่คำหลัก

อาร์กิวเมนต์แรกของวิธีการเรียนทุกครั้งรวมถึง init จะอ้างอิงถึงอินสแตนซ์ปัจจุบันของคลาสเสมอ ตามแบบแผนข้อโต้แย้งนี้จะตั้งชื่อตัวเองเสมอ ในวิธีการเริ่มต้นตนเองอ้างถึงวัตถุที่สร้างขึ้นใหม่ ในวิธีการเรียนอื่น ๆ มันหมายถึงอินสแตนซ์ที่มีวิธีการที่ถูกเรียก ตัวอย่างรหัสด้านล่างเหมือนกับรหัสด้านบน

2: ทำไมเรามีวิธีนี้และทำไมเราไม่สามารถกำจัดมันเป็นอาร์กิวเมนต์เช่น Java และมีคำหลักแทน

สิ่งที่ผมอยากจะเพิ่มก็คือตัวเลือกอาร์กิวเมนต์ช่วยให้ผมที่จะประกาศวิธีการคงอยู่ภายในชั้นเรียนโดยไม่ได้เขียนselfself

ตัวอย่างรหัส:

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นั้นข้อโต้แย้งจะเป็นหน้าที่

ฉันแปลกใจที่ไม่มีใครเลี้ยง Lua ขึ้นมาได้ Lua ใช้ตัวแปร 'ตัวเอง' แต่สามารถละเว้นได้ แต่ยังคงใช้อยู่ C ++ ทำเช่นเดียวกันกับ 'this' ฉันไม่เห็นเหตุผลใด ๆ ที่จะต้องประกาศ 'ตนเอง' ในแต่ละฟังก์ชั่น แต่คุณควรจะสามารถใช้มันได้เช่นเดียวกับ lua และ C ++ สำหรับภาษาที่ภูมิใจในการสรุปก็แปลกที่คุณจะต้องประกาศตัวแปรตนเอง

ลองดูตัวอย่างต่อไปนี้ซึ่งอธิบายถึงวัตถุประสงค์ของ 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 ใช้ / จำเป็นเพื่อแยกแยะระหว่างอินสแตนซ์

ที่มา: อธิบายตัวแปรตัวเองในไพ ธ อน - Pythontips

เป็นเพราะวิธีการที่หลามได้รับการออกแบบทางเลือกจะไม่ทำงาน Python ถูกออกแบบมาเพื่ออนุญาตให้มีการกำหนดวิธีการหรือฟังก์ชั่นในบริบทที่ทั้งนัยthis(a-la Java / C ++) หรือชัดแจ้ง@(a-la ruby) ไม่ทำงาน ลองมาตัวอย่างกับแนวทางชัดเจนกับอนุสัญญาหลาม:

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__วิธีการตัวเองหมายถึงวัตถุที่สร้างขึ้นใหม่ ในวิธีการเรียนอื่น ๆ มันหมายถึงอินสแตนซ์ที่มีวิธีการที่ถูกเรียก

ตัวเองเป็นชื่อเป็นเพียงการประชุมเรียกมันว่าคุณต้องการ! แต่เมื่อใช้มันตัวอย่างเช่นในการลบวัตถุคุณจะต้องใช้ชื่อเดียวกัน: __del__(var)ซึ่งvarถูกใช้ใน__init__(var,[...])

คุณควรดูclsด้วยเพื่อให้ได้ภาพที่ใหญ่ขึ้น โพสต์นี้อาจมีประโยชน์

ตนเองทำตัวเหมือนชื่อวัตถุปัจจุบันหรืออินสแตนซ์ของคลาส

# 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 คงหนีไม่พ้น

มีเพียงคำถามที่ควรselfจะเป็นนัยหรือชัดเจน Guido van Rossumการแก้ไขคำกล่าวที่ว่าคำถามนี้มีการเข้าพักself

ดังนั้นselfอยู่ที่ไหน

selfถ้าเราก็จะยึดติดอยู่กับโปรแกรมการทำงานเราจะไม่จำเป็นต้อง เมื่อเราเข้าสู่Python OOPเราจะพบว่าselfมี

นี่คือกรณีการใช้งานทั่วไปclass 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

ดังนั้นselfเก็บที่อยู่หน่วยความจำของอินสแตนซ์ของคลาส วัตถุประสงค์ของselfการจัดเก็บการอ้างอิงสำหรับวิธีการอินสแตนซ์และเพื่อให้เราสามารถเข้าถึงการอ้างอิงนั้น ได้อย่างชัดเจน

_{หมายเหตุมีวิธีการเรียนสามประเภท:}

• _{วิธีการคงที่ (อ่าน: ฟังก์ชั่น)}
• _{วิธีการเรียน}
• _{วิธีการอินสแตนซ์ (กล่าวถึง)}

จากเอกสาร ,

สิ่งพิเศษเกี่ยวกับวิธีการคือวัตถุตัวอย่างจะถูกส่งผ่านเป็นอาร์กิวเมนต์แรกของฟังก์ชั่น ในตัวอย่างของเราโทรเป็นว่าเทียบเท่ากับx.f() MyClass.f(x)โดยทั่วไปการเรียกเมธอดที่มีรายการอาร์กิวเมนต์ n เท่ากับการเรียกฟังก์ชันที่สอดคล้องกับรายการอาร์กิวเมนต์ที่สร้างขึ้นโดยการแทรกวัตถุอินสแตนซ์ของเมธอดก่อนอาร์กิวเมนต์แรก

ก่อนหน้านี้ตัวอย่างที่เกี่ยวข้อง

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

    def f(self):
        return 'hello world'

x = MyClass()

เป็นการอ้างอิงที่ชัดเจนถึงวัตถุอินสแตนซ์ของคลาส