python 单下划线及双下划线使用方法

Python下划线命名模式 - 小结

以下是一个简短的小结，即“速查表”，罗列了我在本文中谈到的五种Python下划线模式的含义：

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

Python 用下划线作为变量前缀和后缀指定特殊变量/方法。

主要存在四种情形

object # public
__object__ # special, python system use, user should not define like it
__object # private (name mangling during runtime)
 _object # obey python coding convention, consider it as private
核心风格：避免用下划线作为变量名的开始。

     因为下划线对解释器有特殊的意义，而且是内建标识符所使用的符号，我们建议程序员避免用下划线作为变量名的开始。一般来讲，变量名_object被看作是“私有 的”，在模块或类外不可以使用，不能用'from moduleimport *'导入。当变量是私有的时候，用_object来表示变量是很好的习惯。因为变量名__object__对Python 来说有特殊含义，对于普通的变量应当避免这种命名风格。

     python有关private的描述，python中不存在protected的概念，要么是public要么就是private，但是python中的private不像C++, Java那样，它并不是真正意义上的private，通过name mangling（名称改编(目的就是以防子类意外重写基类的方法或者属性)，即前面加上“单下划线”+类名,eg：_Class__object）机制就可以访问private了。

     "单下划线" 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；"双下划线" 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。(如下列所示)
     以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用“from xxx import *”而导入；以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如 __init__（）代表类的构造函数。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

class Foo():
    def __init__():
        ...
    def public_method():
        print 'This is public method'
 
    def __fullprivate_method():
        print 'This is double underscore leading method'
 
    def _halfprivate_method():
        print 'This is one underscore leading method'

实例化Foo的一个对象，

f = Foo()
f.public_method() # OK
 
f.__fullprivate_method() # Error occur
 
f._halfprivate_method() # OK
 
f._Foo__fullprivate()_method() # OK

    从上面的例子可以看出，f._halfprivate_method()可以直接访问，确实是。不过根据python的约定，应该将其视作private，而不要在外部使用它们，（如果你非要使用也没辙），良好的编程习惯是不要在外部使用它。同时，根据Python docs的说明，_object和__object的作用域限制在本模块内。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------
理解Python命名机制（单双下划线开头）  (转载：http://blog.csdn.net/lanphaday) 
引子 
我热情地邀请大家猜测下面这段程序的输出：
class A(object):
       def __init__(self):
              self.__private()
              self.public()
       def __private(self):
              print 'A.__private()'
       def public(self):
              print 'A.public()'
class B(A):
       def __private(self):
              print 'B.__private()'
       def public(self):
              print 'B.public()'
b = B()
初探 
正确的答案是：
A.__private()
B.public()
如果您已经猜对了，那么可以不看我这篇博文了。如果你没有猜对或者心里有所疑问，那我的这篇博文正是为您所准备的。
一切由为什么会输出“A.__private()”开始。但要讲清楚为什么，我们就有必要了解一下Python的命名机制。
据 Python manual，变量名（标识符）是Python的一种原子元素。当变量名被绑定到一个对象的时候，变量名就指代这个对象，就像人类社会一样，不是吗？当变 量名出现在代码块中，那它就是本地变量；当变量名出现在模块中，它就是全局变量。模块相信大家都有很好的理解，但代码块可能让人费解些。在这里解释一下：
代码块就是可作为可执行单元的一段Python程序文本；模块、函数体和类定义都是代码块。不仅如此，每一个交互脚本命令也是一个代码块；一个脚本文件也是一个代码块；一个命令行脚本也是一个代码块。
接下来谈谈变量的可见性，我们引入一个范围的概念。范围就是变量名在代码块的可见性。 如果一个代码块里定义本地变量，那范围就包括这个代码块。如果变量定义在一个功能代码块里，那范围就扩展到这个功能块里的任一代码块，除非其中定义了同名 的另一变量。但定义在类中的变量的范围被限定在类代码块，而不会扩展到方法代码块中。
迷踪 
据上节的理论，我们可以把代码分为三个代码块：类A的定义、类B的定义和变量b的定义。根据类定义，我们知道代码给类A定义了三个成员变量（Python的函数也是对象，所以成员方法称为成员变量也行得通。）；类B定义了两个成员变量。这可以通过以下代码验证：
>>> print '\n'.join(dir(A))
_A__private
__init__
public
>>> print '\n'.join(dir(B))
_A__private
_B__private
__init__
public
咦，为什么类A有个名为_A__private的 Attribute 呢？而且__private消失了！这就要谈谈Python的私有变量轧压了。
探究 
懂Python的朋友都知道Python把以两个或以上下划线字符开头且没有以两个或以上下划线结尾的变量当作私有变量。私有变量会在代码生成之前被转换为长格式（变为公有）。转换机制是这样的：在变量前端插入类名，再在前端加入一个下划线字符。这就是所谓的私有变量轧压（Private name mangling）。如类 A里的__private标识符将被转换为_A__private，这就是上一节出现_A__private和__private消失的原因了。

再讲两点题外话：
一是因为轧压会使标识符变长，当超过255的时候，Python会切断，要注意因此引起的命名冲突。
二是当类名全部以下划线命名的时候，Python就不再执行轧压。如：
>>> class ____(object):
       def __init__(self):
              self.__method()
       def __method(self):
              print '____.__method()'
>>> print '\n'.join(dir(____))
__class__
__delattr__
__dict__
__doc__
__getattribute__
__hash__
__init__
__method              # 没被轧压
__module__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__str__
__weakref__
>>> obj = ____()
____.__method()
>>> obj.__method()      # 可以外部调用
____.__method()
现在我们回过头来看看为什么会输出“A.__private()”吧！
真相 
相信现在聪明的读者已经猜到答案了吧？如果你还没有想到，我给你个提示：真相跟C语言里的宏预处理差不多。
因为类A定义了一个私有成员函数（变量），所以在代码生成之前先执行私有变量轧压（注意到上一节标红的那行字没有？）。轧压之后，类A的代码就变成这样了：
class A(object):
       def __init__(self):
              self._A__private()          # 这行变了
              self.public()
       def _A__private(self):           # 这行也变了
              print 'A.__private()'
       def public(self):
              print 'A.public()'
是不是有点像C语言里的宏展开啊？
因为在类B定义的时候没有覆盖__init__方法，所以调用的仍然是A.__init__，即执行了self._A__private()，自然输出“A.__private()”了。
下面的两段代码可以增加说服力，增进理解：
>>> class C(A):
       def __init__(self):          # 重写 __init__ ，不再调用 self._A__private
              self.__private()       # 这里绑定的是 _C_private
              self.public()
       def __private(self):
              print 'C.__private()'
       def public(self):
              print 'C.public()'
>>> c = C()
C.__private()
C.public()
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
>>> class A(object):
       def __init__(self):
              self._A__private()   # 调用一个没有定义的函数， Python 会把它给我的 
              self.public()
       def __private(self):
              print 'A.__private()'
       def public(self):
              print 'A.public()'
>>>a = A()
A.__private()
A.public()
-----------------------------------------------------------------------------------------------------------------------------------------------------------------

特殊方法一览表
Model 一章列出了 83 个特殊方法的名字， 其中 47 个用于实现算术运算、 位运算和比较操作

1. 类的基础方法 

序号	目的	所编写代码	Python 实际调用
①	初始化一个实例	x = MyClass()	x.__init__()
②	字符串的 “官方” 表现形式	repr(x)	x.__repr__()
③	字符串的“非正式”值	str(x)	x.__str__()
④	字节数组的“非正式”值	bytes(x)	x.__bytes__()
⑤	格式化字符串的值	format(x, format_spec)	x.__format__(format_spec)

按照约定， repr() 方法所返回的字符串为合法的 Python 表达式
在调用 print(x) 的同时也调用了 str() 方法
2.迭代枚举

序号	目的	所编写代码	Python 实际调用
①	遍历某个序列	iter(seq)	seq.__iter__()
②	从迭代器中获取下一个值	next(seq)	seq.__next__()
③	按逆序创建一个迭代器	reversed(seq)	seq.__reversed__()

无论何时创建迭代器都将调用 iter() 方法。这是用初始值对迭代器进行初始化的绝佳之处。
无论何时从迭代器中获取下一个值都将调用 next() 方法。
__reversed__() 方法并不常用。它以一个现有序列为参数，并将该序列中所有元素从尾到头以逆序排列生成一个新的迭代器
3. 属性管理

序号	目的	所编写代码	Python 实际调用
①	获取一个计算属性（无条件的）	x.my_property	x.__getattribute__('my_property')
②	获取一个计算属性（后备）	x.my_property	x.__getattr__('my_property')
③	设置某属性	x.my_property = value	x.__setattr__('my_property',value)
④	删除某属性	del x.my_property	x.__delattr__('my_property')
⑤	列出所有属性和方法	dir(x)	x.__dir__()

如果某个类定义了 __getattribute__() 方法，在 每次引用属性或方法名称时 Python 都调用它（特殊方法名称除外，因为那样将会导致讨厌的无限循环）。
如果某个类定义了 __getattr__() 方法，Python 将只在正常的位置查询属性时才会调用它。如果实例 x 定义了属性color， x.color 将 不会 调用 x.__getattr__('color')；而只会返回x.color 已定义好的值
无论何时给属性赋值，都会调用 __setattr__()方法
无论何时删除一个属性，都将调用__delattr__()方法
如果定义了 __getattr__() 或 __getattribute__() 方法， __dir__() 方法将非常有用。通常，调用 dir(x)将只显示正常的属性和方法。如果__getattr()__方法动态处理 color 属性， dir(x) 将不会将 color 列为可用属性。可通过覆盖 __dir__() 方法允许将 color 列为可用属性，对于想使用你的类但却不想深入其内部的人来说，该方法非常有益
4. 可序列化的类

Python 支持 任意对象的序列化和反序列化。（多数 Python 参考资料称该过程为 pickling 和 unpickling）。该技术对与将状态保存为文件并在稍后恢复它非常有意义。所有的 内置数据类型 均已支持 pickling 。如果创建了自定义类，且希望它能够 pickle，阅读 pickle 协议 了解下列特殊方法何时以及如何被调用

序号	目的	所编写代码	Python 实际调用
①	自定义对象的复制	copy.copy(x)	x.__copy__()
②	自定义对象的深度复制	copy.deepcopy(x)	x.__deepcopy__()
③	在 pickling 之前获取对象的状态	pickle.dump(x, file)	x.__getstate__()
④	序列化某对象	pickle.dump(x, file)	x.__reduce__()
⑤	序列化某对象（新 pickling 协议）	pickle.dump(x, file, protocol_version)	x.__reduce_ex__(protocol_version)
⑥	控制 unpickling 过程中对象的创建方式	x = pickle.load(file)	x.__getnewargs__()
⑦	在 unpickling 之后还原对象的状态	x = pickle.load(file)	x.__setstate__()

要重建序列化对象，Python 需要创建一个和被序列化的对象看起来一样的新对象，然后设置新对象的所有属性。__getnewargs__() 方法控制新对象的创建过程，而 __setstate__() 方法控制属性值的还原方式

总结
单下划线 (_)

1、在 CPython 等解释器中代表交互式解释器会话中上一条执行的语句的结果

2、作为临时性的名称使用，分配了一个特定的名称但是在后面不会用到该名称

3、用于实现国际化和本地化字符串之间翻译查找的函数名称(遵循相应的C约定)

4、名称前的单下划线，用于指定该名称属性为 私有，这并不是语法规定而是惯例，在使用这些代码时将大家会知道以 _ 开头的名称只供内部使用，在 from <Package> import * 时，以 _ 开头的名称都不会被导入，除非模块或包中的 __all__ 列表显式地包含了它们

双下划线 (__)

1、名称（具体为一个方法名）前双下划线（__）的用法并不是一种惯例，对解释器来说它有特定的意义。Python 中的这种用法是为了避免与子类定义的名称冲突。Python文档指出，__spam 这种形式（至少两个前导下划线，最多一个后续下划线）的任何标识符将会被 _classname__spam 这种形式原文取代，在这里 classname 是去掉前导下划线的当前类名

2、名称前后的双下划线表示 Python 中特殊的方法名。这只是一种惯例，对 Python 来说，这将确保不会与用户自定义的名称冲突。通常，程序员会重写这些方法，并在里面实现所需要的功能，以便Python 调用