Python มีตัวแปร "ส่วนตัว" ในชั้นเรียนหรือไม่?

ฉันมาจากโลก Java และการอ่านบรูซ Eckels' งูใหญ่ 3 รูปแบบสูตรและสำนวน

ในขณะที่อ่านเกี่ยวกับคลาสมันจะบอกว่าใน Python ไม่จำเป็นต้องประกาศตัวแปรอินสแตนซ์ คุณเพียงแค่ใช้พวกมันในตัวสร้างและบูมพวกมันอยู่ที่นั่น

ตัวอย่างเช่น:

class Simple:
    def __init__(self, s):
        print("inside the simple constructor")
        self.s = s

    def show(self):
        print(self.s)

    def showMsg(self, msg):
        print(msg + ':', self.show())

หากเป็นจริงวัตถุของคลาสใด ๆ ก็Simpleสามารถเปลี่ยนค่าของตัวแปรsนอกคลาสได้

ตัวอย่างเช่น:

if __name__ == "__main__":
    x = Simple("constructor argument")
    x.s = "test15" # this changes the value
    x.show()
    x.showMsg("A message")

ใน Java เราได้รับการสอนเกี่ยวกับตัวแปรสาธารณะ / ส่วนตัว / ที่มีการป้องกัน คำหลักเหล่านั้นสมเหตุสมผลเพราะในบางครั้งคุณต้องการตัวแปรในคลาสที่ไม่มีใครอยู่นอกชั้นเรียนสามารถเข้าถึงได้

เหตุใดจึงไม่จำเป็นใน Python

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

หากคุณต้องการที่จะเลียนแบบตัวแปรส่วนตัวด้วยเหตุผลบางอย่างคุณก็สามารถใช้__คำนำหน้าจากPEP 8 Python รวบรวมชื่อของตัวแปรเช่น__fooนั้นไว้เพื่อไม่ให้สามารถมองเห็นโค้ดภายนอกคลาสที่มีตัวแปรเหล่านั้นได้อย่างง่ายดาย (แม้ว่าคุณจะสามารถหลีกเลี่ยงได้ถ้าคุณตั้งใจมากพอเช่นเดียวกับที่คุณสามารถป้องกัน Java ได้หากคุณทำงาน )

ในการประชุมเดียวกัน_คำนำหน้าหมายถึงอยู่ห่าง ๆ แม้ว่าคุณจะไม่ได้รับการป้องกันในทางเทคนิคก็ตาม คุณไม่ได้เล่นรอบกับตัวแปรของชั้นอื่นที่มีลักษณะเหมือนหรือ__foo_bar

ตัวแปรส่วนตัวในไพ ธ อนมีการแฮ็กมากขึ้นหรือน้อยลงล่ามจะทำการเปลี่ยนชื่อตัวแปรโดยเจตนา

class A:
    def __init__(self):
        self.__var = 123
    def printVar(self):
        print self.__var

ตอนนี้ถ้าคุณพยายามเข้าถึง__varนอกคำจำกัดความของคลาสมันจะล้มเหลว:

 >>>x = A()
 >>>x.__var # this will return error: "A has no attribute __var"

 >>>x.printVar() # this gives back 123

แต่คุณสามารถหลีกเลี่ยงสิ่งนี้ได้โดยง่าย:

 >>>x.__dict__ # this will show everything that is contained in object x
               # which in this case is something like {'_A__var' : 123}

 >>>x._A__var = 456 # you now know the masked name of private variables
 >>>x.printVar() # this gives back 456

คุณอาจรู้ว่ามีการเรียกใช้เมธอดใน OOP เช่นนี้: x.printVar() => A.printVar(x)หากA.printVar()สามารถเข้าถึงบางฟิลด์ในได้xฟิลด์นี้สามารถเข้าถึงได้นอก A.printVar() ... หลังจากทั้งหมดฟังก์ชั่นถูกสร้างขึ้นเพื่อนำมาใช้ซ้ำได้ไม่มีอำนาจพิเศษใด ๆ

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

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

มีตัวแปรส่วนบุคคลในการประชุมที่ขีดล่าง

In [5]: class Test(object):
   ...:     def __private_method(self):
   ...:         return "Boo"
   ...:     def public_method(self):
   ...:         return self.__private_method()
   ...:     

In [6]: x = Test()

In [7]: x.public_method()
Out[7]: 'Boo'

In [8]: x.__private_method()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-8-fa17ce05d8bc> in <module>()
----> 1 x.__private_method()

AttributeError: 'Test' object has no attribute '__private_method'

มีความแตกต่างเล็กน้อย แต่เพื่อความบริสุทธิ์ของรูปแบบการเขียนโปรแกรมอุดมการณ์ดีพอ

มีตัวอย่างจากผู้ตกแต่งส่วนบุคคลที่ @private ซึ่งใช้แนวคิดนี้อย่างใกล้ชิดมากกว่า แต่เป็น YMMV เนื้อหาที่เราสามารถเขียนคลาส defintion ที่ใช้เมตา

"ใน java เราได้รับการสอนเกี่ยวกับตัวแปรสาธารณะ / ส่วนตัว / ที่มีการป้องกัน"

"ทำไมถึงไม่จำเป็นในงูใหญ่"

ด้วยเหตุผลเดียวกันมันไม่จำเป็นใน Java

คุณมีอิสระในการใช้งาน - หรือไม่ใช้และprivateprotected

ในฐานะที่เป็นโปรแกรมเมอร์ Python และ Java ฉันพบว่าprivateและprotectedเป็นแนวคิดการออกแบบที่สำคัญมาก แต่เป็นเรื่องจริงในนับหมื่นของเส้นของ Java และ Python ฉันไม่เคยจริงใช้หรือprivateprotected

ทำไมจะไม่ล่ะ?

นี่คือคำถามของฉัน "ป้องกันจากใคร"

โปรแกรมเมอร์คนอื่นในทีมของฉัน? พวกเขามีแหล่งที่มา การป้องกันหมายถึงอะไรเมื่อพวกเขาสามารถเปลี่ยนแปลงได้

โปรแกรมเมอร์คนอื่นในทีมอื่น ๆ ? พวกเขาทำงานให้กับ บริษัท เดียวกัน พวกเขาสามารถ - ด้วยการโทรศัพท์ - รับแหล่งที่มา

ลูกค้าได้อย่างไร มันเป็นโปรแกรมการจ้างงาน (โดยทั่วไป) ลูกค้า (โดยทั่วไป) เป็นเจ้าของรหัส

ดังนั้นฉันจะปกป้องใครจากใคร

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

class Foo:

    def __init__(self, bar):
        self._bar = bar

    @property
    def bar(self):
        """Getter for '_bar'."""
        return self._bar

วิธีนี้บางคนหรือบางสิ่งที่อ้างอิงbarเป็นการอ้างอิงค่าส่งคืนของbarฟังก์ชันแทนที่จะเป็นตัวแปรเองดังนั้นจึงสามารถเข้าถึงได้ แต่ไม่สามารถเปลี่ยนแปลงได้ อย่างไรก็ตามถ้ามีคนต้องการจริงๆพวกเขาสามารถใช้_barและกำหนดค่าใหม่ให้กับมัน ไม่มีวิธีที่แน่นอนในการป้องกันบุคคลจากการเข้าถึงตัวแปรและวิธีการที่คุณต้องการซ่อนตามที่ได้รับการพูดซ้ำ ๆ อย่างไรก็ตามการใช้propertyเป็นข้อความที่ชัดเจนที่สุดที่คุณสามารถส่งได้ว่าไม่ควรแก้ไขตัวแปร propertyนอกจากนี้ยังสามารถใช้สำหรับเส้นทางเข้าถึง getter / setter / deleter ที่ซับซ้อนมากขึ้นดังที่อธิบายไว้ที่นี่: https://docs.python.org/3/library/functions.html#property

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

ดูที่นี่สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนั้น

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

เวลาเดียวที่ฉันเคยใช้ตัวแปรส่วนตัวคือเมื่อฉันต้องทำสิ่งอื่นเมื่อเขียนหรืออ่านจากตัวแปรและดังนั้นฉันจึงจำเป็นต้องบังคับให้ใช้ setter และ / หรือทะเยอทะยาน

อีกครั้งนี้ไปสู่วัฒนธรรมตามที่ระบุไว้แล้ว ฉันทำงานเกี่ยวกับโปรเจ็กต์ที่การอ่านและการเขียนตัวแปรคลาสอื่น ๆ นั้นฟรีสำหรับทุกคน เมื่อการติดตั้งครั้งเดียวเลิกใช้งานมันใช้เวลานานกว่านั้นในการระบุพา ธ โค้ดทั้งหมดที่ใช้ฟังก์ชันนั้น เมื่อมีการบังคับใช้ setters และ getters สามารถแก้ไขคำสั่ง debug ได้อย่างง่ายดายเพื่อระบุว่ามีการเรียกใช้เมธอดที่เลิกใช้แล้วและโค้ดพา ธ ที่เรียกใช้

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

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

ขออภัยพวกที่ "คืนชีพ" เธรด แต่ฉันหวังว่าสิ่งนี้จะช่วยให้ใครบางคน:

ใน Python3 หากคุณเพียงแค่ต้องการ "ห่อหุ้ม" คุณสมบัติคลาสเช่นใน Java คุณสามารถทำสิ่งเดียวกันนี้:

class Simple:
    def __init__(self, str):
        print("inside the simple constructor")
        self.__s = str

    def show(self):
        print(self.__s)

    def showMsg(self, msg):
        print(msg + ':', self.show())

ในการสร้างอินสแตนซ์ให้ทำ:

ss = Simple("lol")
ss.show()

โปรดทราบว่า: print(ss.__s)จะโยนข้อผิดพลาด

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

แต่อย่ากลัวเลย มันไม่สำคัญ มันทำงานได้ดีเช่นกัน ;)

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

นอกจากนี้คุณสามารถสังเกตเห็นว่าแนวคิดของงูหลาม OOP นั้นไม่สมบูรณ์แบบไม่ว่าจะเป็น smolalk หรือ ruby ​​ที่ใกล้เคียงกับแนวคิด OOP บริสุทธิ์มาก แม้แต่ C # หรือ Java ก็ยังเข้าใกล้

Python เป็นเครื่องมือที่ดีมาก แต่มันเป็นภาษา OOP แบบง่าย ๆ ลดความซับซ้อนของ Syntactically และ conceptually เป้าหมายหลักของการมีอยู่ของไพ ธ อนคือการนำความเป็นไปได้ของนักพัฒนาในการเขียนโค้ดที่อ่านง่ายและมีระดับนามธรรมสูงอย่างรวดเร็ว

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

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

เครื่องหมายขีดล่างคู่ "__" ไม่ได้หมายความว่า "ตัวแปรส่วนตัว" คุณใช้มันเพื่อกำหนดตัวแปรที่เป็น "class local" และไม่สามารถถูกแทนที่ได้อย่างง่ายดายโดยคลาสย่อย มัน mangles ชื่อตัวแปร

ตัวอย่างเช่น:

class A(object):
    def __init__(self):
        self.__foobar = None # will be automatically mangled to self._A__foobar

class B(A):
    def __init__(self):
        self.__foobar = 1 # will be automatically mangled to self._B__foobar

ชื่อตัวเองของ. foobar จะถูกทำให้เป็นตัวเองโดยอัตโนมัติ _A__foobar ในคลาส A ในคลาส B นั้นจะมีการจัดการกับตัวเอง _B__foobar ดังนั้นทุกคลาสย่อยสามารถกำหนดตัวแปร __foobar ของตัวเองโดยไม่ต้องแทนที่ตัวแปรพาเรนต์ แต่ไม่มีอะไรป้องกันคุณจากการเข้าถึงตัวแปรที่ขึ้นต้นด้วยเครื่องหมายขีดล่างคู่ อย่างไรก็ตามชื่อ -mangling ป้องกันคุณจากการเรียกตัวแปร / วิธีนี้โดยบังเอิญ

ฉันขอแนะนำอย่างยิ่งให้ดู Raymond Hettingers พูดคุย "Pythons class development tool" จาก Pycon 2013 (ควรมีใน Youtube) ซึ่งเป็นตัวอย่างที่ดีว่าทำไมและวิธีที่คุณควรใช้ @property และ "__" - ตัวแปรอินสแตนซ์

จริงๆแล้วคุณสามารถจำลองผู้C#ทะเยอทะยานและผู้ตั้งค่าโดยใช้เคล็ดลับง่ายๆนี้

class Screen(object):

    def getter_setter_y(self, y, get=True):
        if get is True:
            Screen.getter_setter_y.value = y
        else:
            return Screen.getter_setter_y.value

     def getter_setter_x(self, x, get=True):
         if get is True:
             Screen.getter_setter_x.value = x
         else:
             return Screen.getter_setter_x.value

จากนั้นใช้เหมือนในC#:

scr = Screen()
scr.getter_setter_x(100)
value =  scr.getter_setter_x(0, get=False)
print (value)

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