云顶娱乐平台:浅谈python 里面的单下划线与双下划线的区别,浅谈python

python中的protected和private

python中用

_var
;变量名前一个下划线来定义,此变量为保护成员protected,只有类及其子类可以访问。此变量不能通过from
XXX import xxx 导入

__var;变量名前两个下划线来定义,此变量为私有private,只允许类本身访问,连子类都不可以访问。

 

class perent_class(object):
    def __init__(self,name,protected,private):
        self.name = name
        self._protected = protected
        self.__private = private

 

Linux and
python学习交流1,2群已满.

Linux and
python学习交流3群新开,欢迎加入,一起学习.qq 3群:563227894

不前进,不倒退,停止的状态是没有的.

一起进步,与君共勉,

 

在这里强调说一下私有变量,python默认的成员函数和成员变量都是公开的,没有像其他类似语言的public,private等关键字修饰.但是可以在变量前面加上两个下划线”_”,这样的话函数或变量就变成私有的.这是python的私有变量轧压(这个翻译好拗口),英文是(private
name mangling.)
**情况就是当变量被标记为私有后,在变量的前端插入类名,再类名前添加一个下划线”_”,即形成了_ClassName__变量名.**

浅谈python 里面的单下划线与双下划线的区别,浅谈python

在学习Python的时候,很多人都不理解为什么在方法(method)前面会加好几个下划线,有时甚至两边都会加,比如像
__this__
这种。在我看到上面的文章之前,我一直以为Python中这些下划线的作用就像Golang中方法/函数的大小写一样,或是一些其他语言中的
private 、 public
的作用一样,但仔细深究,这不全是Python这样设计的初衷。下面我们具体分析。

主要存在四种命名

  1. object # 公用方法
  2. __object__ # 内建方法,用户不要这样定义
  3. __object # 全私有,全保护
  4. _object # 半保护

核心风格:避免用下划线作为变量名的开始。

因为下划线对解释器有特殊的意义,而且是内建标识符所使用的符号,我们建议程序员避免用下划线作为变量名的开始。一般来讲,变量名_object被看作是“私有的”,在模块或类外不可以使用,不能用’from
module import
*’导入。当变量是私有的时候,用_object来表示变量是很好的习惯。

单下划线+类名,eg:_Class__object
机制就可以访问__object__了。因为变量名__object__对Python
来说有特殊含义,对于普通的变量应当避免这种命名风格。

“单下划线”
开始的成员变量叫做保护变量,意思是只有类对象和子类对象自己能访问到这些变量;”双下划线”
开始的是私有成员,意思是只有类对象自己能访问,连子类对象也不能访问到这个数据。(如下列所示)

以单下划线开头_foo的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用“from
xxx import
*”而导入;以双下划线开头的__foo代表类的私有成员;以双下划线开头和结尾的__foo__代表python里特殊方法专用的标识,如
__init__()代表类的构造函数。

class Foo():
  def __init__():
    ...

  def public_method():
    print 'This is public method'

  def __fullprivate_method():
    print 'This is fullprivate_method'

  def _halfprivate_method():
    print 'This is halfprivate_method'

  f = Foo()
  f.public_method() # OK
  f.__fullprivate_method() # Error occur
  f._halfprivate_method() # OK
  f._Foo__fullprivate_method() # OK

从上面的例子可以看出,f._halfprivate_method()可以直接访问,确实是。不过根据python的约定,应该将其视作private,而不要在外部使用它们,(如果你非要使用也没辙),良好的编程习惯是不要在外部使用它。同时,根据Python
docs的说明,_object和__object的作用域限制在本模块内。

大家看下面这段程序的输出:

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和类B的属性都有哪些:

>>> print 'n'.join(dir(A))
_A__private
__init__
public

>>> print 'n'.join(dir(B))
_A__private
_B__private
__init__
public

为什么类A有个名为_A__private的
属性呢?而且__private消失了!这就要谈谈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()”吧!

矫直之后,类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 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()  # 调用一个没有定义的函数,但可执行 
    self.public()
  def __private(self):
    print 'A.__private()'
  def public(self):
    print 'A.public()'

a = A()
答案:
A.__private()
A.public()

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持帮客之家。

里面的单下划线与双下划线的区别,浅谈python
在学习Python的时候,很多人都不理解为什么在方法(method)前面会加好几个下划线…

python 中变量的命名规范,python变量

出自: 
模块名: 
小写字母,单词之间用_分割 
ad_stats.py 

包名: 
和模块名一样 

类名: 
云顶娱乐平台:浅谈python 里面的单下划线与双下划线的区别,浅谈python。单词首字母大写 
AdStats 
ConfigUtil 

全局变量名(类变量,在java中相当于static变量): 
大写字母,单词之间用_分割 
NUMBER 
COLOR_WRITE 

普通变量: 
小写字母,单词之间用_分割 
this_is_a_var 

实例变量: 
以_开头,其他和普通变量一样 
_price    
_instance_var 

私有实例变量(外部访问会报错): 
以__开头(2个下划线),其他和普通变量一样 
__private_var 

专有变量: 
__开头,__结尾,一般为python的自有变量,不要以这种方式命名 
__doc__ 
__class__ 

普通函数: 
和普通变量一样: 
get_name() 
count_number() 
ad_stat() 

私有函数(外部访问会报错): 
以__开头(2个下划线),其他和普通函数一样 
__get_name() 
————————————————————————————————————————————————————————————————————
文件名 
全小写,可使用下划线 
包 
应该是简短的、小写的名字。如果下划线可以改善可读性可以加入。如mypackage。 
模块 
与包的规范同。如mymodule。 
类 
总是使用首字母大写单词串。如MyClass。内部类可以使用额外的前导下划线。 

函数&方法 
函数名应该为小写,可以用下划线风格单词以增加可读性。如:myfunction,my_example_function。 
*注意*:混合大小写仅被允许用于这种风格已经占据优势的时候,以便保持向后兼容。 
函数和方法的参数 
总使用“self”作为实例方法的第一个参数。总使用“cls”作为类方法的第一个参数。 
如果一个函数的参数名称和保留的关键字冲突,通常使用一个后缀下划线好于使用缩写或奇怪的拼写。 
全局变量 
对于from M import
*导入语句,如果想阻止导入模块内的全局变量可以使用旧有的规范,在全局变量上加一个前导的下划线。 
*注意*:应避免使用全局变量 
变量 
变量名全部小写,由下划线连接各个单词。如color =
WHITE,this_is_a_variable = 1 
*注意*: 
1.不论是类成员变量还是全局变量,均不使用 m 或 g 前缀。 
2.私有类成员使用单一下划线前缀标识,多定义公开成员,少定义私有成员。 
3.变量名不应带有类型信息,因为Python是动态类型语言。如
iValue、names_list、dict_obj 等都是不好的命名。 
常量 
常量名所有字母大写,由下划线连接各个单词如MAX_OVERFLOW,TOTAL。 
异常 
以“Error”作为后缀。 
缩写 
命名应当尽量使用全拼写的单词,缩写的情况有如下两种: 
1.常用的缩写,如XML、ID等,在命名时也应只大写首字母,如XmlParser。 
2.命名中含有长单词,对某个单词进行缩写。这时应使用约定成俗的缩写方式。 
例如: 
function 缩写为 fn 
text 缩写为 txt 
object 缩写为 obj 
count 缩写为 cnt 
number 缩写为 num,等。 
前导后缀下划线 
一个前导下划线:表示非公有。 
一个后缀下划线:避免关键字冲突。 
两个前导下划线:当命名一个类属性引起名称冲突时使用。 
两个前导和后缀下划线:“魔”(有特殊用途)对象或者属性,例如__init__或者__file__。绝对不要创造这样的名字,而只是使用它们。 
*注意*:关于下划线的使用存在一些争议。 
Python 用下划线作为变量前缀和后缀指定特殊变量。 

_xxx      不能用’from module import *’导入 
__xxx__ 系统定义名字 
__xxx    类中的私有变量名 

核心风格:避免用下划线作为变量名的开始。 

因为下划线对解释器有特殊的意义,而且是内建标识符所使用的符号,我们建议程序员避免用下划线作为变量名的开始。一般来讲,变量名_xxx被看作是“私有的”,在模块或类外不可以使用。当变量是私有的时候,用_xxx
来表示变量是很好的习惯。因为变量名__xxx__对Python
来说刑厥夂澹杂谄胀ǖ谋淞坑Φ北苊庹庵置绺瘛?br> 
“单下划线”
开始的成员变量叫做保护变量,意思是只有类对象和子类对象自己能访问到这些变量; 
“双下划线”
开始的是私有成员,意思是只有类对象自己能访问,连子类对象也不能访问到这个数据。 

以单下划线开头(_foo)的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用“from
xxx import
*”而导入;以双下划线开头的(__foo)代表类的私有成员;以双下划线开头和结尾的(__foo__)代表python里特殊方法专用的标识,如
__init__()代表类的构造函数。 
特定命名方式 
主要是指 __xxx__
形式的系统保留字命名法。项目中也可以使用这种命名,它的意义在于这种形式的变量是只读的,这种形式的类成员函数尽量不要重载。如 
class Base(object): 
def __init__(self, id, parent = None): 
self.__id__ = id 
self.__parent__ = parent 
def __message__(self, msgid): 
# …略 
其中 __id__、__parent__ 和 __message__
都采用了系统保留字命名法。 
附:Google Python命名规范 
module_name, package_name, ClassName, method_name, ExceptionName,
function_name, GLOBAL_VAR_NAME, instance_var_name,
function_parameter_name, local_var_name. 
————————————————————————————————————————————————————————
from: 
理解Python命名机制 

引子 
我热情地邀请大家猜测下面这段程序的输出: 
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变量
出自:
模块名: 小写字母,单词之间用_分割 ad_stats….

Python内置类属性

__dict__ : 类的属性(包含一个字典,由类的数据属性组成)

['hello', 'python']
['hello', 'python']
class A:
    def hello(self):
        print('Hello,i am A.')
class B(A):
    def hello(self):  
        print('Hello,i am B.')
a = A()
b = B()
a.hello()
b.hello()

结果:

一、 类的重写

结果:

1、调用未绑定的基类构造方法

例子1:

__bases__ : 类的所有父类构成元素(包含了一个由所有父类组成的元组)

B类没有定义自己的hello方法,故当hello被调用时,原始信息就被打印出来了。

解释:

class Bird():
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print('Aaaah...')
            self.hungry = False
        else:
            print('No,thanks!')
class SongBird(Bird):
    def __init__(self):
        super(SongBird,self).__init__()
        self.sound = 'Squawk!'
    def sing(self):
        print(self.sound)
b = SongBird()
b.sing()
b.eat()
b.eat()
Squawk!
Aaaah...
No,thanks!

二、类的私有变量

Hello,i am A.
Hello,i am A.

特殊变量命名

class A:
    def hello(self):
        print('Hello,i am A.')
class B(A):
    pass
a = A()
b = B()
a.hello()
b.hello()

__doc__ :类的文档字符串

1.1 重写一般方法

class A():
    def __init__(self):
        self.__name = 'python'  # 私有变量,翻译成 self._A__name='python'

    def __say(self):  # 私有方法,翻译成 def _A__say(self)
        print self.__name  # 翻译成 self._A__name


a = A()
# print a.__name #访问私有属性,报错!AttributeError: A instance has no attribute '__name'
print a.__dict__  # 查询出实例a的属性的集合
print a._A__name  # 这样,就可以访问私有变量了
# a.__say()#调用私有方法,报错。AttributeError: A instance has no attribute '__say'
print dir(a)  # 获取实例的所有属性和方法
a._A__say()  # 这样,就可以调用私有方法了

结果:

Python
2中定义类需要写上object,否则报错。

3、
__xx__定义的是特殊方法。用户控制的命名空间内的变量或是属性,如init ,
__import__或是file 。只有当文档有说明时使用,不要自己定义这类变量。
(就是说这些是python内部定义的变量名)

2、使用super函数

1、 _xx
以单下划线开头的表示的是protected类型的变量。即保护类型只能允许其本身与子类进行访问。若内部变量标示,如:
当使用“from M import”时,不会将以一个下划线开头的对象引入 。

结果:

结果:

2、 __xx
双下划线的表示的是私有类型的变量。只能允许这个类本身进行访问了,连子类也不可以用于命名一个类属性(类变量),调用时名字被改变(在类FooBar内部,__boo变成_FooBar__boo,如self._FooBar__boo)

Hello,i am A.
Hello,i am B.
Squawk!
Aaaah...
No,thanks!

1.2 重写特殊的构造方法

class A(object):
    def __init__(self):
        self.__data = []  # 翻译成 self._A__data=[]

    def add(self, item):
        self.__data.append(item)  # 翻译成 self._A__data.append(item)

    def printData(self):
        print self.__data  # 翻译成 self._A__data


a = A()
a.add('hello')
a.add('python')
a.printData()
# print a.__data  #外界不能访问私有变量 AttributeError: 'A' object has no attribute '__data'
print a._A__data  # 通过这种方式,在外面也能够访问“私有”变量;这一点在调试中是比较有用的!

例子2:

B类也可以重写这个hello方法

__module__:
类定义所在的模块(类的全名是’__main__.className’,如果类位于一个导入模块mymod中,那么className.__module__
等于 mymod)

在Python中可以通过在属性变量名前加上双下划线定义属性为私有属性

结果:

{'_A__name': 'python'}
python
['_A__name', '_A__say', '__doc__', '__init__', '__module__']
python

四周二次课(11月7日)

解释:

class Bird:
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print('Aaaah...')
            self.hungry = False
        else:
            print('No,thanks!')
class SongBird(Bird):
    def __init__(self):
            Bird.__init__(self)
            self.sound = 'Squawk!'
    def sing(self):
        print(self.sound)
b = SongBird()
b.sing()
b.eat()
b.eat()