python中的下划线（私有变量）

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__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__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'

　　如果输入：

　　b._A__private()

　　结果如下:

　　A.__private()
　　也就是说私有变量 __foo 经过mangle成为 _ClassName__foo 后继承给了子类。
　　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(dir(____))  # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__method', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__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()')

因为在类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()

运行结果：

python中的下划线（私有变量）

猜你喜欢