1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
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
2
3
4
5
6
|
1、每次缩进使用4个空格
2、不要使用Tab,更不要Tab和空格混用
3、两个方法之间使用一个空行,两个Class之间使用两个空行
4、添加一个空格在字典、列表、序列、参数列表中的“,“后,以及在字典中的”:“之后,而不是之前
5、在赋值和比较两边放置一个空格(参数列表中除外)
6、紧随括号后面或者参数列表前一个字符不要存在空格
|
1
2
3
4
5
|
1、方法 & 属性:joined_lower
2、常量:joined_lower or ALL_CAPS
3、类:StudlyCaps
4、类属性:interface, _internal, __private
5、camelCase only to conform to pre-existing conventions
|
1
2
3
|
temp = a
a = b
b = temp
|
1
|
b, a
=
a, b
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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'
|
1
2
3
4
5
6
7
|
In [
6
]: people
=
[[
'David'
,
'Pythonista'
,
'15145551234'
], [
'Wu'
,
'Student'
,
'15101365547'
]]
In [
7
]:
for
name, title, phone
in
people:
...:
print
name, phone
...:
David
15145551234
Wu
15101365547
|
1
2
3
4
5
6
7
8
9
|
>>>
1
,
(
1
,)
>>> (
1
,)
(
1
,)
>>> (
1
)
1
>>> value
=
1
,
>>> value
(
1
,)
|
1
2
3
4
5
6
7
8
|
>>>
import
math
>>> math.pi
/
3
1.0471975511965976
>>> angle
=
_
>>> math.cos(angle)
0.50000000000000011
>>> _
0.50000000000000011
|
1
2
3
4
5
|
colors
=
[
'red'
,
'blue'
,
'green'
,
'yellow'
]
result
=
''
for
s
in
colors:
result
+
=
s
|
1
|
result
=
','
.join(colors)
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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
|
1
2
3
|
d
=
{
'a'
:
1
,
'b'
:
2
}
print
d.get(
'c'
)
# None
print
d.get(
'c'
,
14
)
# 14
|
1
2
3
|
# ⽤序列做 key,并提供默认value
>>>
dict
.fromkeys([
'a'
,
'b'
,
'c'
],
1
)
# {'a': 1, 'c': 1, 'b': 1}
|
1
2
3
4
5
6
|
equities
=
{}
for
(portfolio, equity)
in
data:
if
portfolio
in
equities:
equities[portfolio].append(equity)
else
:
equities[portfolio]
=
[equity]
|
1
2
3
|
equities
=
{}
for
(portfolio, equity)
in
data:
equities.setdefault(portfolio, []).append(equity)
|
1
2
3
4
5
|
>>> 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'
}
|
1
2
3
4
|
>>> pythons.keys()
[
'John'
,
'Michael'
,
'Eric'
,
'Terry'
]
>>> pythons.values()
[
'Cleese'
,
'Palin'
,
'Idle'
,
'Gilliam'
]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 这样写
if
x:
pass
# !不要这样写
if
x
=
=
True
:
pass
# 对于list,要这样写
if
items:
pass
# !不要这样写
if
len
(items)
=
=
0
:
pass
|
False | True |
---|---|
False (== 0) | True (== 1) |
"" (空字符串) | 除 "" 之外的字符串(" ", "anything") |
0, 0.0 | 除 0 之外的数字(1, 0.1, -1, 3.14) |
[], (), {}, set() | 非空的list,tuple,set和dict ([0], (None,), ['']) |
None | 大部分的对象,除了明确指定为False的对象 |
1
2
3
4
5
6
7
8
|
class
MyContainer(
object
):
def
__init__(
self
, data):
self
.data
=
data
def
__len__(
self
):
""" Return my length. """
return
len
(
self
.data)
|
1
2
3
4
5
6
7
8
9
|
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)
|
1
|
__bool__
=
__nonzero__
|
1
2
3
4
5
|
>>> 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
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
>>>
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
|
1
|
int
a =
1
;
|
1
|
a =
2
;
|
1
|
int
b = a;
|
1
|
a
=
1
|
1
|
a
=
2
|
1
|
b
=
a
|
1
2
3
4
5
6
7
8
|
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'
]
|
1
2
3
4
5
|
def
good_append(new_item, a_list
=
None
):
if
a_list
is
None
:
a_list
=
[]
a_list.append(new_item)
return
a_list
|
1
2
3
4
5
6
|
name
=
'xianglong'
messages
=
3
text
=
(
'Hello %s, you have %i messages'
%
(name, messages))
print
text
# Output: Hello xianglong, you have 3 messages
|
格式 | 描述 |
%% | 百分号 % 标记 |
%s | 字符串 (采用str()的显示) |
%r | 字符串 (采用repr()的显示) |
%c | 字符及其ASCII码 |
%b | 二进制整数 |
%d | 十进制整数 (有符号整数) |
%u | 十进制整数 (无符号整数) |
%i | 十进制整数 (有符号整数) |
%o | 八进制整数 (无符号整数) |
%x | 十六进制整数 (无符号整数) |
%X | 十六进制整数 (无符号整数) |
%e | 指数 (基底写为e) |
%E | 指数 (基底写为E) |
%f | 浮点数 |
%F | 浮点数,与上相同 |
%g | 指数(e)或浮点数 (根据显示长度) |
%G | 指数(E)或浮点数 (根据显示长度) |
%p | 指针(用十六进制打印值的内存地址) |
%n | 存储输出字符的数量放进参数列表的下一个变量中 |
1
2
3
4
|
values
=
{
'name'
: name,
'messages'
: messages}
print
(
'Hello %(name)s, you have %(messages)i messages'
%
values)
# Output: Hello xianglong, you have 3 messages
|
1
|
print
(
'Hello %(name)s, you have %(messages)i messages'
%
locals
())
|
1
2
3
4
|
print
(
"We found %(error_count)d errors"
%
self
.__dict__)
# 等同于
print
(
"We found %d errors"
%
self
.error_count)
|
1
2
3
|
print
(
"%+10x"
%
10
)
# +a
print
(
"%04d"
%
5
)
# 0005
print
(
"%6.3f"
%
2.3
)
# 2.300
|
1
|
print
(
"%.*f"
%
(
4
,
1.2
))
# 1.2000
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
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'
|
1
2
3
4
|
new_list
=
[]
for
item
in
a_list:
if
condition(item):
new_list.append(fn(item))
|
1
|
new_list
=
[fn(item)
for
item
in
a_list
if
condition(item)]
|
1
2
3
4
5
|
>>> [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
]
|
1
2
3
|
total
=
0
for
num
in
range
(
1
,
101
):
total
+
=
num
*
num
|
1
2
3
4
5
|
# 迭代器(列表生成式)
total
=
sum
([num
*
num
for
num
in
range
(
1
,
101
)])
# 生成器
total
=
sum
(num
*
num
for
num
in
xrange
(
1
,
101
))
|
1
|
total
=
sum
(num
*
num
for
num
in
xrange
(
1
,
1000000000
))
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 过滤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)
|
1
2
3
4
|
In [
1
]: a_list
=
[
'Tommy'
,
'Jack'
,
'Smith'
,
'Paul'
]
In [
2
]: a_list.sort()
In [
3
]: a_list
Out[
3
]: [
'Jack'
,
'Paul'
,
'Smith'
,
'Tommy'
]
|
1
2
3
4
5
6
|
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'
]
|
1
2
3
4
5
6
7
|
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'
]
|
1
2
3
4
5
6
7
8
|
# 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]
|
1
2
3
4
5
6
7
|
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'
]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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
|
1
|
from
module
import
*
|
1
2
|
import
module
module.name
|
1
2
|
import
long_module_name as mod
mod.name
|
1
2
|
from
module
import
name
name
|
1
2
|
if
__name__
=
=
'__main__'
:
# script code here
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#!/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)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
#!/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)
|
1
2
3
4
5
6
|
package
/
__init__.py
module1.py
subpackage
/
__init__.py
module2.py
|
1
2
3
|
import
package.module1
from
package.subpackage
import
module2
from
package.subpackage.module2
import
name
|
1
|
from
__future__
import
absolute_import
|