python（57）：私有变量，代码块

转载：http://blog.csdn.net/zhu_liangwei/article/details/7667745

引子

我热情地邀请大家猜测下面这段程序的输出：

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

 

 

Python类中双下划线的私有成员(私有函数,私有变量)

一、Python中默认的成员函数、成员变量都是公开的(public)，而且python中没有类似public、private等关键词来修饰成员函数，成员变量。

在python中定义私有变量只需要在变量名或函数名前加上 "__" (两个下划线)，那么这个函数或变量就会成为私有的了。

在内部，python使用一种 name mangling 技术，将__membername替换成 _classname__membername，所以你在外部使用原来的私有成员的名字时，会提示找不到。
命名混淆意在给出一个在类中定义"私有"实例变量和方法的简单途径，避免派生类的实例变量定义产生问题，或者与外界代码中的变量搞混。
要注意的是混淆规则主要目的在于避免意外错误，被认作为私有的变量仍然有可能被访问或修改(使用_classname__membername)，在特定的场合它也是有用的，比如调试的时候。
【示例代码】

# -*- coding: utf-8 -*-

class Test(object):
 def __init__(self):
  super(Test, self).__init__()
  self.__member = 99
 
 def __method(self):
  print "Test.__method"

if __name__ == '__main__':
 t = Test()
 
 print dir(t)
 
 #t.__method()    # AttributeError: 'Test' object has no attribute '__method'
 #print t.__member   # AttributeError: 'Test' object has no attribute '__member'
 
 t._Test__method()   # 使用Python更改之后的函数名依然可以访问到"私有"函数
 print t._Test__member  # 使用Python更改之后的变量名依然可以访问到"私有"变量

'''
['_Test__member', '_Test__method', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
Test.__method
99
'''
可以看到在dir里面多的不是__member和__method，而是_Test__member和_Test__method。并且可以通过_Test__member和_Test__method访问原来类里面的成员变量和成员函数。

二、单下划线开头的成员变量和成员函数，其实就是public的，不等同于protected属性。

【示例代码】

# -*- coding: utf-8 -*-

class Test(object):
 def __init__(self):
  super(Test, self).__init__()
  self.__member = 88
  self._member = 99
 
 def __method(self):
  print "Test.__method"
 
 def _method(self):
  print "Test._method"

class TestDerived(Test):
 def __init__(self):
  super(TestDerived, self).__init__()
 
 def test(self):
  #print self.__member  # AttributeError: 'TestDerived' object has no attribute '_TestDerived__member'
  #self.__method()   # AttributeError: 'TestDerived' object has no attribute '_TestDerived__method'
  
  print self._member
  self._method()

if __name__ == '__main__':
 td = TestDerived()
 print dir(td)
 
 td.test()
 
 #print td.__member    # AttributeError: 'TestDerived' object has no attribute '__member'
 #td.__method()     # AttributeError: 'TestDerived' object has no attribute '__method'
 
 print td._member    # 外部可以直接访问单下划线开头的成员变量
 td._method()     # 外部可以直接访问单下划线开头的成员函数

'''
['_Test__member', '_Test__method', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_member','_method', 'test']
99
Test._method
99
Test._method
'''

无论是单下划线还是双下划线开头的成员，都是希望外部程序开发者不要直接使用这些成员变量和这些成员函数，只是双下划线从语法上能够更直接的避免错误的使用，但是如果按照 _类名__成员名 则依然可以访问到。单下划线的在动态调试时可能会方便一些，只要项目组的人都遵守下划线开头的成员不直接使用，那使用单下划线或许会更好。

所有的 Python 模块都是对象并且有几个有用的属性。 您可以使用这些属性方便地测试您所书写的模块。 下面是一个使用 if __name__ 的技巧。
if __name__ == "__main__":
在继续学习新东西之前, 有几点重要的观察结果。 首先, if 表达式无需使用圆括号括起来。 其次, if 语句以冒号结束, 随后跟随的是 缩进代码。
与 C 一样, Python 使用 == 做比较, 使用 = 做赋值。 与 C 不一样, Python 不支持行内赋值, 所以不会出现想要进行比较却意外地出现赋值的情况。
那么为什么说这个特殊的 if 语句是一个技巧呢？模块是对象, 并且所有的模块都有一个内置属性 __name__。一个模块的 __name__ 的值要看您如何应用模块。如果 import 模块, 那么 __name__的值通常为模块的文件名, 不带路径或者文件扩展名。但是您也可以像一个标准的程序一样直接运行模块, 在这种情况下 __name__的值将是一个特别的缺省值, __main__。

>>> import odbchelper
>>> odbchelper.__name__
'odbchelper'

一旦了解到这一点, 您可以在模块内部为您的模块设计一个测试套件, 在其中加入这个 if 语句。当您直接运行模块, __name__ 的值是 __main__, 所以测试套件执行。当您导入模块, __name__的值就是别的东西了, 所以测试套件被忽略。这样使得在将新的模块集成到一个大程序之前开发和调试容易多了.
在 MacPython 上, 需要一个额外的步聚来使得 if __name__ 技巧有效。 点击窗口右上角的黑色三角, 弹出模块的属性菜单, 确认 Run as __main__ 被选中。