python 单下划线/双下划线使用总结

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

主要存在四种情形 
1.    1. object # public 
    2. __object__ # special, python system use, user should not define like it 
    3. __object # private (name mangling during runtime) 
    4. _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__（）代表类的构造函数。 

1.class foo(): 

2.    def __init__(): 
3.        ... 
4.    
5.    def public_method(): 
6.        print 'this is public method' 
7. 
8.    def __fullprivate_method(): 
9.        print 'this is double underscore leading method' 
10. 
11.    def _halfprivate_method(): 
12.        print 'this is one underscore leading method' 
实例化foo的一个对象， 

1.    f = foo() 
1.    f.public_method() # ok 
2. 
3.    f.__fullprivate_method() # error occur 
4. 
5.    f._halfprivate_method() # ok 
6. 
7.    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()

v8.3Shop7z网上购物系统时尚版

Shop7z商城系统时尚版支持支付宝、微信支付等多种常用接口，电脑版与手机版与APP无缝结合数据一体!支持图片批量上传，一次性可上传任意张图片，支持多种在线支付接口，如支付宝、网银在线、财付通等接口，支持多级商品分类划分功能，可以方便的划分各商品类别的上下级关系，支持新订单邮件自动通知功能，支持单商品多分类展示功能，订单方面设计完美，如支持订单模糊查询、订单状态的编辑及打印等功能，灵活的导航可以设

691

查看详情