python下划线，私有变量

 

转自：http://blog.sina.com.cn/s/blog_58649eb30100g4zo.html

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

"单下划线" 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；不能用“from xxx import *”而导入；
"双下划线" 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。
以双下划线开头和结尾的代表python里特殊方法专用的标识，如 __init__（）代表类的构造函数。
核心风格：避免用下划线作为变量名的开始。
因为下划线对解释器有特殊的意义，而且是内建标识符所使用的符号，建议避免用下划线作为变量名的开始。

观察下面这段程序的输出：

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()
为什么会有上述输出呢？
我们先看一个小测试：

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

print dir(A)

运行结果：
['_A__private', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__', 'public']
可以看到，类A有个名为_A__private的 Attribute，而且__private消失了！这就要谈谈Python的私有变量轧压了。
如果我们输入：
b.__private()
得到的将是：
AttributeError: 'B' object has no attribute '__private'
也就是说私有变量__foo经过mangle成为_ClassName__foo后继承给了子类。
Python把以两个下划线开头且没有以两个下划线结尾的变量当作私有变量。
私有变量会在代码生成之前被转换为长格式（变为公有）。
转换机制是这样的：在变量前端插入类名，再在前端加入一个下划线字符。这就是所谓的私有变量轧压（Private name mangling）。
如类A里的__private标识符将被转换为_A__private，这就是前面的小测试出现_A__private，而__private消失的原因了。
注意下面2点：
一是因为轧压会使标识符变长，当超过255的时候，Python会切断，要注意因此引起的命名冲突。
二是当类名全部以下划线命名的时候，Python就不再执行轧压。如：

class ____(object):
    def __init__(self):
        self.__method()
    def __method(self):
        print '____.__method()'

print '\n'.join(dir(____))
instance=____()
instance.__method()#外界可以调用私有方法（因为没有被轧压）

运行结果：
__class__
__delattr__
__dict__
__doc__
__format__
__getattribute__
__hash__
__init__
__method  #没有被轧压
__module__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__sizeof__
__str__
__subclasshook__
__weakref__
____.__method()
____.__method()
现在我们回过头来看看文章开头为什么会输出“A.__private()”吧！这跟C语言里的宏预处理差不多。
因为类A定义了一个私有成员函数（变量），所以在代码生成之前先执行私有变量轧压。轧压之后，类A的代码就变成这样了：

class A(object):
       def __init__(self):
              self.<span style="color:#ff0000;">_A__private()</span>        # 这行变了
              self.public()
       def <span style="color:#ff0000;">_A__private</span>(self):           # 这行也变了
              print 'A.__private()'
       def public(self):
              print 'A.public()'

是不是有点像C语言里的宏展开啊？
因为在类B定义的时候没有覆盖__init__方法，所以调用的仍然是A.__init__，即执行了self._A__private()，自然输出“A.__private()”了。
下面我们再看一个例子：

class A():
    def __init__(self):
        self.__private()
        self.public()
    def __private(self):
        print 'A.__private()'
    def public(self):
        print 'A.public()'
class C(A):
    def __init__(self): # 重写__init__
        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()#貌似在调用一个未定义的函数，别担心，轧压后该函数会出现的。
        self.public()
    def __private(self):#该方法会被轧压成_A__private
        print 'A.__private()'
    def public(self):
        print 'A.public()'  

print dir(A)#可以看到，轧压后，_A__private 方法出现了！
a=A()  

运行结果：
['_A__private', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__', 'public']
A.__private()
A.public()