##1.html代码
 
<abbr style="border-bottom: 1px dotted #000; ">文本</abbr><br/>
<abbr style="border-bottom: 1px dotted #000; ">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</abbr>
 
##2.显示
 

Python语言学习之双下划线那些事：python和双下划线使用方法之详细攻略
 
 
 
 
 
 
 
 
 
目录
 
双下划线介绍
 
1、关于双下划线的函数或方法或属性
 

 
 
 
 
 
 
 
 
双下划线介绍
 
1、关于双下划线的函数或方法或属性
 
__name__：前后加了双下划线是因为是因为这是系统定义的名字。普通变量不要使用此方式命名变量。
 (1)、__name__这个系统变量显示了当前模块执行过程中的名称。如果模块是被直接执行，__name__的值为’__main__’；如果模块是被导入，__name__得到的值为被导入的模块名字。
 再次理解：如果当前程序运行在这个模块中，__name__ 的名称就是__main__如果不是，则为这个模块的名称。  
 (2)、__main__一般作为函数的入口，类似于C语言，尤其在大型工程中，常常有if __name__ == "__main__":来表明整个工程开始运行的入口。
 
#test__name__.py文件内的函数
def HaveFun():
    if __name__ == '__main__':
        print('(test__name__.py),I am in my domainmy name is %s' % __name__)
    else:
        print('(???.py),Someone else calls me!,my name is %s' % __name__)
HaveFun()

#其他py文件内执行命令
import test__name__

test__name__.HaveFun()
 
 
 
 
 
 
 

 python 单下划线/双下划线使用总结
 
 
 时间:2013-10-08 10:56
 来源:www.chengxuyuans.com
 
 
 

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

python 单下划线跟双下划线使用