เมื่อกำหนดวิธีการในชั้นเรียนใน Python มันมีลักษณะดังนี้:

class MyClass(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

แต่ในบางภาษาอื่น ๆ เช่น C # คุณมีการอ้างอิงถึงวัตถุที่วิธีการที่ถูกผูกไว้กับคำหลัก "นี้" โดยไม่ต้องประกาศว่ามันเป็นข้อโต้แย้งในต้นแบบวิธีการ

นี่เป็นการตัดสินใจออกแบบภาษาโดยเจตนาใน Python หรือมีรายละเอียดการนำไปปฏิบัติบางอย่างที่ต้องใช้การผ่าน "ตนเอง" เป็นอาร์กิวเมนต์หรือไม่?

ฉันชอบเสนอราคา Peters 'Zen of Python "ชัดเจนดีกว่าโดยปริยาย"

ใน Java และ C ++, ' this.' สามารถอนุมานได้ยกเว้นเมื่อคุณมีชื่อตัวแปรที่ทำให้ไม่สามารถอนุมานได้ ดังนั้นบางครั้งคุณต้องการมันและบางครั้งก็ทำไม่ได้

Python เลือกที่จะทำสิ่งนี้อย่างชัดเจนมากกว่ายึดตามกฎ

นอกจากนี้เนื่องจากไม่มีสิ่งใดที่บอกเป็นนัยหรือถือว่าเป็นส่วนหนึ่งของการนำไปปฏิบัติ self.__class__, self.__dict__และโครงสร้างอื่น ๆ "ภายใน" ที่มีอยู่ในทางที่เห็นได้ชัด

เพื่อลดความแตกต่างระหว่างวิธีการและฟังก์ชั่น จะช่วยให้คุณสามารถสร้างวิธีการใน metaclasses หรือเพิ่มวิธีการที่รันไทม์ไปยังคลาสที่มีอยู่ก่อน

เช่น

>>> class C(object):
...     def foo(self):
...         print "Hi!"
...
>>>
>>> def bar(self):
...     print "Bork bork bork!"
...
>>>
>>> c = C()
>>> C.bar = bar
>>> c.bar()
Bork bork bork!
>>> c.foo()
Hi!
>>>

นอกจากนี้ (เท่าที่ฉันรู้) ทำให้การใช้งาน python runtime ง่ายขึ้น

ผมขอแนะนำว่าควรอ่านบล็อกกุยรถตู้ซัมในหัวข้อนี้ - ทำไมตัวเองอย่างชัดเจนมีการเข้าพัก

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

ฉันปฏิเสธแฮ็กเช่นปลอกพิเศษ '@classmethod' และ '@staticmethod'

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

อนุญาตให้คุณทำสิ่งนี้ด้วย: (ในระยะสั้นการเรียกใช้Outer(3).create_inner_class(4)().weird_sum_with_closure_scope(5)จะคืนค่า 12 แต่จะทำในวิธีที่บ้าที่สุด

class Outer(object):
    def __init__(self, outer_num):
        self.outer_num = outer_num

    def create_inner_class(outer_self, inner_arg):
        class Inner(object):
            inner_arg = inner_arg
            def weird_sum_with_closure_scope(inner_self, num)
                return num + outer_self.outer_num + inner_arg
        return Inner

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

ยิ่งไปกว่านั้นลองจินตนาการถึงสิ่งนี้: เราต้องการปรับแต่งพฤติกรรมของวิธีการ (สำหรับการทำโปรไฟล์หรือเวทมนตร์สีดำที่บ้าคลั่ง) สิ่งนี้สามารถทำให้เราคิดได้: ถ้าเรามีคลาสMethodที่มีพฤติกรรมที่เราสามารถแทนที่หรือควบคุมได้?

นี่มันคือ:

from functools import partial

class MagicMethod(object):
    """Does black magic when called"""
    def __get__(self, obj, obj_type):
        # This binds the <other> class instance to the <innocent_self> parameter
        # of the method MagicMethod.invoke
        return partial(self.invoke, obj)


    def invoke(magic_self, innocent_self, *args, **kwargs):
        # do black magic here
        ...
        print magic_self, innocent_self, args, kwargs

class InnocentClass(object):
    magic_method = MagicMethod()

และตอนนี้: InnocentClass().magic_method()จะทำหน้าที่อย่างที่คาดไว้ วิธีการจะถูกผูกไว้กับinnocent_selfพารามิเตอร์ถึงInnocentClassและกับmagic_selfอินสแตนซ์ถึง MagicMethod แปลกเหรอ? มันเหมือนกับมี 2 คำหลักthis1และthis2ในภาษาเช่น Java และ C # เวทย์มนตร์เช่นนี้อนุญาตให้เฟรมเวิร์กทำสิ่งต่าง ๆ ที่จะเป็น verbose มากขึ้น

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

ฉันคิดว่าเหตุผลที่แท้จริงนอกเหนือจาก "The Zen of Python" ก็คือฟังก์ชั่นเป็นพลเมืองชั้นหนึ่งใน Python

ซึ่งทำให้พวกเขาเป็นวัตถุ ตอนนี้ปัญหาพื้นฐานคือถ้าฟังก์ชั่นของคุณเป็นวัตถุในกระบวนทัศน์เชิงวัตถุคุณจะส่งข้อความไปยังวัตถุได้อย่างไรเมื่อข้อความนั้นเป็นวัตถุ

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

นี่หมายความว่าทางออกเดียวที่เป็นไปได้คือการส่ง 'ตัวเอง' อย่างชัดเจน (บริบทของการดำเนินการ)

ดังนั้นฉันเชื่อว่านี่เป็นปัญหาในการติดตั้งที่ Zen มาในภายหลัง

ฉันคิดว่ามันเกี่ยวกับ PEP 227:

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

ตามที่อธิบายไว้ในตนเองใน Python Demystified

ทุกอย่างเช่น obj.meth (args) จะกลายเป็น Class.meth (obj, args) กระบวนการเรียกใช้โดยอัตโนมัติในขณะที่กระบวนการรับไม่ได้ (ชัดเจน) นี่คือเหตุผลที่พารามิเตอร์แรกของฟังก์ชันในคลาสต้องเป็นวัตถุเอง

class Point(object):
    def __init__(self,x = 0,y = 0):
        self.x = x
        self.y = y

    def distance(self):
        """Find distance from origin"""
        return (self.x**2 + self.y**2) ** 0.5

สวด:

>>> p1 = Point(6,8)
>>> p1.distance()
10.0

init () กำหนดสามพารามิเตอร์ แต่เราเพิ่งผ่านสอง (6 และ 8) ระยะทางในทำนองเดียวกัน () ต้องการหนึ่งอาร์กิวเมนต์ แต่ผ่านศูนย์แล้ว

ทำไมไพ ธ อนไม่บ่นเกี่ยวกับหมายเลขอาร์กิวเมนต์นี้ไม่ตรงกัน ?

โดยทั่วไปเมื่อเราเรียกเมธอดที่มีอาร์กิวเมนต์บางตัวฟังก์ชันคลาสที่สอดคล้องกันจะถูกเรียกใช้โดยการวางวัตถุของเมธอดก่อนอาร์กิวเมนต์แรก ดังนั้นทุกอย่างเช่น obj.meth (args) จะกลายเป็น Class.meth (obj, args) กระบวนการเรียกใช้โดยอัตโนมัติในขณะที่กระบวนการรับไม่ได้ (ชัดเจน)

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

ตนเองอยู่ที่นี่อยู่

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

นอกจากนี้ยังมีคำตอบที่ง่ายมากอีกด้วยอ้างอิงจากzen of pythonว่า "ชัดแจ้งดีกว่าดีกว่า"