比较来自世界各地的卖家的域名和 IT 服务价格

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

任何人都可以解释在对象名称之前领先强调的存在的确切值 Python 他们之间的区别?

此外,无论是否考虑的对象是可变的,功能,方法等,此值都保持不变。
已邀请:

窦买办

赞同来自:

一个下的下划线

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

引用
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 找不到,因为由于名称的混乱,它不再存在


&gt;&gt;&gt; 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, 它警告您当您覆盖方法时,如果您不在基类中不小心过分的方法,则错误搜索可能需要一些时间。

要回复问题请先登录注册