xml地图|网站地图|网站标签 [设为首页] [加入收藏]

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

来源:http://www.ccidsi.com 作者:最新解决方案 人气:177 发布时间:2019-05-08
摘要:文件名 全小写,可使用下划线 python 中变量的命名标准,python变量 出自:  模块名:  小写字母,单词之间用_分割  ad_stats.py  包名:  和模块名相同  类名:  单词首字母大写  AdStat

文件名
全小写,可使用下划线

python 中变量的命名标准,python变量

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

包名: 
和模块名相同 

类名: 
单词首字母大写 
AdStats 
ConfigUtil 

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

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

实例变量: 
以_始发,其余和平凡变量一样 
_price    
_instance_var 

村办实例变量(外部访问会报错): 
以__开始(1个下划线),别的和经常变量一样 
__private_var 

专有变量: 
__开头,__最后,一般为python的自有变量,不要以那种方法命名 
__doc__ 
__class__ 

一般来说函数: 
和日常变量同样: 
get_name() 
count_number() 
ad_stat() 

村办函数(外部访问会报错): 
以__千帆竞发(3个下划线),其余和一般函数相同 
__get_name() 
————————————————————————————————————————————————————————————————————
文件名 
全小写,可利用下划线 
包 
相应是简约的、小写的名字。假若下划线能够立异可读性能够到场。如mypackage。 
模块 
与包的科班同。如mymodule。 
类 
接连利用首字母大写单词串。如MyClass。内部类能够选拔额外的指引下划线。 

函数&方法 
函数名应当为小写,能够用下划线风格单词以充实可读性。如:myfunction,my_example_function。 
*注意*:混合大小写仅被允许用于那种作风早已攻下优势的时候,以便保障向后非凡。 
函数和措施的参数 
总使用“self”作为实例方法的首先个参数。总使用“cls”作为类形式的率先个参数。 
只要2个函数的参数名称和保留的首要字争论,平日选用二个后缀下划线好于接纳缩写或意外的拼写。 
全局变量 
对于from M import *导入语句,假使想遏止导入模块内的全局变量可以利用旧有的规范,在全局变量上加三个初阶的下划线。 
*注意*:应幸免使用全局变量 
变量 
变量名全部大写,由下划线连接各种单词。如color = WHITE,this_is_a_variable = 1 
*注意*: 
1.不论是类成员变量依然全局变量,均不行使 m 或 g 前缀。 
二.私有类成员选用单一下划线前缀标志,多定义公开成员,少定义私有成员。 
三.变量名不应带有类型音讯,因为Python是动态类型语言。如 iValue、names_list、dict_obj 等都是糟糕的命名。 
常量 
常量名具备字母大写,由下划线连接各种单词如MAX_OVERFLOW,TOTAL。 
异常 
以“Error”作为后缀。 
缩写 
取名应当尽也许选用全拼写的单词,缩写的景观有如下二种: 
1.常用的缩写,如XML、ID等,在命名时也应只大写首字母,如XmlParser。 
二.命名中隐含长单词,对某些单词进行缩写。那时应利用约定成俗的缩写方式。 
例如: 
function 缩写为 fn 
text 缩写为 txt 
object 缩写为 obj 
count 缩写为 cnt 
number 缩写为 num,等。 
前导后缀下写道 
一个指路下划线:表示非公有。 
二个后缀下划线:防止主要字争持。 
多少个前导下划线:当命名3个类属性引起名称争辩时采纳。 
三个前导和后缀下划线:“魔”(有特出用途)对象大概性质,比方__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__ 都选取了系统一保险留字命名法。 
附:谷歌 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的1种原子成分。当变量名被绑定到贰个指标的时候,变量名就代替那些目的,就好像人类社会壹致,不是吧?当变 量名出现在代码块中,那它就是本地变量;当变量名出现在模块中,它正是全局变量。模块相信大家都有很好的知情,但代码块只怕令人费解些。在此间解释一下: 
代码块便是可看作可实行单元的一段Python程序文件;模块、函数体和类定义都以代码块。不只有如此,每种相互脚本命令也是二个代码块;三个本子文件也是3个代码块;二个发令行脚本也是1个代码块。 
接 下来切磋变量的可知性,大家引进3个范围的定义。范围正是变量名在代码块的可知性。假诺1个代码块里定义本地变量,那范围就蕴含这些代码块。假设变量定义 在二个效应代码块里,这范围就扩充到那些效用块里的任一代码块,除非当中定义了同名的另一变量。但定义在类中的变量的限定被界定在类代码块,而不会扩张到 方法代码块中。 

迷踪 
据上节的争鸣,大家能够把代码分为四个代码块:类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消失的因由了。 
再讲两点题外话: 
一是因为轧压会使标识符变长,当赶过25伍的时候,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 中变量的命名标准


应该是差不离的、小写的名字。借使下划线能够改进可读性可以参预。如mypackage。

模块名:

模块
与包的正规化同。如mymodule。

小写字母,单词之间用_分割


连天利用首字母大写单词串。如MyClass。内部类能够利用额外的引路下划线。

ad_stats.py

 

包名:

 

和模块名一样

函数&方法
函数名应当为小写,能够用下划线风格单词以追加可读性。如:myfunction,my_example_function。
*注意*:混合大小写仅被允许用于那种风格已经攻下优势的时候,以便保证向后杰出。

类名:

函数和措施的参数
总使用“self”作为实例方法的首先个参数。总使用“cls”作为类格局的率先个参数。
假使三个函数的参数名称和保留的要紧字争论,日常使用多个后缀下划线好于选择缩写或不测的拼写。

单词首字母大写

全局变量
对于from M import *导入语句,如若想拦截导入模块内的全局变量能够采用旧有的正式,在全局变量上加贰个指引的下划线。
*注意*:应幸免采纳全局变量

AdStats

变量
变量名全体大写,由下划线连接各种单词。如color = WHITE,this_is_a_variable = 1
*注意*:
一.不论是类成员变量仍然全局变量,均不选用 m 或 g 前缀。
2.私有类成员使用单一下划线前缀标记,多定义公开成员,少定义私有成员。
叁.变量名不应带有类型消息,因为Python是动态类型语言。如 iValue、names_list、dict_obj 等皆以倒霉的命名。

ConfigUtil

常量
常量名具备字母大写,由下划线连接各种单词如MAX_OVERFLOW,TOTAL。

全局变量名(类变量,在java中一定于static变量):

异常
以“Error”作为后缀。

大写字母,单词之间用_分割

缩写
取名应当尽恐怕使用全拼写的单词,缩写的状态有如下三种:
1.常用的缩写,如XML、ID等,在命名时也应只大写首字母,如XmlParser。
二.命名中涵盖长单词,对有些单词举办缩写。那时应利用约定成俗的缩写情势。
例如:
function 缩写为 fn
text 缩写为 txt
object 缩写为 obj
count 缩写为 cnt
number 缩写为 num,等。
前导后缀下写道
三个指点下划线:表示非公有。
3个后缀下划线:幸免重大字争论。
八个前导下划线:当命名三个类属性引起名称抵触时采纳。
三个前导和后缀下划线:“魔”(有分外用图)对象或许性质,举个例子__init__或者__file__。相对不用创制那样的名字,而只是使用它们。
*注意*:关于下划线的运用存在部分争执。

NUMBER

一定命名情势
重在是指 __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.

COLOR_WRITE

 

一般说来变量:

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

小写字母,单词之间用_分割

包名: 
和模块名一样 

this_is_a_var

类名: 
单词首字母大写 
AdStats 
ConfigUtil 

实例变量:

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

以_始发,别的和日常变量同样

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

_price

实例变量: 
以_始于,别的和常常变量同样 
_price    
_instance_var 

_instance_var

民用实例变量(外部访问会报错): 
以__起始(3个下划线),其余和一般变量同样 
__private_var 

民用实例变量(外部访问会报错):

专有变量: 
__开头,__最终,一般为python的自有变量,不要以那种艺术命名 
__doc__ 
__class__ 

以__发端(3个下划线),别的和平时变量相同

不以为奇函数: 
和常见变量同样: 
get_name() 
count_number() 
ad_stat() 

__private_var

个体函数(外部访问会报错): 
以__开头(1个下划线),别的和平时函数同样 
__get_name() 
————————————————————————————————————————————————————————————————————
文件名 
全小写,可采纳下划线 
包 
应当是简轻松单的、小写的名字。如若下划线能够革新可读性能够投入。如mypackage。 
模块 
与包的正统同。如mymodule。 
类 
连接利用首字母大写单词串。如MyClass。内部类能够利用额外的引路下划线。 

专有变量:

函数&方法 
函数名应当为小写,能够用下划线风格单词以充实可读性。如:myfunction,my_example_function。 
*注意*:混合大小写仅被允许用于那种风格已经攻下优势的时候,以便保证向后相当。 
函数和措施的参数 
总使用“self”作为实例方法的率先个参数。总使用“cls”作为类方式的第二个参数。 
只要3个函数的参数名称和保留的重要字争辩,平日使用3个后缀下划线好于采用缩写或不测的拼写。 
大局变量 
对于from M import *导入语句,借使想阻止导入模块内的全局变量能够选取旧有的正统,在全局变量上加一个教导的下划线。 
*注意*:应幸免接纳全局变量 
变量 
变量名整体大写,由下划线连接各类单词。如color = WHITE,this_is_a_variable = 1 
*注意*: 
1.不论是类成员变量还是全局变量,均不采纳 m 或 g 前缀。 
二.私有类成员使用单一下划线前缀标记,多定义公开成员,少定义私有成员。 
三.变量名不应带有类型消息,因为Python是动态类型语言。如 iValue、names_list、dict_obj 等都是不佳的命名。 
常量 
常量名富有字母大写,由下划线连接各种单词如MAX_OVERFLOW,TOTAL。 
异常 
以“Error”作为后缀。 
缩写 
取名应当尽大概采纳全拼写的单词,缩写的处境有如下二种: 
一.常用的缩写,如XML、ID等,在命名时也应只大写首字母,如XmlParser。 
二.命名中蕴藏长单词,对有个别单词实行缩写。那时应使用约定成俗的缩写情势。 
例如: 
function 缩写为 fn 
text 缩写为 txt 
object 缩写为 obj 
count 缩写为 cnt 
number 缩写为 num,等。 
前导后缀下写道 
3个先河下划线:表示非公有。 
1个后缀下划线:防止重大字抵触。 
七个前导下划线:当命名1个类属性引起名称冲突时利用。 
七个前导和后缀下划线:“魔”(有特有用途)对象或然性质,比如__init__或者__file__。相对不用创设这样的名字,而只是采取它们。 
*注意*:关于下划线的应用存在一些争议。 
Python 用下划线作为变量前缀和后缀钦命尤其变量。 

__开头,__最后,一般为python的自有变量,不要以那种措施命名

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

__doc__

主导风格:防止用下划线作为变量名的起来。 

__class__

因为下划线对解释器有特殊的意思,而且是内建标记符所使用的标识,大家提议程序猿防止用下划线作为变量名的初始。一般来说,变量名_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() 

get_name()

初探 
是的的答案是: 
A.__private() 
B.public() 
若果你已经猜对了,那么能够不看笔者那篇博文了。借使您未有猜对也许心里有着疑问,那自个儿的那篇博文就是为您所预备的。 
方方面面由为何会输出“A.__private()”初步。但要讲掌握怎么,大家就有不能缺少了然一下Python的命名机制。 
据 Python manual,变量名(标记符)是Python的一种原子成分。当变量名被绑定到3个指标的时候,变量名就代表那一个指标,就像人类社会平等,不是吗?当变 量名出现在代码块中,那它就是地点变量;当变量名出现在模块中,它便是全局变量。模块相信我们都有很好的精通,但代码块大概令人费解些。在那边解释一下: 
代码块正是可作为可推行单元的一段Python程序文件;模块、函数体和类定义都是代码块。不仅仅如此,每2个交互脚本命令也是三个代码块;四个剧本文件也是二个代码块;多少个下令行脚本也是多个代码块。 
接 下来研商变量的可知性,我们引进3个限制的定义。范围便是变量名在代码块的可见性。要是1个代码块里定义本地变量,那范围就包涵那个代码块。假如变量定义 在1个成效代码块里,那范围就增添到这么些功用块里的任一代码块,除非个中定义了同名的另一变量。但定义在类中的变量的界定被限制在类代码块,而不会扩展到 方法代码块中。 

count_number()

迷踪 
据上节的论争,大家能够把代码分为两个代码块:类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的个人变量轧压了。 

ad_stat()

探究 
懂 Python的爱侣都知晓Python把以多个或以上下划线字符开首且未有以八个或上述下划线结尾的变量当作私有变量。私有变量会在代码生成在此以前被撤换为 长格式(变为国有)。调换机制是那般的:在变量前端插入类名,再在前端出席3个下划线字符。这就是所谓的私家变量轧压(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定义了贰个个体成员函数(变量),所以在代码生成以前先执行私有变量轧压(注意到上1节标红的那行字未有?)。轧压之后,类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() 

以__起来(3个下划线),其余和一般函数同样

__get_name()

————————————————————————————————————————————————————————————————————

文件名

全小写,可应用下划线

相应是粗略的、小写的名字。若是下划线可以改革可读性能够参预。如mypackage。

模块

与包的标准同。如mymodule。

连日选取首字母大写单词串。如MyClass。内部类能够动用额外的携自汗划线。

函数&方法

函数名应当为小写,能够用下划线风格单词以增添可读性。如:myfunction,my_example_function。

*注意*:混合大小写仅被允许用于这种作风早已攻克优势的时候,以便有限支撑向后格外。

函数和艺术的参数

总使用“self”作为实例方法的率先个参数。总使用“cls”作为类措施的第一个参数。

要是三个函数的参数名称和保存的机要字顶牛,平时接纳1个后缀下划线好于选拔缩写或古怪的拼写。

全局变量

对于from M import *导入语句,借使想阻止导入模块内的全局变量能够应用旧有的正统,在全局变量上加叁个教导的下划线。

*注意*:应防止采纳全局变量

变量

变量名全体大写,由下划线连接各样单词。如color = WHITE,this_is_a_variable = 1

*注意*:

一.不论是类成员变量依旧全局变量,均不采用 m 或 g 前缀。

二.私有类成员运用单一下划线前缀标记,多定义公开成员,少定义私有成员。

叁.变量名不应带有类型音信,因为Python是动态类型语言。如 iValue、names_澳门皇家赌场,list、dict_obj 等都以倒霉的命名。

常量

常量名持有字母大写,由下划线连接各样单词如MAX_OVERFLOW,TOTAL。

异常

以“Error”作为后缀。

缩写

命名应当尽大概利用全拼写的单词,缩写的动静有如下二种:

一.常用的缩写,如XML、ID等,在命名时也应只大写首字母,如XmlParser。

二.命名中包括长单词,对有个别单词进行缩写。那时应采用约定成俗的缩写形式。

例如:

function 缩写为 fn

本文由68399皇家赌场发布于最新解决方案,转载请注明出处:中变量的命名规范,命名规范

关键词: 68399皇家赌场 日记本 python热爱者

上一篇:js构建单页应用,用vuex构建单页

下一篇:没有了

频道精选

最火资讯