你的问题很好，不仅仅是关于方法。模块中的函数和对象通常也以一个下划线作为前缀，也可以以两个下划线作为后缀。

例如，__double_underscore名称在模块中不会被篡改。如果从一个模块（从模块导入*）导入所有名称，则不会导入以一个（或多个）下划线开头的名称，也不会导入帮助（模块）中显示的名称。

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

# 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>”未定义错误。

很好的答案，而且都是正确的。我提供了简单的例子以及简单的定义/含义。

含义：

某些变量--► 这是公开的，任何人都可以看到。

_某些变量--► 这是公开的，任何人都可以看到，但这是一个惯例，表明私人。。。警告Python不执行强制。

__某些变量--► Python将变量名替换为_classname__some_varable（AKA name mangling），并降低/隐藏其可见性，更像是私有变量。

老实说，根据Python文档

无法访问的“Private”实例变量Python中不存在对象“

示例：

class A():
    here="abc"
    _here="_abc"
    __here="__abc"


aObject=A()
print(aObject.here) 
print(aObject._here)
# now if we try to print __here then it will fail because it's not public variable 
#print(aObject.__here)

.variable是半私有的，仅用于约定

.__variable通常被错误地认为是超级私有的，而它的实际含义只是为了命名mangle以防止意外访问[1]

.__variable__通常为内置方法或变量保留

您仍然可以访问__如果您非常想的话，可以对变量进行损坏。双下划线只是将变量命名为mangles或重命名为instance_类名__已损坏

例子：

class Test(object):
    def __init__(self):
        self.__a = 'a'
        self._b = 'b'

>>> t = Test()
>>> t._b
'b'

t.b是可访问的，因为它仅按惯例隐藏

>>> t.__a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Test' object has no attribute '__a'

找不到t.__a，因为它由于名称损坏而不再存在

>>> t._Test__a
'a'

通过访问实例_className__variable而不仅仅是双下划线名称，您可以访问隐藏值

开头有一个下划线：

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变量的可访问性约定与Java中的访问修饰符进行比较：

(Python)                                     =   (Java)
_single_underscore_variable                  =   Protected (Accessible to class and its subclasses)
__double_underscore_variable                 =   Private (Accessible to class itself only)
no_underscore_variable                       =   Public (Accessible anywhere)

参考：https://www.tutorialsteacher.com/python/public-private-protected-modifiers