Python 命名规范

一，包名、模块名、局部变量名、函数名

全小写+下划线式驼峰

example：this_is_var

二，全局变量

全大写+下划线式驼峰

example：GLOBAL_VAR

三，类名

首字母大写式驼峰

example：ClassName()

四，关于下划线

1. 以单下划线开头，是弱内部使用标识，from M import * 时，将不会导入该对象（python 一切皆对象）。
2. 以双下划线开头的变量名，主要用于类内部标识类私有，不能直接访问。模块中使用见上一条。
3. 双下划线开头且双下划线截尾的命名方法尽量不要用，这是标识

example for 1：

module_1 模块中定义变量 var_1, _var_2, __var_3

#module_1

var_1
_var_2
__var_3

module_2 模块中代码如下：

 #module_2_error
'''
以下划线开头的变量不会别导入
'''
 from module_1 import *
 
 print var_1
 print _var_2  #将报错
 print __var_3  #将报错

执行到第6，7行将会报错，因为凡是以下划线开头的对象都不会被导入。

既然是弱内部使用标识，就还是有使用办法的，只需单独导入即可：

#module_2_solution

from module_1 import *  # 导入所有的不是下划线开头的对象

from module_1 import _var_2, __var_3 # 显式导入下划线开头的对象

print var_1
print _var_2 # 不会报错
print __var_3  # 不会报错

example for 2:

#module_error
''' 
双下划线开头的变量不能被直接访问
'''

class MyClass():
    def __init__(self):
        self.var_1 = 1
        self._var_2 = 2
        self.__var_3 = 3
    
if __name__=="__main__":
    obj = MyClass()
    print obj.var_1
    print obj._var_2
    print obj.__var_3  # 这里将会出错

#module_solution

'''
需要定义函数来获取双下划线开头的变量
'''

class MyClass():
    def __init__(self):
        self.var_1 = 1
        self._var_2 = 2
        self.__var_3 = 3
        
    def get_var_3(self):
        return self.__var_3
        
    

if __name__=="__main__":
    obj = MyClass()
    print obj.var_1
    print obj._var_2
    print obj.get_var_3()  # 不会再报错

四，其他要注意的

• 不要像c等语言里面一样去用开头字母标识变量类型（如 iValue），因为python在解释的时候才确定类型。
• 因为异常也是一个类，所以遵守类的命名规则。此外，如果异常实际上指代一个错误的话，应该使用“Error”做后缀。
• 命名应当尽量使用全拼写的单词，缩写的情况有如下两种：常用的缩写，如XML、ID等，在命名时也应只大写首字母，如XmlParser。命名中含有长单词，对某个单词进行缩写。这时应使用约定成俗的缩写方式。例如：function 缩写为 fn, text 缩写为 txt, object 缩写为 obj, count 缩写为 cnt, number 缩写为 num 等。
• 类实例方法第一个参数使用self, 类方法第一个参数使用cls

五，最后，把一些英文说明作为备注

Package and Module Names               

　　　Modules should have short, all-lowercase names.  Underscores can be used

      in the module name if it improves readability.  Python packages should

      also have short, all-lowercase names, although the use of underscores is

      discouraged.     
                Since module names are mapped to file names, and some file systems are

      case insensitive and truncate long names, it is important that module

      names be chosen to be fairly short -- this won't be a problem on Unix,

      but it may be a problem when the code is transported to older Mac or

      Windows versions, or DOS.

 

Class Names

      Almost without exception, class names use the CapWords convention.

      Classes for internal use have a leading underscore in addition.

 

 Exception Names

      Because exceptions should be classes, the class naming convention

      applies here.  However, you should use the suffix "Error" on your

      exception names (if the exception actually is an error).

 

Global Variable Names

      　　(Let's hope that these variables are meant for use inside one module

      only.)  The conventions are about the same as those for functions.

      　　Modules that are designed for use via "from M import *" should use the

      __all__ mechanism to prevent exporting globals, or use the older

      convention of prefixing such globals with an underscore (which you might

      want to do to indicate these globals are "module non-public").

 

  Function Names

      Function names should be lowercase, with words separated by underscores

      as necessary to improve readability.

      mixedCase is allowed only in contexts where that's already the

      prevailing style (e.g. threading.py), to retain backwards compatibility.

 

 Function and method arguments

      Always use 'self' for the first argument to instance methods.

      Always use 'cls' for the first argument to class methods.

      If a function argument's name clashes with a reserved keyword, it is

      generally better to append a single trailing underscore rather than use

      an abbreviation or spelling corruption.  Thus "print_" is better than

      "prnt".  (Perhaps better is to avoid such clashes by using a synonym.)

 

Method Names and Instance Variables

      Use the function naming rules: lowercase with words separated by

      underscores as necessary to improve readability.

      Use one leading underscore only for non-public methods and instance

      variables.

      To avoid name clashes with subclasses, use two leading underscores to

      invoke Python's name mangling rules.

      Python mangles these names with the class name: if class Foo has an

      attribute named __a, it cannot be accessed by Foo.__a.  (An insistent

      user could still gain access by calling Foo._Foo__a.)  Generally, double

      leading underscores should be used only to avoid name conflicts with

      attributes in classes designed to be subclassed.

      Note: there is some controversy about the use of __names (see below).

 

Constants

       Constants are usually defined on a module level and written in all

       capital letters with underscores separating words.  Examples include

       MAX_OVERFLOW and TOTAL.