名称加扰用于确保子类不会意外覆盖其超类的私有方法和属性。它的设计不是为了防止外界故意进入。

例如：

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

当然，如果两个不同的类具有相同的名称，它就会崩溃。

常用的短语是“我们都是成年人”。通过在前面加上一个下划线（不要暴露）或双下划线（隐藏），您可以告诉类的用户您希望成员以某种方式“私有”。然而，您相信其他人都会表现得负责任并尊重这一点，除非他们有令人信服的理由不这样做（例如，调试器和代码完成）。

如果您确实必须拥有私有的东西，那么可以在扩展中实现它（例如，在C for CPython中）。然而，在大多数情况下，您只需学习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'

从9.6开始。专用变量：

注意，损坏规则的设计主要是为了避免事故；仍然可以访问或修改被认为是私有的变量。这甚至可以在特殊情况下使用，例如在调试器中。

关于私有方法和属性最重要的问题是告诉开发人员不要在类外部调用它，这就是封装。人们可能误解了封装的安全性。当你故意使用你提到的（下面）语法时，你不需要封装。

obj._MyClass__myPrivateMethod()

我是从C#迁移过来的，起初这对我来说也很奇怪，但过了一段时间，我发现只有Python代码设计者对OOP的思考方式不同。

专用函数示例

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 beginning
            matched = re.match( '^self\.', function_call)
            if not matched:
                print 'This is a private function. Go away.'
                return
        except:
            print 'This is a private function. Go away.'
            return

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

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

### End ###

为什么Python的“私有”方法实际上不是私有的？

据我所知，他们不可能是私人的。如何才能强制实施隐私？

显而易见的答案是“私有成员只能通过self访问”，但这行不通——self在Python中并不特殊。它只是函数的第一个参数的常用名称。