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

例如：

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

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

当我第一次从Java到Python时，我讨厌这一点。它把我吓死了。

今天，这可能只是我最喜欢Python的一件事。

我喜欢呆在一个平台上，在这个平台上，人们相互信任，不觉得需要在他们的代码周围建造难以穿透的墙。在强封装语言中，如果API有一个错误，并且您已经发现了问题所在，那么您可能仍然无法解决它，因为所需的方法是私有的。在Python中，态度是：“确定”。如果你认为你理解这种情况，也许你甚至读过它，那么我们只能说“祝你好运！”。

请记住，封装甚至与“安全”或让孩子远离草坪没有微弱的关系。这只是另一种模式，应该用来使代码库更容易理解。

Example of a private function

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，3.9。专用功能：

Strictly speaking, private methods are accessible outside their class, just not easily accessible. Nothing in Python is truly private; internally, the names of private methods and attributes are mangled and unmangled on the fly to make them seem inaccessible by their given names. You can access the __parse method of the MP3FileInfo class by the name _MP3FileInfo__parse. Acknowledge that this is interesting, then promise to never, ever do it in real code. Private methods are private for a reason, but like many other things in Python, their privateness is ultimately a matter of convention, not force.

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

如果您确实必须拥有私有的东西，那么您可以在扩展中实现它（例如，在C中用于CPython）。然而，在大多数情况下，您只需学习Python式的做事方式。

并不是说在任何语言中都绝对不能绕过成员的私有性（C++中的指针算法和.NET/Java中的反射）。

关键是，如果你试图意外地调用私有方法，就会出现错误。但如果你想开枪打自己的脚，那就去做吧。

你不会试图通过OO封装来保护你的东西，是吗？

Important note:

形式为__name的任何标识符（至少两个前导下划线，最多一个尾随下划线）都会被_classname__name公开替换，其中classname是去掉前导下划线的当前类名。

因此，__name不能直接访问，但可以作为_classname__name访问

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