Почему «приватные» методы Python на самом деле не приватны?

Пример частной функции

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 ###

От http://www.faqs.org/docs/diveintopython/fileinfo_private.html

Строго говоря, частные методы доступный вне их класса, просто не легко доступны. Ничего в Python действительно личный; внутренне, имена частных методов и атрибуты искажены и не связаны на лету, чтобы заставить их казаться недоступными по их названию. Вы может получить доступ к методу __parse Класс MP3FileInfo по названию _MP3FileInfo__parse. Признайте, что это интересно, тогда обещайте никогда, никогда не делайте это в реальном коде. Частные методы приватны для разум, но, как и многие другие Python, их приватность в конечном счете, вопрос конвенции, а не сила.

Когда я впервые пришел из Java в Python я hated. Это напугало меня до смерти.

Сегодня это может быть только одна вещь , которую я люблю больше всего о Python.

Мне нравится находиться на платформе, где люди доверяют друг другу и не чувствуют, что им нужно строить непроницаемые стены вокруг своего кода. В сильно инкапсулированных языках, если у API есть ошибка, и вы выяснили, что пошло не так, вы все равно не сможете обойти его, потому что необходимый метод является закрытым. В Python отношение: "уверен". Если вы думаете, что понимаете ситуацию, возможно, вы ее даже прочитали, тогда все, что мы можем сказать, "удачи!".

Помните, что инкапсуляция даже не слабо связана с "безопасностью" или не позволяет детям покинуть газон. Это просто еще один шаблон, который следует использовать для упрощения понимания базы кода.

Обычно используется фраза: "Мы все соглашаем взрослых здесь". Добавив одно подчеркивание (не раскрывайте) или двойное подчеркивание (скрыть), вы сообщаете пользователю своего класса, что вы намерены, чтобы член был 'private' каким-то образом. Тем не менее, вы доверяете всем остальным вести себя ответственно и уважать это, если только у них нет веских причин (например, отладчиков, завершения кода).

Если у вас действительно есть что-то частное, вы можете реализовать его в расширении (например, в C для CPython). В большинстве случаев, однако, вы просто изучаете питоновский способ делать вещи.

Это не так, как вы абсолютно не можете обойти неприкосновенность членов на любом языке (указательная арифметика в С++, Reflections в .NET/Java).

Дело в том, что вы получаете сообщение об ошибке, если пытаетесь случайно вызвать частный метод. Но если вы хотите стрелять в ногу, продолжайте и делайте это.

Изменить: вы не пытаетесь защитить свои вещи посредством OO-инкапсуляции, не так ли?

Подобное поведение существует, когда имена атрибутов модуля начинаются с одного подчеркивания (например, _foo).

Атрибуты модуля, названные как таковые, не будут скопированы в модуль импорта при использовании метода from*, например:

from bar import *

Однако это соглашение, а не языковое ограничение. Это не частные атрибуты; на них можно ссылаться и манипулировать любым импортером. Некоторые утверждают, что из-за этого Python не может реализовать истинную инкапсуляцию.

Это только один из вариантов выбора языка. На каком-то уровне они оправданы. Они делают это так, что вам нужно идти довольно далеко от вашего пути, чтобы попытаться вызвать метод, и если вам это действительно нужно, вы должны иметь довольно вескую причину!

Отладочные крючки и тестирование приходят на ум как возможные приложения, которые, конечно, используются ответственно.

Соглашение об именах class.__stuff позволяет программисту понять, что он не предназначен для доступа к __stuff извне. Название mangling делает маловероятным, что кто-то сделает это случайно.

Правда, вы все равно можете обойти это, это еще проще, чем на других языках (что BTW также позволяет вам это делать), но ни один программист на 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()

Я перешел с С#, и сначала это было странно для меня, но через некоторое время я пришел к мысли, что только то, как дизайнеры кода Python думают об ООП, отличается.