<编程技巧> 代码规范

戴宇轩

    本文主要记录Python中的一些常用技巧，所描述的是告诉你怎么写才是更好
    如果你并不熟悉Python语法，希望你能在下面代码片段中看到Python的简单、优雅
    如果你对 Python 有兴趣我相信下面的技巧并不会让你失望

Python 禅道
这是Python的指导原则，但有不同诠释。

1. 美丽优于丑陋。
   
2. 明确优于含蓄。
   
3. 简单比复杂好。
   
4. 平版优于嵌套。
   
5. 稀疏比密集更好。
   
6. 特殊情况不能特殊到打破规则。
   
7. 错误不应该默默传递。
   
8. ......

复制代码

代码风格: 提高可读性
Programs must be written for people to read, and only incidentally for machines to execute.
     —Abelson & Sussman, Structure and Interpretation of Computer Programs


PEP-8 Python 代码风格指南: http://www.python.org/dev/peps/pep-0008/

空格(行)使用---1:
1. 使用 4 个空格缩进。
2. 不要使用制表符。
3. 不要将制表符和空格混合使用。
4. 每个函数之间应该有一个空行。
5. 每一个 Class 之间应该有两个空行。


空格(行)使用---2:
1.在使用 字典(dict), 列表(list), 元组(tuple), 参数(argument)列表时， 应在 "," 前添加一个空格, 并且使用字典(dict)时，在 ":" 号后添加空格
在括号之前或参数之前不添加空格。
文档注释的前后不要有空格。

示范:

1. def make_squares(key, value=0):  
   
2.     """Return a dictionary and a list..."""  
   
3.     d = {key: value}  
   
4.     l = [key, value]  
   
5.     return d, l

复制代码

命名
joined_lower 可以是 函数名, 方法名, 属性名
joined_lower or ALL_CAPS 是常量
StudlyCaps 类名
camelCase 只有在预先制定好的命名规范使用
属性: interface, _internal, __private
但尽量避免__private形式。下面两个链接解释了 为什么python中没有 private声明？
      http://stackoverflow.com/questions/70528/why-are-pythons-private-methods-not-actually-private
      http://stackoverflow.com/questions/1641219/does-python-have-private-variables-in-classes


较长代码行
1. 保持一行代码在 80 个字符长度。
2. 在括号内使用隐含的行延续，例如:

1. def __init__(self, first, second, third,  
   
2.             fourth, fifth, sixth):  
   
3.    output = (first + second + third  
   
4.              + fourth + fifth + sixth)

复制代码

或者在需要换行的位置使用 \ 来延续行，例如:

1. VeryLong.left_hand_side \  
   
2.     = even_longer.right_hand_side()

复制代码

另外，使用反斜杠是有风险的，如果你添加一个空格在反斜杠后面，它就出错了。此外，它使代码难看。


较长字符串
将相邻的字符串进行连接的做法:

1. >>> print 'o' 'n' "e"  
   
2. one

复制代码

虽然字符之间的空格不是必需的，但是这样有助于可读性。

1. >>> print 't' r'\/\/' """o"""  
   
2. t\/\/o

复制代码

  

用一个 “r“ 开头的字符串是一个“raw“的字符串(类似java中的转义符)。上面的反斜杠就会当成普通字符串处理。他们对正则表达式和Windows文件系统路径非常有用。
注意: 使用字符串变量名无法通过以上方式进行连接。

1. >>> a = 'three'  
   
2. >>> b = 'four'  
   
3. >>> a b  
   
4.   File "<stdin>", line 1  
   
5.     a b  
   
6.       ^  
   
7. SyntaxError: invalid syntax

复制代码

这是因为自动连接是由Python解析器/编译器来处理的，因为其无法在编译时对变量值进行"翻译"，所以就这种必须在运行时使用“+“运算符来连接变量。


复合语句
Good:

1. if foo == 'blah':  
   
2.     do_something()  
   
3. do_one()  
   
4. do_two()  
   
5. do_three()

复制代码

Bad:

1. if foo == 'blah': do_something()  
   
2. do_one(); do_two(); do_three()

复制代码

文档注释(Docstrings) & 注释
文档注释 = 用于解释如何使用代码
      文档注释公约：http://www.python.org/dev/peps/pep-0257/
注释 = 为什么 (理由) & 代码如何工作的如：

1. # !!! BUG: ...  
   
2. # !!! FIX: This is a hack  
   
3. # ??? Why is this here?

复制代码

注释对于任何语言开发者来说已经最基本的东西了，这里就不详细说了.


交换变量
在其它语言的交换变量的做法一般是:

1. temp = a
   
2. a = b  
   
3. b = temp

复制代码

Python的做法:

1. b, a = a, b

复制代码

也许你见到过这样的情况，但是你知道它是如何工作的吗？
首先，逗号是元组构造语法。
等号的右边是定义一个元组 (tuple packing).
其左边为一个目标元组 (tuple unpacking)).
右边的元组根据名称被 unpacked 到左边的无组。
更多关于 unpacked例子:

1. >>> info =['David', 'Pythonista', '+1250']  
   
2. >>> name, title, phone = info  
   
3. >>> name  
   
4. 'Davids'  
   
5. >>> title  
   
6. 'Pythonista'  
   
7. >>> phone  
   
8. '+1250'

复制代码

在结构化的数据上使用循环：
info 是在上面定义的一个 list . 所以下面的 people 有两个项,  两个项都是分别都拥有三个项的 list.

1. >>> people = [info, ['Guido', 'BDFL', 'unlisted']]  
   
2. >>> for (name, title, phone) in people:  
   
3. ...     print(name, phone)
   
4. ...  
   
5. David +1250  
   
6. Guido unlisted

复制代码

以上循环中，people中的两个项(list item)，都已经被 unpacked 到 (name, title, phone) 无组中。
可以任意嵌套(只要左右两边的结构一定要能够匹配得上):

1. >>> david, (gname, gtitle, gphone) = people  
   
2. >>> gname  
   
3. 'Guido'  
   
4. >>> gtitle  
   
5. 'BDFL'  
   
6. >>> gphone  
   
7. 'unlisted'  
   
8. >>> david  
   
9. ['David', 'Pythonista', '+1250']

复制代码

更多关于 Tuples
我们看到的是元组通过逗号构造，而不是括号。例如:

1. >>> 1,  
   
2. (1,)

复制代码

Python的解释器会为你显示括号，所以建议你使用括号:

1. >>> (1,)  
   
2. (1,)

复制代码

千万不要忘记逗号!

1. >>> (1)  
   
2. 1

复制代码

在只有一个元素的元组，尾随逗号是必须的，在2 + 元素的元组，尾随逗号是可选的。 如果创建一个 0或空元组，一对括号是快捷的语法:

1. >>> ()  
   
2. ()  
   
3. >>> tuple()  
   
4. ()

复制代码

一个常见的&#8203;&#8203;错误当你并不想要一个无组，却无意的添加了一个逗号，很容易造成你在代码中的错误，如:

1. >>> value = 1,  
   
2. >>> value # is a tuple, not a int  
   
3. (1,)

复制代码

所以，当你发现一个元组时，赶紧去找一下那个,号吧。


关于 "_"
是一个非常有用的功能，但是却很少有人知道。
当你在交互式模式下(如 IDEL)计算一个表达式或调用一个函数后，其结果必然是一个临时名称，_（下划线):

1. >>> 1 + 1  
   
2. 2  
   
3. >>> _  
   
4. 2

复制代码

在 _ 中存储最后输出的值。
当输出的结果是 None 或没有任何输出时，而 _ 的值并不会改变，仍然保存上一次的值。这就是方便所在。
当然，这只能交互式的模式中使用，在模块中不能支持。
这在交互式模式中是非常有用的，当你在过程中没有保存计算结果 或 你想看最后一步的执行的输出结果:

1. >>> import math  
   
2. >>> math.pi / 3  
   
3. 1.0471975511965976  
   
4. >>> angle = _  
   
5. >>> math.cos(angle)  
   
6. 0.50000000000000011  
   
7. >>> _  
   
8. 0.50000000000000011

复制代码

创建String: 从列表中创建
开始定义一个 string  列表:

1. colors = ['red', 'blue', 'green', 'yellow']

复制代码

当我们需要将上面的列表连接成一个字符串。尤其当 list 是一个很大的列表时....
不要这样做:

1. result = ''  
   
2. for s in colors:  
   
3.     result += s

复制代码

这种方式效率非常低下的，它有可怕的内存使用问题，至于为什么，如果你是 javaer 的话，其中的 string 连接，我想你并不陌生。
相反，你应该这样做:

1. result = ''.join(colors)

复制代码

当你只有几十或几百个string项连接时，它们效率上并不会太大的差别。但你要在养成写高效代码的习惯，因为当字符串数千时，join 比起 for 连接性能会能有所提升。

如果你需要使用一个函数来生成一个字符串列表，同样可以使用:

1. result = ''.join(fn(i) for i in items)

复制代码

尽可能的使用
Good:

1. for key in d:  
   
2.     print key

复制代码

使用 in 一般情况下是非常快的。
这种方式也适用于其它的容器对象(如 list，tuple 和 set)。


字典中的 get 函数
我们经常需要在字典中初始化数据：
以下是不好的实现方法:

1. <navs = {}  
   
2. for (portfolio, equity, position) in data:  
   
3.     if portfolio not in navs:  
   
4.         navs[portfolio] = 0  
   
5.     navs[portfolio] += position * prices[equity]<

复制代码

使用dict.get(key, default) 删除 if 判断代码:

1. navs = {}  
   
2. for (portfolio, equity, position) in data:  
   
3.     navs[portfolio] = (navs.get(portfolio, 0)  
   
4.                        + position * prices[equity])

复制代码

这种方式更为直接。


字典中的 setdefault 函数---1
当我们要初始化一个可变字典的值。每个字典的值将是一个列表。下面是不好的做法：
初始化可变字典的值:

1. equities = {}  
   
2. for (portfolio, equity) in data:  
   
3.     if portfolio in equities:  
   
4.         equities[portfolio].append(equity)  
   
5.     else:  
   
6.         equities[portfolio] = [equity]

复制代码

通过 dict.setdefault(key, default) 使这段代码工作的更好:

1. equities = {}  
   
2. for (portfolio, equity) in data:  
   
3.     equities.setdefault(portfolio, []).append(  
   
4.                                          equity)

复制代码

dict.setdefault() 等同于“ get, or set & get“ 或"如果没有，就设置";  如果你的字典Key是复杂的计算或long类型，使用 setdefault 是特别有效的。


字典中的 setdefault 函数---2
在我们看到的setdefault字典方法也可以作为一个独立的语句使用:

1. avs = {}  
   
2. for (portfolio, equity, position) in data:  
   
3.     navs.setdefault(portfolio, 0)  
   
4.     navs[portfolio] += position * prices[equity]

复制代码

我们在这里忽略了字典的setdefault方法返回的默认值。我们正利用的setdefault中的作用，仅仅只是在dict中没有 key 的值的时候才会设置。


创建 & 分割字典
如果你有两份 list 对象，希望通过这两个对象构建一个 dict 对象。

1. given = ['John', 'Eric', 'Terry', 'Michael']  
   
2. family = ['Cleese', 'Idle', 'Gilliam', 'Palin']  
   
3. pythons = dict(zip(given, family))  
   
4. >>> pprint.pprint(pythons)  
   
5. {'John': 'Cleese',  
   
6. 'Michael': 'Palin',  
   
7. 'Eric': 'Idle',  
   
8. 'Terry': 'Gilliam'}

复制代码

同样，如果希望获取两份列表，也是非常简单:

1. >>> pythons.keys()  
   
2. ['John', 'Michael', 'Eric', 'Terry']  
   
3. >>> pythons.values()  
   
4. ['Cleese', 'Palin', 'Idle', 'Gilliam']

复制代码

需要注意的是，上面 list 虽然是有序的，但是 dict 中的  keys 和 values 是无序的，这正是因为 dict 本质就是无序存储的。


索引 & 项---1
如果你需要一个列表，这里有一个可爱的方式来节省你的输入:

1. >>> items = 'zero one two three'.split()  
   
2. >>> print(items)
   
3. ['zero', 'one', 'two', 'three']

复制代码

如果我们需要遍历这个 list ，而且需要 index 和 items:

1. i = 0  
   
2. for item in items:
   
3.     print(i, item)
   
4.     i += 1
   
5. 
   
6. # 或者
   
7. for i in range(len(items)):
   
8.     print(i, items[i])

复制代码

索引 & 项---2: enumerate
通过 enumerate 可以返回 list 中的 (index, item)元组:

1. >>> print(list(enumerate(items)))
   
2. [(0, 'zero'), (1, 'one'), (2, 'two'), (3, 'three')]

复制代码

于是，遍历list获取index 及 item 就更加简单了:

1. for (index, item) in enumerate(items):  
   
2.     print(index, item)
   
3. 
   
4. # 等同于
   
5. index = 0
   
6. for item in items:
   
7.     print index, item
   
8.     index += 1
   
9. 
   
10. # 或者
    
11. for i in range(len(items)):
    
12.     print(i, items[i])
    
13. 不难看出，使用 enumerate 比起下面两种方式，更加简单，更加容易阅读，这正是我们想要的。
    
14. 下面是例子是如何通过 enumerate 返回迭代器:[code]>>> enumerate(items)  
    
15. <enumerate object at 0x011EA1C0>  
    
16. >>> e = enumerate(items)  
    
17. >>> e.next()  
    
18. (0, 'zero')  
    
19. >>> e.next()  
    
20. (1, 'one')  
    
21. >>> e.next()  
    
22. (2, 'two')  
    
23. >>> e.next()  
    
24. (3, 'three')  
    
25. >>> e.next()  
    
26. Traceback (most recent call last):  
    
27.   File "<stdin>", line 1, in ?  
    
28. StopIteration

复制代码

默认参数值
这是对于一个初学者常犯的错误，甚至于一些高级开发人员也会遇到，因为他们并不了解 Python 中的 names.

1. def bad_append(new_item, a_list=[]):  
   
2.     a_list.append(new_item)  
   
3.     return a_list

复制代码

这里的问题是，a_list是一个空列表，默认值是在函数定义时进行初始化。因此，每次调用该函数，你会得到不相同的默认值。尝试了好几次:

1. >>> print bad_append('one')  
   
2. ['one']  
   
3. >>> print(bad_append('two'))
   
4. ['one', 'two']

复制代码

列表是可变对象，你可以改变它们的内容。正确的方式是先获得一个默认的列表（或dict，或sets）并在运行时创建它。

1. def good_append(new_item, a_list=None):  
   
2.     if a_list is None:  
   
3.         a_list = []  
   
4.     a_list.append(new_item)  
   
5.     return a_list

复制代码

判断 bool 值

1. # 这样做
   
2. if x:
   
3.     pass
   
4. # 不要这样做
   
5. if x == True:
   
6.     pass<

复制代码

它的优势在于效率和优雅。
判断一个list是否不为空:

1. # 要这样做   
   
2. if items:
   
3.     pass
   
4. 
   
5. # 不要这样做
   
6. if len(items):
   
7.     pass
   
8. 
   
9. # 千万不要这样做!
   
10. if items != []:
    
11.     pass

复制代码

菜子zzk

谢谢楼主分享！

～风介～

好东西！继续努力！

xuff

还没看完，留着

ianv

每天回帖赚鱼币

lengyudu

受教了

xinluen

學習中 有時會看看google的規範

飘雪折柳别

作为一名优秀的工程师，基层建筑不可少，整体美观很重要。

天也高云也淡

学习，实践

hyzszq

GOOD

tju1015zc

好东西，必须支持，支持小甲鱼！！！

吕浩

学习了、、、

poiulp

  真的不错，好好学习中！

zxc123qwe

好分享

韩彦博

能不能gi答案

双枪李向阳

必须赞一个！

YY杰

很多实用的技巧，如果有关于函数变量类成员命名规范的就更好了

emoji

很实用，谢谢

想飞的翅膀

好东西，新手非常有用