The Zen of Python, by Tim Peters
 
Beautiful is better than ugly.
# 优美胜于丑陋（Python以编写优美的代码为目标）
 
Explicit is better than implicit.
# 明了胜于晦涩（优美的代码应当是明了的，命名规范，风格相似）
 
Simple is better than complex.
# 简洁胜于复杂（优美的代码应当是简洁的，不要有复杂的内部实现）
 
Complex is better than complicated.
# 复杂胜于凌乱（如果复杂不可避免，那代码间也不能有难懂的关系，要保持接口简洁）
 
Flat is better than nested.
# 扁平胜于嵌套（优美的代码应当是扁平的，不能有太多的嵌套）
 
Sparse is better than dense.
# 间隔胜于紧凑（优美的代码有适当的间隔，不要奢望一行代码解决问题）
 
Readability counts.
# 可读性很重要（优美的代码是可读的）
 
Special cases aren‘t special enough to break the rules.
Although practicality beats purity.
# 即便假借特例的实用性之名，也不可违背这些规则（这些规则至高无上）
 
Errors should never pass silently.
Unless explicitly silenced.
# 不要包容所有错误，除非你确定需要这样做（精准地捕获异常，不写except:pass风格的代码）
 
In the face of ambiguity, refuse the temptation to guess.
# 当存在多种可能，不要尝试去猜测
 
There should be one-- and preferably only one --obvious way to do it.
# 而是尽量找一种，最好是唯一一种明显的解决方案（如果不确定，就用穷举法）
 
Although that way may not be obvious at first unless you‘re Dutch.
# 虽然这并不容易，因为你不是 Python 之父（这里的Dutch是指Guido）
Now is better than never.
Although never is often better than *right* now.
# 做也许好过不做，但不假思索就动手还不如不做（动手之前要细思量）
If the implementation is hard to explain, it‘s a bad idea.
If the implementation is easy to explain, it may be a good idea.
# 如果你无法向人描述你的方案，那肯定不是一个好方案；反之亦然（方案测评标准）
Namespaces are one honking great idea -- let‘s do more of those!
# 命名空间是一种绝妙的理念，我们应当多加利用（倡导与号召）

1、每次缩进使用4个空格
2、不要使用Tab，更不要Tab和空格混用
3、两个方法之间使用一个空行，两个Class之间使用两个空行
4、添加一个空格在字典、列表、序列、参数列表中的“，“后，以及在字典中的”：“之后，而不是之前
5、在赋值和比较两边放置一个空格（参数列表中除外）
6、紧随括号后面或者参数列表前一个字符不要存在空格

1、方法 & 属性：joined_lower
2、常量：joined_lower or ALL_CAPS
3、类：StudlyCaps
4、类属性：interface, _internal, __private
5、camelCase only to conform to pre-existing conventions

temp = a
a = b
b = temp

b, a = a, b

In [1]: people = [‘David‘, ‘Pythonista‘, ‘15145551234‘]
 
In [2]: name, title, phone = people
 
In [3]: name
Out[3]: ‘David‘
 
In [4]: title
Out[4]: ‘Pythonista‘
 
In [5]: phone
Out[5]: ‘15145551234‘

In [6]: people = [[‘David‘, ‘Pythonista‘, ‘15145551234‘], [‘Wu‘, ‘Student‘, ‘15101365547‘]]
 
In [7]: for name, title, phone in people:
   ...:     print name,  phone
   ...:     
David 15145551234
Wu 15101365547

>>> import math
>>> math.pi / 3
1.0471975511965976
>>> angle = _
>>> math.cos(angle)
0.50000000000000011
>>> _
0.50000000000000011

colors = [‘red‘, ‘blue‘, ‘green‘, ‘yellow‘]
 
result = ‘ ‘
for s in colors:
    result += s

result = ‘ ‘.join(colors)

d = {‘a‘: 1, ‘b‘: 2}
if ‘c‘ in d:
    print True
# DO NOT USE
if d.has_key(‘c‘):
    print True
 
for key in d:
    print key
# DO NOT USE
for key in d.keys():
    print key

d = {‘a‘: 1, ‘b‘: 2}
print d.get(‘c‘)        # None
print d.get(‘c‘, 14)    # 14

# 序列做 key,并提供默认value
>>> dict.fromkeys([‘a‘, ‘b‘, ‘c‘], 1)
# {‘a‘: 1, ‘c‘: 1, ‘b‘: 1}

equities = {}
for (portfolio, equity) in data:
    if portfolio in equities:
        equities[portfolio].append(equity)
    else:
        equities[portfolio] = [equity]

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

>>> given = [‘John‘, ‘Eric‘, ‘Terry‘, ‘Michael‘]
>>> family = [‘Cleese‘, ‘Idle‘, ‘Gilliam‘, ‘Palin‘]
>>> pythons = dict(zip(given, family))
>>> print pythons
{‘John‘: ‘Cleese‘, ‘Michael‘: ‘Palin‘, ‘Eric‘: ‘Idle‘, ‘Terry‘: ‘Gilliam‘}

>>> pythons.keys()
[‘John‘, ‘Michael‘, ‘Eric‘, ‘Terry‘]
>>> pythons.values()
[‘Cleese‘, ‘Palin‘, ‘Idle‘, ‘Gilliam‘]

# 这样写
if x:
    pass
# !不要这样写
if x == True:
    pass
 
# 对于list，要这样写
if items:
    pass
# !不要这样写
if len(items) == 0:
    pass

class MyClass(object):
 
    def __init__(self, value):
        self.value = value
 
    def __nonzero__(self):
        """ Return my truth value (True or False). """
        # This could be arbitrarily complex:
        return bool(self.value)

__bool__ = __nonzero__

>>> items = ‘zero one two three‘.split()
>>> print list(enumerate(items))
[(0, ‘zero‘), (1, ‘one‘), (2, ‘two‘), (3, ‘three‘)]
>>> for (index, item) in enumerate(items):
    print index, item

for (index, item) in enumerate(items):
    print index, item
 
# compare:
index = 0
for item in items:
    print index, item
    index += 1
 
# compare:
for i in range(len(items)):
    print i, items[i]

>>> enumerate(items)
<enumerate object at 0x011EA1C0>
>>> e = enumerate(items)
>>> e.next()
(0, ‘zero‘)
>>> e.next()
(1, ‘one‘)
>>> e.next()
(2, ‘two‘)
>>> e.next()
(3, ‘three‘)
>>> e.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
StopIteration

int a = 1;

def bad_append(new_item, a_list=[]):
    a_list.append(new_item)
    return a_list
 
>>> print bad_append(‘one‘)
[‘one‘]
>>> print bad_append(‘two‘)
[‘one‘, ‘two‘]

def good_append(new_item, a_list=None):
    if a_list is None:
        a_list = []
    a_list.append(new_item)
    return a_list

name = ‘xianglong‘
messages = 3
text = (‘Hello %s, you have %i messages‘ % (name, messages))
print text
 
# Output: Hello xianglong, you have 3 messages

values = {‘name‘: name, ‘messages‘: messages}
print (‘Hello %(name)s, you have %(messages)i messages‘ % values)
 
# Output: Hello xianglong, you have 3 messages

print (‘Hello %(name)s, you have %(messages)i messages‘ % locals())

print ("We found %(error_count)d errors" % self.__dict__)
 
# 等同于
print ("We found %d errors" % self.error_count)

print("%+10x" % 10)    # +a
print("%04d" % 5)    # 0005
print("%6.3f" % 2.3)    # 2.300

print("%.*f" % (4, 1.2))    # 1.2000

In [1]: name = ‘xianglong‘
In [2]: messages = 4
 
# 通过位置
In [3]: ‘Hello {0}, you have {1} messages‘.format(name, messages)
Out[3]: ‘Hello xianglong, you have 4 messages‘
 
# 通过关键字参数
In [4]: ‘Hello {name}, you have {messages} messages‘.format(name=name, messages=messages)
Out[4]: ‘Hello xianglong, you have 4 messages‘
 
# 通过下标
In [5]: ‘Hello {0[0]}, you have {0[1]} messages‘.format([name, messages])
Out[5]: ‘Hello xianglong, you have 4 messages‘
 
# 格式限定符：填充与对齐
# ^、<、>分别是居中、左对齐、右对齐，后面带宽度
# :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
In [6]: ‘Hello {0:>14}, you have {1:>14} messages‘.format(name, messages)
Out[6]: ‘Hello      xianglong, you have              4 messages‘
 
# 格式限定符：精度与类型f
In [7]: ‘{:.2f}‘.format(321.33345)
Out[7]: ‘321.33‘
 
# 格式限定符：b、d、o、x分别是二进制、十进制、八进制、十六进制
In [8]: ‘{:b}‘.format(14)
Out[8]: ‘1110‘
 
In [9]: ‘{:d}‘.format(14)
Out[9]: ‘14‘
 
In [10]: ‘{:o}‘.format(14)
Out[10]: ‘16‘
 
In [11]: ‘{:x}‘.format(14)
Out[11]: ‘e‘
 
# 格式限定符：千位分隔符
In [12]: ‘{:,}‘.format(1234567890)
Out[12]: ‘1,234,567,890‘

new_list = []
for item in a_list:
    if condition(item):
        new_list.append(fn(item))

new_list = [fn(item) for item in a_list if condition(item)]

>>> [n ** 2 for n in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 
>>> [n ** 2 for n in range(10) if n % 2]
[1, 9, 25, 49, 81]

total = 0
for num in range(1, 101):
    total += num * num

# 迭代器(列表生成式)
total = sum([num * num for num in range(1, 101)])
 
# 生成器
total = sum(num * num for num in xrange(1, 101))

total = sum(num * num for num in xrange(1, 1000000000))

# 过滤CSV文件中的空行
def filter_rows(row_iterator):
    for row in row_iterator:
        if row:
            yield row
 
data_file = open(path, ‘rb‘)
irows = filter_rows(csv.reader(data_file))
 
# 文件读取：open
datafile = open(‘datafile‘)
for line in datafile:
    do_something(line)

In [1]: a_list = [‘Tommy‘, ‘Jack‘, ‘Smith‘, ‘Paul‘]
In [2]: a_list.sort()
In [3]: a_list
Out[3]: [‘Jack‘, ‘Paul‘, ‘Smith‘, ‘Tommy‘]

In [1]: a_list = [‘Tommy‘, ‘Jack‘, ‘Smith‘, ‘Paul‘]
In [2]: b_list = sorted(a_list)
In [3]: b_list
Out[3]: [‘Jack‘, ‘Paul‘, ‘Smith‘, ‘Tommy‘]
In [4]: a_list
Out[4]: [‘Tom‘, ‘Jack‘, ‘Smith‘, ‘Paul‘]

In [1]: def custom_cmp(item1, item2):
   ...:     return cmp((item1[1], item1[3]), (item2[1], item2[3]))
   ...: 
In [2]: a_list = [‘Tommy‘, ‘Jack‘, ‘Smith‘, ‘Paul‘]
In [3]: a_list.sort(custom_cmp)
In [4]: a_list
Out[4]: [‘Jack‘, ‘Paul‘, ‘Smith‘, ‘Tommy‘]

# Decorate:
to_sort = [(item[1], item[3], item) for item in a_list]
 
# Sort:
to_sort.sort()
 
# Undecorate:
a_list = [item[-1] for item in to_sort]

In [1]: a_list = [‘Tommy‘, ‘Jack‘, ‘Smith‘, ‘Paul‘]
In [2]: def my_key(item):
   ...:     return (item[1], item[3])
   ...: 
In [3]: a_list.sort(key=my_key)
In [4]: a_list
Out[4]: [‘Jack‘, ‘Paul‘, ‘Smith‘, ‘Tommy‘]

d = {}
words = [‘a‘, ‘d‘, ‘a‘, ‘c‘, ‘b‘, ‘z‘, ‘d‘]
# LBYL
for w in words:
    if w not in d:
        d[w] = 0
    d[w] += 1
 
# EAFP
for w in words:
    try:
        d[w] += 1
    except KeyError:
        d[w] = 1

from module import *

import module
module.name

import long_module_name as mod
mod.name

from module import name
name

if __name__ == ‘__main__‘:
    # script code here

#!/usr/bin/env python
# -*- coding: utf-8 -*-
""" 文档 module docstring """
 
# 引用 imports
# 常量 constants
# 异常 exception classes
# 方法 interface functions
# 类 classes
# 内部方法和类 internal functions & classes
 
def main(...):
    ...
 
if __name__ == ‘__main__‘:
    status = main()
    sys.exit(status)

#!/usr/bin/env python
 
"""
Module docstring.
"""
 
import sys
import optparse
 
def process_command_line(argv):
    """
    Return a 2-tuple: (settings object, args list).
    `argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
    """
    if argv is None:
        argv = sys.argv[1:]
 
    # initialize the parser object:
    parser = optparse.OptionParser(
        formatter=optparse.TitledHelpFormatter(width=78),
        add_help_option=None)
 
    # define options here:
    parser.add_option(      # customized description; put --help last
        ‘-h‘, ‘--help‘, action=‘help‘,
        help=‘Show this help message and exit.‘)
 
    settings, args = parser.parse_args(argv)
 
    # check number of arguments, verify values, etc.:
    if args:
        parser.error(‘program takes no command-line arguments; ‘
                     ‘"%s" ignored.‘ % (args,))
 
    # further process settings & args if necessary
 
    return settings, args
 
def main(argv=None):
    settings, args = process_command_line(argv)
    # application code here, like:
    # run(settings, args)
    return 0        # success
 
if __name__ == ‘__main__‘:
    status = main()
    sys.exit(status)

package/
    __init__.py
    module1.py
    subpackage/
        __init__.py
        module2.py

import package.module1
from package.subpackage import module2
from package.subpackage.module2 import name

from __future__ import absolute_import