对于方法，可以使用双下划线隐藏私有“方法”，模式如下：

# Private methods of MyClass
def _MyClass__do_something(obj:'MyClass'):
    print('_MyClass__do_something() called. type(obj) = {}'.format(type(obj)))

class MyClass():
    def __init__(self):
        __do_something(self)

mc = MyClass()

输出：

_MyClass__do_something() called. type(obj) = <class '__main__.MyClass'>

我今天在尝试对类方法使用双下划线时遇到了这个问题，并得到了NameError:name“_<class><method>”未定义错误。

单个下划线

在类中，带前导下划线的名称向其他程序员表示该属性或方法将在该类中使用。然而，隐私权并未以任何方式强制执行。对模块中的函数使用前导下划线表示不应从其他地方导入。

从PEP-8风格指南：

_single_leading_underscore：“内部使用”指标较弱。例如，from M import*不会导入名称以下划线开头的对象。

双下划线（名称Mangling）

从Python文档中：

__spam形式的任何标识符（至少两个前导下划线，最多一个尾随下划线）在文本上替换为_classname__spam，其中classname是当前类名，前导下划线被去掉。这种修改是在不考虑标识符的语法位置的情况下完成的，因此它可以用于定义类私有实例和类变量、方法、存储在全局变量中的变量，甚至是存储在实例中的变量。对于其他类的实例，该类是私有的。

以及来自同一页的警告：

名称修改旨在为类提供一种简单的方法来定义“私有”实例变量和方法，而不必担心派生类定义的实例变量，也不必担心类外的代码干扰实例变量。注意，损坏规则的设计主要是为了避免事故；一个坚定的灵魂仍然有可能访问或修改一个被认为是私有的变量。

实例

>>> class MyClass():
...     def __init__(self):
...             self.__superprivate = "Hello"
...             self._semiprivate = ", world!"
...
>>> mc = MyClass()
>>> print mc.__superprivate
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: myClass instance has no attribute '__superprivate'
>>> print mc._semiprivate
, world!
>>> print mc.__dict__
{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

既然这么多人都在提到雷蒙德的谈话，我就把他说的话写下来，让事情变得简单一点：

双下划线的用意不是关于隐私。我们的意图是这样使用它类圆（对象）：def__init__（自身，半径）：self.radius=半径定义区域（自身）：p=自身__周长（）r=p/math.pi/2.0返回math.pi*r**2.0定义周长（自身）：return 2.0*math.pi*self.radius__周界=周界#本地参考等级轮胎（圆形）：定义周长（自身）：返回圆周长（自身）*1.25这实际上是隐私的反面，都是关于自由的。它使您的子类可以自由覆盖任何一个方法，而不破坏其他方法。

假设您没有在Circle中保留周界的本地参考。现在，派生类Tire覆盖了周长的实现，而不接触面积。当您调用Tire（5）.area（）时，理论上它应该仍然使用Circle.perimeter进行计算，但实际上它使用的是Tire.perimet，这不是预期的行为。这就是为什么我们需要Circle的本地参考。

但为什么用周长代替周长？因为_perimeter仍然给派生类重写的机会：

class Tire(Circle):

    def perimeter(self):
        return Circle.perimeter(self) * 1.25

    _perimeter = perimeter

双下划线具有名称损坏，因此父类中的本地引用在派生类中被重写的可能性很小。因此“使您的子类可以自由覆盖任何一个方法而不破坏其他方法”。

如果您的类不会被继承，或者方法重写不会破坏任何东西，那么您就不需要__double_leading_underscore。

开头有一个下划线：

Python没有真正的私有方法。相反，方法或属性名称开头的一个下划线表示您不应该访问此方法，因为它不是API的一部分。

class BaseForm(StrAndUnicode):
    
    def _get_errors(self):
        "Returns an ErrorDict for the data provided for the form"
        if self._errors is None:
            self.full_clean()
        return self._errors

    errors = property(_get_errors)

（此代码片段取自django源代码：django/forms/forms.py）。在这段代码中，error是一个公共属性，但此属性调用的方法_get_errors是“私有”的，因此您不应该访问它。

开头有两个下划线：

这会引起很多混乱。它不应用于创建私有方法。应该使用它来避免方法被子类重写或意外访问。让我们看一个例子：

class A(object):
    def __test(self):
        print "I'm a test method in class A"

    def test(self):
        self.__test()
 
a = A()
a.test()
# a.__test() # This fails with an AttributeError
a._A__test() # Works! We can access the mangled name directly!

输出：

$ python test.py
I'm test method in class A
I'm test method in class A

现在创建一个子类B并为__test方法进行定制

class B(A):
    def __test(self):
        print "I'm test method in class B"

b = B()
b.test()

输出将是。。。。

$ python test.py
I'm test method in class A

正如我们所看到的，B.test（）并没有像我们预期的那样调用B.__test（）方法。但事实上，这是__的正确行为。名为__test（）的两个方法会自动重命名（损坏）为_A__test（）和_B__test（。当你创建一个以__开头的方法时，这意味着你不希望任何人能够覆盖它，你只想从它自己的类内部访问它。

开头和结尾有两个下划线：

当我们看到像__this___这样的方法时，不要调用它。这是python要调用的方法，而不是您。让我们来看看：

>>> name = "test string"
>>> name.__len__()
11
>>> len(name)
11

>>> number = 10
>>> number.__add__(40)
50
>>> number + 50
60

总是有一个运算符或本机函数调用这些神奇的方法。有时它只是在特定情况下python调用的钩子。例如，在调用__new__（）构建实例后创建对象时调用__init__（）。。。

让我们举个例子。。。

class FalseCalculator(object):

    def __init__(self, number):
        self.number = number

    def __add__(self, number):
        return self.number - number

    def __sub__(self, number):
        return self.number + number

number = FalseCalculator(20)
print number + 10      # 10
print number - 20      # 40

有关详细信息，请参阅[PEP-8指南][1]。有关更多神奇的方法，请参阅[本PDF][2]。[1]: https://www.python.org/dev/peps/pep-0008/#method-名称和实例变量[2] http://github.com/RafeKettler/magicmethods/blob/master/magicmethods.pdf

Python中不存在只能从对象内部访问的“私有”实例变量。然而，大多数Python代码都遵循一个惯例：前缀为下划线的名称（例如_spam）应被视为API的非公共部分（无论是函数、方法还是数据成员）。应将其视为实施细节，如有更改，恕不另行通知。

参考https://docs.python.org/2/tutorial/classes.html#private-变量和类本地引用

到目前为止，答案很好，但缺少一些花絮。一个前导下划线不仅仅是一个约定：如果使用from foobar import*，并且foobar模块没有定义__all__列表，那么从模块导入的名称不包括前导下划线的名称。假设这主要是一个惯例，因为这个案例是一个相当模糊的角落；-）。

前导下划线约定不仅广泛用于私有名称，也广泛用于C++所称的受保护的名称，例如，完全打算由子类重写的方法的名称（即使是必须重写的方法，因为在基类中它们引发NotImplementedError！-）通常是单前导下划线名称，以向使用该类（或子类）实例的代码指示不打算直接调用所述方法。

例如，要使线程安全队列具有与FIFO不同的排队规则，可以导入queue，将queue.queue子类化，并重写_get和_put等方法；“客户端代码”从不调用这些（“钩子”）方法，而是调用（“组织”）公共方法，如put和get（这被称为模板方法设计模式——例如，请参见此处，以获取基于我关于该主题的演讲视频的有趣演示，并添加了摘要）。

编辑：会谈描述中的视频链接现已断开。你可以在这里和这里找到前两个视频。