ทำไมวิธีการแบบส่วนตัวของ Python จึงไม่เป็นแบบส่วนตัว

Python ช่วยให้เราสามารถสร้างวิธีการและตัวแปร 'ส่วนตัว' ภายในชั้นเรียนโดยการใส่เครื่องหมายขีดล่างคู่กับชื่อดังนี้: __myPrivateMethod(). แล้วจะอธิบายได้อย่างไร

>>> class MyClass:
...     def myPublicMethod(self):
...             print 'public method'
...     def __myPrivateMethod(self):
...             print 'this is private!!'
... 
>>> obj = MyClass()
>>> obj.myPublicMethod()
public method
>>> obj.__myPrivateMethod()
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: MyClass instance has no attribute '__myPrivateMethod'
>>> dir(obj)
['_MyClass__myPrivateMethod', '__doc__', '__module__', 'myPublicMethod']
>>> obj._MyClass__myPrivateMethod()
this is private!!

ตกลงคืออะไร!

ฉันจะอธิบายเรื่องนี้เล็กน้อยสำหรับผู้ที่ไม่ค่อยเข้าใจ

>>> class MyClass:
...     def myPublicMethod(self):
...             print 'public method'
...     def __myPrivateMethod(self):
...             print 'this is private!!'
... 
>>> obj = MyClass()

สิ่งที่ฉันทำคือสร้างชั้นเรียนด้วยวิธีสาธารณะและวิธีส่วนตัวและยกตัวอย่าง

ต่อไปฉันเรียกวิธีการสาธารณะ

>>> obj.myPublicMethod()
public method

ต่อไปฉันลองและเรียกวิธีการส่วนตัว

>>> obj.__myPrivateMethod()
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: MyClass instance has no attribute '__myPrivateMethod'

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

>>> dir(obj)
['_MyClass__myPrivateMethod', '__doc__', '__module__', 'myPublicMethod']

ชื่อเมธอดใหม่นี้จะเป็นขีดล่างเสมอตามด้วยชื่อคลาสตามด้วยชื่อเมธอด

>>> obj._MyClass__myPrivateMethod()
this is private!!

มากสำหรับการห่อหุ้มใช่มั้ย

ไม่ว่าในกรณีใดฉันมักจะได้ยินว่า Python ไม่รองรับการห่อหุ้มดังนั้นทำไมถึงต้องลอง สิ่งที่ช่วยให้?

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

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

>>> class Foo(object):
...     def __init__(self):
...         self.__baz = 42
...     def foo(self):
...         print self.__baz
...     
>>> class Bar(Foo):
...     def __init__(self):
...         super(Bar, self).__init__()
...         self.__baz = 21
...     def bar(self):
...         print self.__baz
...
>>> x = Bar()
>>> x.foo()
42
>>> x.bar()
21
>>> print x.__dict__
{'_Bar__baz': 21, '_Foo__baz': 42}

แน่นอนว่ามันจะพังถ้าสองคลาสที่ต่างกันมีชื่อเหมือนกัน

ตัวอย่างของฟังก์ชั่นส่วนตัว

import re
import inspect

class MyClass :

    def __init__(self) :
        pass

    def private_function ( self ) :
        try :
            function_call = inspect.stack()[1][4][0].strip()

            # See if the function_call has "self." in the begining
            matched = re.match( '^self\.', function_call )
            if not matched :
                print 'This is Private Function, Go Away'
                return
        except :
            print 'This is Private Function, Go Away'
            return

        # This is the real Function, only accessible inside class #
        print 'Hey, Welcome in to function'

    def public_function ( self ) :
        # i can call private function from inside the class
        self.private_function()

### End ###

ครั้งแรกที่ฉันมาจาก Java ถึง Python ฉันเกลียดสิ่งนี้ มันทำให้ฉันกลัวจนตาย

วันนี้มันอาจเป็นสิ่งเดียวที่ฉันชอบมากที่สุดเกี่ยวกับ Python

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

โปรดจำไว้ว่าการห่อหุ้มไม่ได้เกี่ยวข้องกับ "ความปลอดภัย" อย่างอ่อนแรงหรือทำให้เด็ก ๆ ออกจากสนามหญ้า มันเป็นเพียงรูปแบบอื่นที่ควรใช้เพื่อทำให้เข้าใจรหัสฐานได้ง่ายขึ้น

จากhttp://www.faqs.org/docs/diveintopython/fileinfo_private.html

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

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

หากคุณต้องมีสิ่งที่เป็นส่วนตัวคุณสามารถนำไปใช้ในส่วนขยาย (เช่นใน C สำหรับ CPython) อย่างไรก็ตามในกรณีส่วนใหญ่คุณเพียงแค่เรียนรู้วิธีการทำสิ่งต่าง ๆ ของ Pythonic

ไม่ใช่ว่าคุณไม่สามารถเข้าถึงความเป็นส่วนตัวของสมาชิกในภาษาใด ๆ ได้อย่างแน่นอน (ตัวชี้เลขใน C ++, Reflections in .NET / Java)

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

แก้ไข: คุณไม่พยายามรักษาความปลอดภัยข้อมูลของคุณโดย OO-encapsulation ใช่ไหม?

class.__stuffตั้งชื่อการประชุมช่วยให้โปรแกรมเมอร์ที่รู้ว่าเขาไม่ได้หมายถึงการเข้าถึง__stuffจากภายนอก ชื่อ mangling ทำให้ไม่น่าที่ใครจะทำโดยบังเอิญ

จริงอยู่ที่คุณยังสามารถแก้ไขได้มันง่ายกว่าในภาษาอื่น ๆ (ซึ่ง BTW อนุญาตให้คุณทำเช่นนี้) แต่ไม่มีโปรแกรม Python ที่จะทำสิ่งนี้ถ้าเขาสนใจเรื่องแค็ปซูล

พฤติกรรมที่คล้ายกันเกิดขึ้นเมื่อชื่อแอ็ตทริบิวต์ของโมดูลเริ่มต้นด้วยเครื่องหมายขีดล่างเดียว (เช่น _foo)

แอตทริบิวต์ของโมดูลที่มีชื่อเช่นนี้จะไม่ถูกคัดลอกไปยังโมดูลการนำเข้าเมื่อใช้from*วิธีการเช่น:

from bar import *

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

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

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

ด้วย Python 3.4 นี่คือพฤติกรรม:

>>> class Foo:
        def __init__(self):
                pass
        def __privateMethod(self):
                return 3
        def invoke(self):
                return self.__privateMethod()


>>> help(Foo)
Help on class Foo in module __main__:

class Foo(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |
 |  invoke(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)

 >>> f = Foo()
 >>> f.invoke()
 3
 >>> f.__privateMethod()
 Traceback (most recent call last):
   File "<pyshell#47>", line 1, in <module>
     f.__privateMethod()
 AttributeError: 'Foo' object has no attribute '__privateMethod'

https://docs.python.org/3/tutorial/classes.html#tut-private

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

แม้ว่าคำถามจะเก่า แต่ฉันหวังว่าข้อมูลโค้ดของฉันจะมีประโยชน์

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

obj._MyClass__myPrivateMethod()

ฉันได้ย้ายจาก C # และในตอนแรกมันก็แปลกสำหรับฉันเช่นกัน แต่หลังจากนั้นไม่นานฉันก็คิดว่าวิธีเดียวที่ Python ออกแบบรหัสคิดเกี่ยวกับ OOP นั้นแตกต่างกัน

ทำไมวิธีการแบบส่วนตัวของ Python จึงไม่เป็นแบบส่วนตัว

เมื่อฉันเข้าใจแล้วพวกเขาไม่สามารถเป็นส่วนตัวได้ ความเป็นส่วนตัวสามารถบังคับใช้อย่างไร

คำตอบที่ชัดเจนคือ "สมาชิกส่วนตัวเท่านั้นที่สามารถเข้าถึงได้ผ่านself" แต่นั่นไม่ได้ผล - selfไม่ใช่พิเศษใน Python มันไม่มีอะไรมากไปกว่าชื่อที่ใช้กันทั่วไปสำหรับพารามิเตอร์แรกของฟังก์ชัน