Скремблирование имен используется для гарантии того, что подклассы случайно не переопределят частные методы и атрибуты своих суперклассов. Он не предназначен для предотвращения преднамеренного доступа извне.

Например:

>>> 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-инкапсуляции, не так ли?

Важная заметка:

Любой идентификатор формы __name (не менее двух ведущих подчеркиваний, не более одного подчеркивания в конце) публично заменяется на _classname__name, где classname - это имя текущего класса с удаленным начальным подчеркиванием.

Таким образом, __name является частным, а _classname__name - общедоступным.

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

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

Пример

class Cat:
    def __init__(self, name='unnamed'):
        self.name = name
    def __print_my_name(self):
        print(self.name)
        
        
tom = Cat()
tom.__print_my_name() #Error
tom._Cat__print_my_name() #Prints name

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

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

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

Насколько я понимаю, они не могут быть приватными. Как можно обеспечить конфиденциальность?

Очевидный ответ - «к закрытым членам можно получить доступ только через self», но это не сработает - self не является особенным в Python, это не что иное, как обычно используемое имя для первого параметра функции.