第 1 章 用 Pythonic 方式来思考
第 1 条：确认自己所用的 Python 版本
python --versionimport sys print(sys.version_info) print(sys.version)
第 2 条：遵循 PEP8 风格标准指南
《 Python Enhancement Proposal #8》（8 号 Python 增强提案）又叫 PEP 8
第 3 条：了解 bytes、str 与 unicode 的区别
- Unicode 字符转换成二进制数据 ： encode 方法
- 二进制数据转换成Unicode 字符 ：decode 方法
第 4 条：用辅助函数代替复杂的函数表达式
如果出现复杂的表达式，可以抽调成一个函数方法，如果需要反复使用相同逻辑，更应该把复杂的表达式放进辅助函数中。
第 5 条：了解切割序列的方法
1.不要写多余的代码：当 start 索引为 0，或 end 索引为序列长度时，应该将其省略。
- 切片操作不会计较 start 与 end 索引是否越界（如 a[:20] 或 a[-20:]）。
3.对 list 赋值的时候，如果使用切片操作，就会把原列表中处在相关范围内的值替
换成新值，即便它们的长度不同也依然可以替换
第 6 条：在单次切片操作内，不要同时指定 start 、end 和 stride
somelist[开始索引：结束索引：步进值]
不要同时使用 start 、 end 和 stride ，理解很困难；可以拆作范围切割和步进切割两条赋值表达，或考虑使用内置 itertools 模块中的 islice。
尽量不使用负值的 stride 。
第 7 条：用列表推导来取代 map 和 filter
a = [1, 2 ,3 ,4 ,5 ,6 , 7, 8, 9, 10]
squares = [x x**2 for x in a if x % 2 == 0]
squares = map(lambda x: x**2, filter(lambda x: x % 2 == 0), a)
结果均为 [4, 16, 36, 64, 100] 。第1个中的采用列表推导来做，那么只需在循环后面添加条件表达式即可；第2个把内置的 f ilter 函数与 map 结合起来，也能达成同样的效果，但是代码会写得非常
难懂。
字典与集也支持推导表达式。
第 8 条:不要使用两个以上的表达式的列表推导
列表推导支持多级循环，每一级循环也支持多项条件。超过两个表达式的列表推导是很难理解的，应该尽量避免。
可以使用两个条件、两个循环或
一个条件搭配一个循环。如果要写的代码比这还复杂，那就应该使用普通的 if 和 for 语句，并编写辅助函数。
第 9 条：用生成器表达式来改写数据量较大的列表推导
当输入的数据量较大时，列表推导可能会因为占用太多内存而出问题。为了解决这个问题，Python 提供了生成器表达式（generator expression），它是对列表
推导和生成器的一种泛化（generalization）。
把实现列表推导所用的那种写法放在一对圆括号中，就构成了生成器表达式。此时立刻返回一个迭代器，逐次调用内置的 next 函数，以这个迭代器为参数，输出一个值，做循环输出即可。
第 10 条：尽量用 enumerate 取代 range
name_list = ['aa', 'bbb', 'cccc', 'ddddd', 'eeeeee']
for i, name in enumerate(name_list):
print('%d : %s' % (i + 1, name))
结果：
1 : aa
2 : bbb
3 : cccc
4 : ddddd
5 : eeeeee
还可以直接指定 enumerate 函数开始计数时所用的值（默认为0，本例从 1 开始计数），结果不变，这样能
把代码写得更短。
name_list = ['aa', 'bbb', 'cccc', 'ddddd', 'eeeeee']
for i, name in enumerate(name_list, 1):
print('%d : %s' % (i , name))
3.11
第 11 条：用 zip 函数同时遍历两个迭代器
内置的 zip 函数里可以平行的同时遍历两个迭代器，如果长度不一样则会以较短的迭代器为准而结束循环。
python 3 中的 zip 函数相当于生成器，可以逐次产生元组。
python 2 则时一次性生成返回整份列表；如果用 zip 函数遍历的数据比较多，则会导致程序崩溃，需要用
itertools内置模块的 izip 函数
第 12 条：不要在 for 和 while 循环后面写 else 模块
# 判断两个数是否互质
a = 4
b = 9
for i in range(2, min(a, b) + 1):
print('Testing', i)
if a % i == 0 and b % i ==0:
print('Not coprime')
break
else:
print('Coprime')结果：
Testing 2
Testing 3
Testing 4
Coprime
只有当 for 或 while 整个循环主体没有遇到 break 语句时，循环后面的 else 模块才会运行。不要在循环后面使用 else 块，难以理解，用函数返回的形式代替。
第 13 条：合理利用 try/except/else/finally 结构中的每个代码块
else 块：try 块没有发生异常时才会运行。
例子：要从文件中读取某项事务的描述信息，处理该事务，然后就地更新该文件。
解题思路：为了实现此功能，我们可以用 try 块来读取文件并处理其内容，用 except 块来应对 try 块中可能发生的相关异常，用 else 块实时地更新文件并把更新中可能出现的异
常回报给上级代码，然后用 finally 块来清理文件句柄。UNDEFINED = object()
def divide_json(path):
handle = open(path, 'r+') # May raise IOError
try:
data = handle.read() # May raise UnicodeDecodeError
op = json.loads(data) # May raise ValueError
value = (
op['numerator'] /
op['denominator']) # May raise ZeroDivisionError
except ZeroDivisionError as e:
return UNDEFINED
else:
op['result'] = value
result = json.dumps(op)
handle.seek(0)
handle.write(result) # May raise IOError
return value
finally:
handle.close() # Always runs
第 2 章 函数
第 14 条：尽量用异常来表示特殊情况，而不要返回 None
# 处理分母为 0 的方法（异常）
def divide(a, b):
try:
return a / b
except ZeroDivisionError as e:
raise ValueError('Invalid inputs') from e
x, y = 5, 2
try:
result = divide(x, y)
except ValueError:
print('Invalid inputs')
else:
print('Result is %.1f' % result)
# 结果：Result is 2.5
第 15 条：了解如何在闭包里使用外围作用域中的变量
python支持闭包。
获取闭包内的数据：
1. nonlocal ：nonlocal 语句清楚地表明（python 2 不支持）：如果在闭包内给该变量赋值，那么修改的其实是闭包外那个作用域中的变量。这与 global 语句互为补充，global 用来表示对该变量的赋值操作，将会直接修改模块作用域里的那个变量。尽量不要用。
2. 使用可变量（例如，包含单个元素的列表，字典，元组）如果使用 nonlocal 的那些代码，已经写得越来越复杂，那就应该将相关的状态封装成辅助类（helper class）。
第 16 条：考虑用生成器来改写直接返回列表的函数
如果返回的列表量比较大，那么程序可能耗尽内存并崩溃，用生成器改写则不会出现这种情况。生成器是使用 yield 表达式的函数。调用生成器函数时候，它并不会真的运行，而是会返回迭代器。每次在这个迭代器上面调用内置的 next 函数是，迭代器会把生成器推到下一个 yield 表达式那里。生成器传给 yield 的每一个值，都会有迭代器返回给调用者。
# 计空格位置索引
def index_words_iter(text):
if text:
yield 0
for index, letter in enumerate(text):
if letter == ' ':
yield index + 1
第 17 条：在参数上面迭代时，要多加小心
迭代器只能欸遍历一次，如果多次遍历则会出现意想不到的错误。
（列表可以被多次迭代）
为解决迭代器不可多次遍历，可以使用迭代器制作一份列表，缺点在于列表的数据量大的话，会造成程序崩溃；
① 可以使用 lambda 表达式代替，该表达式在调用生成器的时候，可以每次产生新的迭代器；（略显生硬）
② 新编一种实现迭代器协议的容器类。（建议使用）
# 可以迭代的容器类
class ReadVisits(object):
def __init__(self, data_path):
self.data_path = data_path
def __iter__(self):
with open(self.data_path) as f:
for line in f:
yield int(line)
# 可以判断是否传入的是容器类的求取百分比的函数
def normalize_defensive(numbers):
if iter(numbers) is iter(numbers): # An iterator -- bad !
raise TypeError('Must supply a container !')
total = sum(numbers)
result = []
for value in numbers:
percent = 100 * value / total
result.append(percent)
return result
# visits = TreadVisits(path)
visits = [15, 35, 80]
per = normalize_defensive(visits) # No error
print(per)
# it = iter(visits)
# normalize_defensive(visits) # Error
第 18 条：用数量可变的位置参数减少视觉杂讯
*args :(习惯写成这样 starargs)
做函数参数时可以接收国定形参以外的任意数量的位置参数；
调用函数时，使用 * 操作符，把序列中的元素当成位置参数传给函数；
在已经接受 *args 参数的函数上面继续添加位置参数，可能会产生难以排查的
bug。
第 19 条：用关键字参数来表达可选的行为
函数参数可以按位置或关键字来指定。
只使用位置参数来调用函数，可能会导致这些参数值的含义不够明确，而关键
字参数则能够阐明每个参数的意图。给函数添加新的行为时，可以使用带默认值的关键字参数，以便与原有的函数
调用代码保持兼容。可选的关键字参数，总是应该以关键字形式来指定，而不应该以位置参数的形
式来指定。
第 20 条：用 None 和文档字符串来描述具有动态默认值的参数
如果参数的实际默认值是可变类型（mutable），那就一定要记得用 None 作为形式
上的默认值。（即形参值设为 None）
def log(message, when=None):
"""Log a message with a timestamp.
Args:
message: Message to print.
when: datetime of when the message occurred.
Defaults to the present time.
"""
when = datetime.now() if when is None else when
print('%s: %s' % (when, message))
# 两个时间戳就会不一样，如果形参 when=datetime.now() ,则输出相同时间戳
log('Hi there!')
sleep(0.1)
log('Hi again!')
参数的默认值，只会在程序加载模块并读到本函数的定义时评估一次。对于 {}
或 [] 等动态的值，这可能会导致奇怪的行为。对于以动态值作为实际默认值的关键字参数来说，应该把形式上的默认值写为
None，并在函数的文档字符串里面描述该默认值所对应的实际行为。
第 21 条：用只能以关键词形式指定的参数来确保代码的明晰
关键字参数能够使函数调用的意图更加明确。
**kwargs 参数：可以接受任意数量的关键字参数。
第 22 条：尽量用辅助类来维护程序的状态，而不要用字典和元组
我们很容易就能用 Python 内置的字典与元组类型构建出分层的数据结构，从而保存程序的内部状态。
但是，当前套多于一层的时候，就应该避免使用这种做法了（例如，不要使用包含字典的字典，不要使用过长的元组）如果容器中包含简单而又不可变的数据，可以使用
namedtuple来表示保存内部状态的字典如果变得比较复杂，那就应该把这些代码拆解为多个辅助类。（建议使用）
第 23 条：简单的接口应该接收函数，而不是类的实例
简单的接口应该接收函数，类的实例化可以在函数中完成。
通过 call 特殊方法，可以使类的实例能够像普通的 Python 函数那样得到调用
第 24 条：以 @classmethod 形式的多态去通用地构建对象
python 中每个类只有一个构造器： init
通过 @classmethod 机制，用一种与构造器相仿的方式构造类的对象
通过类方法多态机制，可以以更加通用的方式创建并拼接具体的子类。
第 25 条：用 super 初始化父类
直接在子类中调用超类的 init 方法，可能会产生无法预知的行为，问题之一就是一个类继承多个类，全部调用超类的 init 方法，实际调用顺序并不固定。
钻石行继承体系：如果子类继承自两个单独的超类，而那两个超类有继承自同一个公共基类，那么就构成了钻石行继承体系。
3.总是应该使用内置的 super 函数来初始化父类。