在对象名称之前，单个和双重下划线的含义是什么？

Question

在Python中对象的名称代表之前，单个和双重领导下指标是什么？

Answer 1

一类中的单个下划线

，带有领先下划线的名称向其他程序员表示属性或方法旨在在该类中使用。但是，隐私不是任何方式执行的。
在模块中使用领先的下划线进行功能表明不应从其他地方导入它。

来自 pep-8 样式指南：

_single_leading_underscore ：弱“内部使用”指示器。例如，来自m import *的代码>不导入其名称以下划线开头的对象。

double double dusterscore（name mangling）

表单的任何标识符 __垃圾邮件（至少两个领先的下划线，最多有一个尾随下划线）被文本替换为 _CLASSNAME__SPAM ，其中 className 是当前的班级名称，带有领先的下划线剥离。此乱七八糟的是无需考虑标识符的句法位置，因此可以用来定义类别私有实例和类变量，方法，存储在Globals中的变量，甚至在实例中存储的变量。在其他课程的实例上，本班的私人。

并从同一页面发出警告：

名称杂交旨在为类提供一种简单的方法来定义“私有”实例变量和方法，而不必担心通过派生类定义的实例变量，或者通过类在类外部代码与实例变量弄乱。请注意，乱七八糟的规则主要是为了避免事故。 确定的灵魂仍然有可能访问或修改被认为是私人的变量。

示例

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

到目前为止，出色的答案，但缺少一些花絮。单个领先的下划线不完全 一个惯例：如果您从foobar import *中使用，而模块 foobar 不定义 __所有__ 列表，从模块导入的名称 不包括带有领先下划线的名称。假设这是主要是的惯例，因为这种情况是一个非常晦涩的角落;-)。

领先的condent惯例不仅被广泛用于 private 名称，还用于C ++所谓的受保护的名称 - 例如，完全旨在完全旨在的方法的名称被子类（即使是已经被覆盖的子类）覆盖，因为在基类中，它们提高noctimplementedError ！ - ）通常是单个Leading-underScore名称，以指示代码<强>使用该类别（或子类）的实例，该类别并非直接调用所述方法。

例如，要使与FIFO不同的排队纪律制作线程安全队列，One inovers queue，subclasses queue.queue.queue和覆盖 _get> _get 和 _put> _put 之类的方法; “客户端代码”从不调用这些（“钩”）方法，而是（“组织”）公共方法，例如 put 和 get （这被称为< a href =“ http://en.wikipedia.org/wiki/wiki/template_method_pattern” rel =“ noreferrer”> template方法设计模式 - 请参阅eg 此处 基于关于我的主题的谈论的视频，并添加了有趣的演讲成绩单的概念）。

编辑：谈判描述中的视频链接现在被打破。您可以找到前两个视频在这里 .youtube.com/watch？v = tjxhtncdbu4“ rel =“ noreferrer”>在这里。

Answer 4

._变量是半剥夺的，仅对于惯例

.__变量通常被错误地考虑到超级私人，而其实际含义仅是namemangle到防止意外访问 [1]

.__ .__

您仍然可以访问。双重下调的只是namemangles或命名，将变量添加到 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隐藏，因为它不再存在，因为它不再存在由于

>>> 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取的）。在此代码中，错误是公共属性，但是该属性调用的方法是_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

总有一个称为这些魔术方法的操作员或本机功能。有时候，这只是在特定情况下打电话的钩子。例如，当 __ init __（）在 __ new __（）之后创建对象时，请调用来构建实例...

让我们以示例...

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指南 。有关更多魔术方法，请参见 this pdf 。

Answer 6

根据 python中的

• 含义代码> _VAR ）：命名约定，指示该名称旨在内部使用。通常，Python的口译员（在通配符进口中除外）并不是对程序员的提示。
• 单个尾随下划线（ var _ ）：公约用来避免使用Python关键字命名冲突。
• 双领先下划线（ __ var ）：在课堂上下文中使用时触发名称杂物。由Python口译员执行。
• 双领先和尾随下划线（ __ var __ ）：指示由Python语言定义的特殊方法。避免使用您自己属性的这个命名方案。
• 单个下划线（ _ ）：有时用作临时或微不足道变量的名称（“不在乎”）。另外：python中最后一个表达式的结果 repl 。

Answer 7

由于有很多人指的是雷蒙德的谈话写下他所说的话，这要容易一些：

双重下调的意图与隐私无关。目的是像这样使用它

  class Circle（对象）：

    def __init __（自我，半径）：
        self.radius =半径

    DEF区域（自我）：
        p = self .__ ender（）
        r = p / math.pi / 2.0
        返回Math.pi * r ** 2.0

    DEF周长（自我）：
        返回2.0 * Math.pi * self.radius

    __ Perimeter =周长＃本地参考


轮胎班级（圈）：

    DEF周长（自我）：
        返回圆圈。
 

实际上与隐私相反，这全都与自由有关。它使您的子类自由覆盖任何一种方法而不打破其他方法。

假设您在 circle 中不保留外围的本地参考。现在，派生的类轮胎覆盖了周边的实现，而无需触摸 afear 。当您调用轮胎（5）.AREA（）时，理论上仍应使用 circle.perimeter 进行计算，但实际上它使用的是 tire.perimeter.perimeter.perimeter.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)

在这种情况下，正在发生的事情是，_（）是本地化函数的别名地方。例如，狮身人面像这样做，您将在Imports

from sphinx.locale import l_, _

和sphinx.locale中找到_（）中的发现，将其分配为某些本地化函数的别名。

Answer 9

• _var ：Python中带有领先单个下划线的变量是经典变量，旨在使用您的代码通知其他变量，以便将此变量保留为内部使用。它们在一个点上与经典变量有所不同：在执行定义的对象/模块的通配符导入的通配符导入时，它们没有被导入（定义

• _ ：单个下划线是领先的单个下划线变量的特殊情况。会议将其用作垃圾变量，以存储不打算以后访问的值。它也不是通配符进口的进口。例如：此循环打印“我必须在课堂上说话” 10次，而不需要访问 _ 变量。

   <代码> _在范围内（10）：
      打印（“我不能在课堂上说话”）
   

• var _ ：单个尾随下划线变量。它们是公约使用的经典变量，以避免与Python关键字发生冲突。例如：

    class_ =“ myClassName”
   

• __ var ：双领先下划线变量（至少两个领先的下划线，最多有一个尾随下划线）。当用作类属性（变量和方法）时，这些变量将由名称进行杂交：班级之外，Python将将属性重命名为 _＆lt; class_name＆gt; __＆gt; __＆lt; attribute_name＆gt; ; 。示例：

   类myclass：
      __an_attribute =“ attribute_value”
  
  my_class = myClass（）
  打印（my_class._myclass__an_attribute）＃“ attribute_value”
  print（my_class .__ an_attribute）＃attributeError：'myclass'对象没有属性'__an_attribute'
   

  当类似于单个领先的下划线变量时，它们的表现是在类似的班级外部。

• __ var __ ：双向和尾随下划线变量（至少两个领先和尾随下划线）。也称为 dunders 。 Python使用此命名约定在内部定义变量。避免使用此约定来防止Python更新可能引起的名称冲突。 Dunder变量的行为就像单个领先的下划线变量：在类中使用时，它们不受名字的名称，而是在通配符导入中导入。

Answer 10

如果一个人真的想制作一个只能读取的变量，那么恕我直言，最好的方法就是使用property（），而只通过getter将其传递给它。使用属性（），我们可以完全控制数据。

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_varable（又称名称mangling）替换了变量名称，并且它降低了/隐藏的视野，并且更像是私人变量。

老实说，在这里根据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 Repp中创建一个子实例，您会看到以下

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 __ 等。double

引导下方均带有tailling对等方面的双领先底列，但是也是一个约定。类方法将为 mangled> mangled 解释者。对于变量或基本函数名称，没有差异。

Answer 14

您的问题很好，不仅与方法有关。模块中的功能和对象通常也以一个下划线为前缀，并且可以由两个前缀。

但是__double_underscore名称并未在模块中使用名称。发生的事情是，如果您从模块中导入全部（从模块导入 *），则不会导入一个（或更多）下划线的名称，也不会在help（模块）中显示名称。

Answer 15

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

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

Answer 16

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

这就是我的看法：

_

应使用来指示函数不用于公众使用，例如API。这和导入限制使其行为与C＃中的内部。

__

应使用以避免在继承的遗迹中碰撞并避免隔离。很像C＃中的私人。

==＆gt;

如果要指出某物不是用于公共使用的东西，但应像受保护使用 _ 一样。
如果您想指出某物不是用于公共使用的东西，但应像 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'>

当我尝试使用double double下划线用于类方法并获得 name eRror：name'name'时，我今天偶然发现了这一点。 _＆lt; class＆gt;＆lt;未定义错误。

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-public-private-protected-modifiers

Answer 19

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

- obj表示私有（它们无法从定义的班级外部直接访问它们。但是，Python并不像其他语言那样强制执行严格的私人访问；取而代之的是，它执行名称操作以使访问更加困难，但并非不可能。）

杂交是Python中的一个功能，它修改了类成员的名称，以使直接从班级外部直接访问。这是一种用于创建“伪私人”变量和方法的技术。这是通过将成员名称加上双重下划线（__）的前缀来完成