对象名称前的单下划线和双下划线的含义是什么？

Question

Python 中对象名称前的单下划线和双下划线代表什么？

Answer 1

单下划线

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

来自 PEP-8 风格指南：

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

双下划线（名称修改）

来自 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!'}

Answer 2

• _foo：只是一个约定。程序员表明该变量是私有的（无论这在 Python 中意味着什么）。

• __foo：这有实际意义。解释器将此名称替换为 _classname__foo，以确保该名称不会与另一个类中的类似名称重叠。

• __foo__：只是一个约定。 Python系统使用不会与用户名冲突的名称的一种方式。

在 Python 世界中，其他形式的下划线都没有意义。此外，在这些约定中，类、变量、全局等之间没有区别。

Answer 3

到目前为止，答案很好，但缺少一些花絮。单个前导下划线并不完全只是一种约定：如果您使用 from foobar import *，并且模块 foobar 没有定义 __all__ 列表中，从模块导入的名称不包含以下划线开头的名称。假设这主要是一种约定，因为这个案例是一个相当不起眼的角落;-)。

前导下划线约定不仅广泛用于私有名称，而且还用于 C++ 称为受保护的名称 - 例如，完全旨在被子类覆盖（即使是必须被覆盖的子类，因为在基类中它们引发NotImplementedError！-）通常是单前导下划线名称来指示代码<使用该类（或子类）的实例，该方法并不意味着直接调用。

例如，要创建一个具有与 FIFO 不同的排队规则的线程安全队列，可以导入 Queue，子类化 Queue.Queue，并重写诸如 _get 和 _put 之类的方法； “客户端代码”从不调用这些（“钩子”）方法，而是调用（“组织”）公共方法，例如 put 和 get （这称为 < a href="http://en.wikipedia.org/wiki/Template_method_pattern" rel="noreferrer">模板方法设计模式 - 请参见 此处 提供了一个有趣的演示，该演示基于我关于该主题的演讲视频，并添加了抄本摘要）。

编辑：演讲描述中的视频链接现已损坏。您可以在此处和此处。

Answer 4

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

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

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

如果您迫切需要，您仍然可以访问 .__mangled 变量。双下划线只是将变量命名或重命名为 instance._className__mangled

示例：

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 找不到，因为它不再存在由于 namemangling

>>> t._Test__a
'a'

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

Answer 5

开头单下划线：

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）。在此代码中，errors 是公共属性，但该属性调用的方法 _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 指南 。有关更多魔术方法，请参阅此 PDF。

Answer 6

根据 Python 中下划线的含义

• 单前导下划线(< code>_var)：命名约定，指示名称供内部使用。通常不由 Python 解释器强制执行（通配符导入除外），仅作为对程序员的提示。
• 单尾下划线(var_)：按惯例使用以避免与Python关键字发生命名冲突。
• 双前导下划线(__var)：在类上下文中使用时触发名称修改。由 Python 解释器强制执行。
• 双前导和尾随下划线(__var__)：表示Python语言定义的特殊方法。避免为您自己的属性采用这种命名方案。
• 单下划线(_)：有时用作临时或无关紧要的变量的名称（“不关心”）。另外：Python REPL 中最后一个表达式的结果。

Answer 7

由于很多人都在参考 Raymond 的演讲，我就简单说一下写下他说的话会更容易一些：

双下划线的目的不是为了隐私。目的是像这样使用它

类 Circle（对象）：

    def __init__(自身，半径)：
        self.radius = 半径

    定义区域（自身）：
        p = self.__周长()
        r = p / 数学.pi / 2.0
        返回math.pi * r ** 2.0

    定义周长（自身）：
        返回 2.0 * math.pi * self.radius

    __perimeter = 周长 # 局部参考


轮胎类别（圆）：

    定义周长（自身）：
        返回 Circle.perimeter(self) * 1.25

这实际上与隐私相反，这都是关于自由的。它使您的子类可以自由地重写任何一种方法，而不会破坏其他方法。

假设您没有在 Circle 中保留 perimeter 的本地引用。现在，派生类 Tire 重写了 perimeter 的实现，而不触及 area。当您调用 Tire(5).area() 时，理论上它应该仍然使用 Circle.perimeter 进行计算，但实际上它使用 Tire.perimeter，这不是预期的行为。这就是为什么我们需要 Circle 中的本地引用。

但为什么是__perimeter而不是_perimeter呢？因为 _perimeter 仍然为派生类提供了重写的机会：

class Tire(Circle):

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

    _perimeter = perimeter

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

如果您的类不会被继承，或者方法重写不会破坏任何内容，那么您根本不需要 __double_leading_underscore。

Answer 8

有时您会看到一个带有前导下划线的元组，如在

def foo(bar):
    return _('my_' + bar)

本例中，发生的情况是 _() 是本地化函数的别名，该函数对文本进行操作以将其转换为正确的语言等。语言环境。例如，Sphinx 就是这样做的，您会发现在导入

from sphinx.locale import l_, _

和 sphinx.locale 中，_() 被指定为某些本地化函数的别名。

Answer 9

• _var：Python 中以单下划线开头的变量是经典变量，旨在通知其他使用您代码的人该变量应保留供内部使用。它们与经典变量有一点不同：在定义它们的对象/模块中进行通配符导入时，不会导入它们（定义 __all__ 变量）。例如：

  # foo.py
  
  变量=“变量”
  _var =“_var”
  

  # bar.py
  
  从 foo 导入 *
  
  print(dir()) # 已定义对象的列表，包含 'var' 但不包含 '_var'
  打印（var）#var
  print(_var) # NameError: 名称 '_var' 未定义
  

• _ ：单下划线是前导单下划线变量的特殊情况。按照惯例，它被用作垃圾变量，用于存储以后不打算访问的值。它也不是通过通配符导入来导入的。例如：这个 for 循环打印“我不能在课堂上讲话”10 次，并且永远不需要访问 _ 变量。

  对于范围 (10) 内的 _：
      print("我不能在课堂上说话")
  

• var_：单个尾随下划线变量。它们是按惯例使用的经典变量，以避免与 Python 关键字冲突。例如：

  class_ = "MyClassName"
  

• __var：双前导下划线变量（至少两个前导下划线，最多一个尾随下划线）。当用作类属性（变量和方法）时，这些变量会受到名称修改的影响：在类之外，Python 会将属性重命名为 ___。示例：

  类 MyClass:
      __an_attribute = "属性值"
  
  my_class = MyClass()
  print(my_class._MyClass__an_attribute) # “属性值”
  print(my_class.__an_attribute) # AttributeError: 'MyClass' 对象没有属性 '__an_attribute'
  

  当在类外部用作变量时，它们的行为类似于单个前导下划线变量。

• __var__：双前导和尾随下划线变量（至少两个前导和尾随下划线）。也称为dunders。 python 使用此命名约定在内部定义变量。避免使用此约定来防止 python 更新可能出现的名称冲突。 Dunder 变量的行为类似于单个前导下划线变量：它们在类内部使用时不受名称修改的影响，但不会在通配符导入中导入。

Answer 10

如果确实想将变量设置为只读，恕我直言，最好的方法是使用 property() ，仅将 getter 传递给它。使用 property() 我们可以完全控制数据。

class PrivateVarC(object):

    def get_x(self):
        pass

    def set_x(self, val):
        pass

    rwvar = property(get_p, set_p)  

    ronly = property(get_p) 

我知道OP问了一个不同的问题，但由于我发现另一个问题询问“如何设置私有变量”，与这个问题标记重复，我想在这里添加这个附加信息。

Answer 11

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

含义：

some_variable --► 它是公开的，任何人都可以看到它。

_some_variable --► 它是公开的，任何人都可以看到它，但这是表示私有的约定...警告Python 不执行任何强制操作。

__some_varaible --► Python 用 _classname__some_varaible 替换变量名（又名名称修改），它减少/隐藏它的可见性，并且更像私有变量。

老实说根据Python文档

““私有”实例变量只能从
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)

Answer 12

下面是一个简单的说明性示例，说明双下划线属性如何影响继承的类。因此，通过以下设置：

class parent(object):
    __default = "parent"
    def __init__(self, name=None):
        self.default = name or self.__default

    @property
    def default(self):
        return self.__default

    @default.setter
    def default(self, value):
        self.__default = value


class child(parent):
    __default = "child"

如果您随后在 python REPL 中创建一个子实例，您将看到下面的内容

child_a = child()
child_a.default            # 'parent'
child_a._child__default    # 'child'
child_a._parent__default   # 'parent'

child_b = child("orphan")
## this will show 
child_b.default            # 'orphan'
child_a._child__default    # 'child'
child_a._parent__default   # 'orphan'

这对某些人来说可能是显而易见的，但在更复杂的环境中它让我措手不及

Answer 13

单前导下划线是一种约定。从解释器的角度来看，名称是否以下划线开头没有区别。

双前导和尾随下划线用于内置方法，例如 __init__、__bool__ 等。

双前导下划线不带尾随对应项也是一种约定，但是，类方法将被解释器mangled。对于变量或基本函数名称不存在差异。

Answer 14

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

但是，例如，__double_underscore 名称在模块中不会被名称破坏。发生的情况是，如果从模块导入所有名称（from module import *），则不会导入以一个（或多个）下划线开头的名称，help(module) 中也不会显示名称。

Answer 15

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

参考
https://docs.python.org /2/tutorial/classes.html#private-variables-and-class-local-references

Answer 16

获取 _ 和 __ 的事实非常容易；其他答案很好地表达了它们。其用途更难确定。

我是这样看的：

_

应该用来表明某个函数不供公共使用，例如 API。这个和导入限制使它的行为与 C# 中的 internal 非常相似。

__

应该用于避免继承层次结构中的名称冲突并避免后期绑定。很像 c# 中的 private。

==>

如果您想表明某些内容不供公共使用，但其行为应类似于 protected，请使用 _。
如果您想表明某些内容不供公共使用，但其行为应类似于 private，请使用 __。

这也是我非常喜欢的一句话：

问题是类的作者可能合理地认为“这个
属性/方法名称应该是私有的，只能从内部访问
这个类定义”并使用 __private 约定。但后来，
该类的用户可以创建一个合法需要的子类
访问该名称。所以要么必须修改超类
（这可能很困难或不可能），或者子类代码必须
使用手动修改的名称（这充其量是丑陋且脆弱的）。

但我认为，这样做的问题是，如果没有 IDE 在您重写方法时发出警告，那么如果您不小心重写了基类中的方法，则可能需要一段时间才能找到错误。

Answer 17

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

# 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 ' 时，我偶然发现了这一点_<类><方法>'未定义错误。

Answer 18

为了用简单的话来表达它，让我们将 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

Answer 19

_obj 表示受保护（可以在定义类及其子类内访问）

--obj 表示私有（它们不能从定义它们的类外部直接访问。但是，Python 并不像其他一些语言那样强制执行严格的私有访问；相反，它执行名称重整，使访问变得更加困难，但并非不可能。）

重整是 Python 中的一项功能，它修改类成员的名称，以使其更难从类外部直接访问。这是一种用于创建“伪私有”变量和方法的技术。这是通过在成员名称前加上双下划线 (__) 前缀但不以另一个双下划线结尾来完成的