在对象名称之前单个下划线的单个下划线是什么意思？

一个下的下划线

带有领先的下划线的类中的名称只需指示其他程序员，即属性或方法才能私有用途。 但是，名称本身没有什么特别的。

引用
http://www.python.org/dev/peps/pep-0008/
:

_single_leading_underscore: 弱指标 "internal use". E.g.

from M import *

不会导入名称以带下划线的符号开头的对象。

双重下划线 /失真名称/

的
https://docs.python.org/3/tuto ... ables
Python :

任何类型标识符

__spam

/至少两个领先的重点，不超过一个下划线 trailing/ 变形是替代的

_classname__spam

, 在哪里

classname

- 这是当前类名，带有弯曲的领先强调。 执行该失真而不考虑标识符的语法位置，因此可用于确定类的类私有实例和变量，方法，存储在全局中的类，甚至存储在实例中的变量。 在其他课程的情况下为此课程关闭。

和同一页面的警告：

名称失真旨在为类提供一种简单的方法来识别变量和实例方法 “private”, 不要担心衍生类定义的变量实例，或者类之外的代码更改了实例变量。 请注意，扭曲规则主要开发，以避免事故; 特定灵魂仍然可以访问或更改被视为私有的变量。

例子

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

&gt;&gt;&gt; print mc._semiprivate

, world!

&gt;&gt;&gt; print mc.__dict__

{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

</module></stdin>

仍然很好的回应，但有些小伙子缺失。 唯一的初始下划线不是

只是

协议：如果您使用

from foobar import *

, 一个模块

foobar

没有定义列表

__all__

, 从模块导入的名称，

不是

包含初始下划线的名称。 让我们说这是

基本的

公约，因为这种情况是非常黑暗的角度; -/.

初始的下划线协议不仅用于私人名称，还广泛使用 C++ 会呼唤受保护

例如，完全打算重新定义子类的方法的名称 /甚至

那些必须重新定义的人因为在基础上他们

raise NotImplementedError

! -/, 经常是名称 single-leading-underscore, 使用此类实例指示代码 /或亚亚类/, 指定的方法不适用于直接呼叫。

例如，要从其他大规模维护的另一门学科创建线程安全队列 FIFO, 一个导入队列，子类 Queue.Queue 并覆盖这些方法

_get

和

_put

; "client code" 永远不会导致这些方法 /"hook"/, 而且相当开放的方法 /"organizing"/, 如那个

put

和

get

/这被称为模板设计模板设计模板，例如，这是一个有趣的演示，基于对此主题的对话的视频，增加了转录程序的简要描述/.

编辑：在谈判描述中链接到视频现在不起作用。 您可以找到前两个视频。
https://www.youtube.com/watch?v=1Sbzmz1Nxvo
和
https://www.youtube.com/watch?v=tJXhtncDBu4
.

__foo__

: 这只是一个协议，系统的方法 Python 使用不会与用户名冲突的名称。

_foo

: 这只是一个惯例，程序员指示变量是私有的方法 /无论含义何种意义 Python/.

__foo

: 它具有实际值：解释器替换此名称

_classname__foo

, 确保名称不会在另一个类中以相同的名称重叠。

在世界上没有其他形式的下划线无关紧要 Python.

在这些协议中，类，变量，全局等没有区别。

._variable

半墙和仅适用于惯例

.__variable

is often incorrectly considered superprivate, while it's actual meaning is just to namemangle to

prevent accidental access

https://www.youtube.com/watch% ... 33m8s

.__variable__

is typically reserved for builtin methods or variables

You can still access

.__mangled

variables if you desperately want to. The double underscores just namemangles, or renames, the variable to something like

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'

转到K.

instance._className__variable

而不是简单的双下核，可以访问隐藏值。
</module></stdin>

一开始一个下划线

:

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, 是一个 "private", 因此，你不应该与他联系。

一开始就有两个下划线

:

它导致很多混乱。 它不应用于创建私有方法。 它应该用来避免通过子类或随机访问来覆盖你的方法。 让我们考虑一个例子：

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 method

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

我们如何看待 A.test// 没有原因 B.__test// 方法是你期望的。 但事实上，这是正确的行为 __. 两种方法称为 __test//, 自动重命名 /歪曲/ 在 _A__test// 和 _B__test//, 因此，它们不会意外重新定义。 当您创建与C__开始的方法时，它意味着您不希望有人覆盖它，并且您将从您的类内部访问它。

在开始和结束时的两个underscores

:

当我们看到一种类似的方法时

__this__

, 不要打电话给它。 这是一种应该引起的方法 python, 而不是你。 让我们看看：

>>> name = "test string"

>>> name.__len__//

11

>>> len/name/

11



>>> number = 10

>>> number.__add__/40/

50

>>> number + 50

60

始终存在操作员或其自己的功能，导致这些魔法方法。 有时它只是一个钩子 python 在某些情况下呼叫。 例如，

__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

有关更多信息，请参阅
https://www.python.org/dev/pep ... ables
PEP-8 . 有关魔术方法的更多信息，请参阅

.

有时你有什么似乎是带领下划线的元组，如

def foo/bar/:

 return _/'my_' + bar/

在这种情况下，有些东西 _//- 它是本地化函数的假名，它适用于将其转换为适当的语言等。 locale. 例如，狮身人面像这样它，你会在进口中找到。

from sphinx.locale import l_, _

A B. sphinx.locale, _// 分配为假名某些本地化功能。

因为这么多人参考
https://www.youtube.com/watch% ... 33m8s
雷蒙德 , 通过写作他所说的话，我会更容易地做到这一点：

双重下划线的意图与私生活无关。 意图是这样用它

class Circle/object/:



 def __init__/self, radius/:

 self.radius = radius



 def area/self/:

 p = self.__perimeter//

 r = p / math.pi / 2.0

 return math.pi * r ** 2.0



 def perimeter/self/:

 return 2.0 * math.pi * self.radius



 __perimeter = perimeter # local reference





class Tire/Circle/:



 def perimeter/self/:

 return Circle.perimeter/self/ * 1.25

事实上，这与隐私相反，这就是自由。 这使您的子类免费覆盖任何一种方法而不扰乱他人。

.

假设您不存储本地链接

perimeter

在

Circle

. 现在派生类

Tire

覆盖实现

perimeter

, 不是Cascoo.

area

. 您打电话的时候

Tire/5/.area//

, 理论上，他仍然必须使用

Circle.perimeter

用于计算，但实际上它使用

Tire.perimeter

, 什么不是涉嫌的行为。 这就是为什么我们在圈子中需要本地参考。

但为什么

__perimeter

反而

_perimeter

? 因为

_perimeter

仍然给出了一个衍生类的覆盖：

class Tire/Circle/:



 def perimeter/self/:

 return Circle.perimeter/self/ * 1.25



 _perimeter = perimeter

Double Underlining的名称失真，因此在派生类中将覆盖父类中的本地参考的几乎没有机会。 因此， "

使您的子类免费覆盖任何一种方法而不打扰他人

".

如果您的课程未继承或重新定义该方法不会破坏任何东西，那么您只是不需要

__double_leading_underscore

.

Accroding 到
https://dbader.org/blog/meanin ... ython

单个初始下划线/_var/

: 命名协议，表明名称适用于内部使用。 通常不被翻译申请 Python /除了导入通配符标志/ 并且仅用于提示程序员。

单个下划线 Trailing/var_/

: 由协议使用以避免使用关键字的名称冲突 Python.

双重初始下划线/__var/

: 在类的上下文中使用时导致名称失真。 强制执行翻译 Python.

双重最初i. Trailing 强调/__var__/

: 表示语言定义的特殊方法 Python. 避免此命名方案进行您自己的属性。

单个下划线/_/

: 有时用作临时或次要变量的名称 /“我不在乎”/. 另外：最后表达的结果 a Python REPL.

如果你真的想制作一个可变的可访问读者，那么 IMHO 最好使用 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 问了一些不同的问题，但是因为我发现了另一个问题 "如何安装私有变量", 有重复标记为此，我考虑在此添加此附加信息。

出色的答案，它们都是真的。 我带来了一个简单的例子 definition/meaning.

价值：

some_variable - ► 它公开有人能看到它。

_some_variable --► 在一个公共场所，有人可以看到它，但这是指定自己的象征性......

警告

没有进行胁迫 Python.

__some_varaible --► Python 替换变量的名称 _classname__some_varaible /失真名称 AKA/, 它减少了/隐藏她的可见性，更像是私有变量。

只是说实话
https://docs.python.org/3/tuto ... ivate
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/

单一领先的下划线是常规正规。 从解释器的角度来看，没有区别，是否名称是从一个下划线开始的。

双极领导I. trailing 下划线用于嵌入方法，例如

__init__

,

__bool__

等等。

没有类似物的双领先的下划线 trailing 也是常规的，但是类方法将是
http://docs.python.org/tutoria ... ables
翻译。 对于基本功能的变量或名称，没有区别。

你的问题很好，它不仅涉及方法。 模块中的函数和对象通常具有一个下划线的前缀，也可以具有两个前缀。

但是名字 __double_underscore 例如，在模块中不扭曲。 从一个开始的名字会发生什么 /或几个/ 如果您导入所有模块，则不会导入下划线 /来自模块 import*/, 以及证书中显示的名称/模块/.

这是双重下划线属性如何影响可继承类的简单说明性示例。 因此，使用以下设置：

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'

对某些人来说可能是显而易见的，但它让我惊讶于更复杂的环境。

“Private” 变量实例，只能从对象内部访问它，不存在 Python. 但是，大多数代码遵循的协议 Python: 下划线前缀的名称 /例如， _spam/ 应该被视为失业部分 API /是否是函数，方法或数据元素/. 它应该被视为实施的细节，可以在恕不另行通知进行更改。

关联
https://docs.python.org/2/tuto ... ences

得到事实 _ 和 __ 相当容易; 其他答案表达它们很好。 使用它更难以确定。

这就是我看到它的方式：

_

应该用来表示该功能不适用于公共使用，例如， API. 这和进口的限制使他的行为非常相似

internal

在 c#.

__

应该用来避免名字的碰撞 hirarchy inheritace 并避免结束结束。 非常类似于privat c#. 年

==>

如果你想表明某些东西不适合公共使用，但它应该表现得像

protected

, 使用

_

.
如果你想指出某些东西不适合公共使用，但它应该充当

private

, 使用

__

.

这也是我真正喜欢的报价：

问题是，班级的作者可以在法律上思考 "这是
属性名称/该方法必须关闭，只能休息
这个类定义", 并使用协议 __private. 但后来 ... ,
此类的用户可以创建一个合法需要的子类
访问此名称。 所以应该改变超类
/什么是困难或不可能的/, 或子类代码应该
使用手动扭曲的名称 /这是最好和脆弱的/.

但是这个问题在于，在我看来，如果没有 IDE, 它警告您当您覆盖方法时，如果您不在基类中不小心过分的方法，则错误搜索可能需要一些时间。