Чому "приватні" методи 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, їхня приватність - це врешті-решт питання конвенції, а не сили.

Загальновживана фраза - "ми тут усі згоди на дорослих". Заздалегідь випереджаючи окремий підкреслення (не розкривайте) або подвійне підкреслення (приховування), ви повідомляєте користувачеві свого класу, що ви маєте намір учасником певним чином бути "приватним". Однак ви довіряєте всім іншим поводитися відповідально і поважати це, якщо вони не мають вагомих причин цього не робити (наприклад, налагоджувачі, заповнення коду).

Якщо у вас справді має бути щось приватне, ви можете реалізувати це в розширенні (наприклад, в C для CPython). Однак у більшості випадків ви просто вивчаєте піфонічний спосіб робити речі.

Це не так, як ви абсолютно не можете обійти приватність членів будь-якою мовою (арифметика вказівника на C ++, відбиття в .NET / Java).

Справа в тому, що ви отримуєте помилку, якщо намагаєтеся викликати приватний метод випадково. Але якщо ви хочете стріляти собі в ногу, продовжуйте це і робіть.

Редагувати: Ви не намагаєтеся закріпити свої речі шляхом OO-інкапсуляції, чи не так?

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

Зауважте, що правила керування людьми розроблені переважно для уникнення нещасних випадків; все ще можна отримати доступ або змінити змінну, яка вважається приватною. Це навіть може бути корисно в особливих обставинах, наприклад, у налагоджувачі.

Навіть якщо питання старе, я сподіваюся, що мій фрагмент може бути корисним.

Найважливіше занепокоєння щодо приватних методів та атрибутів - це сказати розробникам не називати його поза класом, і це інкапсуляція. можна неправильно зрозуміти безпеку від інкапсуляції. коли ви навмисно використовуєте такий синтаксис (нижче), який ви згадали, ви не хочете інкапсуляції.

obj._MyClass__myPrivateMethod()

Я мігрував з C #, і спочатку це теж було дивно для мене, але через деякий час я прийшов до думки, що тільки спосіб, який дизайнери коду Python думають про OOP, відрізняється.

Чому "приватні" методи Python насправді не є приватними?

Як я розумію, вони не можуть бути приватними. Як можна забезпечити конфіденційність?

Очевидна відповідь - "приватні члени можуть отримати доступ лише через self", але це не вийде - selfце не особливе значення в Python, це не що інше, як загальновживане ім'я першого параметра функції.