《Effective Python》59个有效方法(今日到25)
chapter1：用Pythonic方式来思考
第1条:确认自己所用的Python
shijianzhongdeMacBook-Pro:~ shijianzhong$ python -V Python 2.7.16 shijianzhongdeMacBook-Pro:~ shijianzhong$ python --version Python 2.7.16 shijianzhongdeMacBook-Pro:~ shijianzhong$ python3 --version Python 3.7.4 shijianzhongdeMacBook-Pro:~ shijianzhong$ python3 -V Python 3.7.4 shijianzhongdeMacBook-Pro:~ shijianzhong$
In [48]: import sys In [49]: sys.version_info Out[49]: sys.version_info(major=3, minor=7, micro=4, releaselevel='final', serial=0) In [50]: sys.version Out[50]: '3.7.4 (default, Jul 9 2019, 18:13:23) \n[Clang 10.0.1 (clang-1001.0.46.4)]' In [51]:
以后重点使用py3，2已经冻结，只会bug修复
第2条:遵循PEP8风格指南
《Python Enhancement Proposal#8》又叫PEP8，它是针对Python代码格式而编订的风格指南。
空白：
使用space(空格)来表示缩进，而不要用tab(制表符)。
和语法相关的每一层缩进都用4个空格来表示
每行的字符数不应超过79，学习笔记说，现在可以100了
对于占据多行的长表达式来说，除了首行之外的其余各行都应该在通常的缩进级别之上再加4个空格(pycharm是6个空格)
文件中函数跟类应该用两个空行分开
在同一个类中，各方法之间应该用一个空行隔开
在使用下标来获取列表元素、调用函数或给关键字参数赋值的时候，不要在两旁添加空格
为变量赋值的时候，赋值符号的左侧和右侧应该各自写上一个空格，而且只写一个就好。
命名:
函数、变量和属性应该用小写字母来拼写，各单词之间以下划线相连。
受保护的实例属性，应该以单个下划线开头，例如_xxx_xx
私有的实例属性，应该以两个下划线开头，例如__double_xxx
类与异常，应该以每个单词首字母大写的形式来命名
模块级别的常量，应该全部采用大写字母来拼写，个单词之间以下划线相连，如ALL_CAPS
实例方法首字母(self)
类方法首字母(cls)
表达式语句
采用内联形式的否定词，而不是把否定词放在整个表达式的前面，列如 if a is not b 而不是 if not a is b
不要通过len一个序列去判断空，直接用对象就可以了。
文件中的那些import语句应该按照顺序划分三个部分，分别表示标准版模块、第三方模块以及自用模块。在每一个部分之中，各import语句应该按模块的字母顺序来排序.
第3条:了解bytes、str与unicode的区别
Python3有两种表示字符序列的类型:bytes和str。前者实例包含原始的8位值；或者的实例包含Unicode字符
Python2也有两种表示字符序列的类型，分别叫做str和unicode。与Python3不同的是，str的实例包含原始的8位值;而unicode的实例，则包含Unicode字符。
也就是说，py3的bytes与py2中的str数据格式相等
另外写的比较简单，py2默认的打开方式是2进制模式打开，py3是以文件的形式打开，如果向文件对象进行二进制操作，可以用'rb'与'wb'。
第4条：用赋值函数来取代复杂的表达式。
书中主要用到了or操作符左侧的子表达式估值为False，那么整个表达式的值就是or操作符右侧那个子表达式的值，和三元操作符。
最后告诉我们要适当使用Python语法特性。
In [58]: my_values = parse_qs('red=5&blue=0&green=',keep_blank_values=True)
In [59]: my_values
Out[59]: {'red': ['5'], 'blue': ['0'], 'green': ['']}
In [60]: red = my_values.get('red',[''])[0] or 0
In [61]: blue = my_values.get('blue',[''])[0] or 0
In [62]: green = my_values.get('green',[''])[0] or 0
In [64]: red;blue;green
Out[64]: 0
In [65]: red
Out[65]: '5'
In [66]: blue
Out[66]: '0'
In [67]: green
Out[67]: 0
In [68]:
上面就用到了or操作符的使用，但如果还要对参数进行数字加减，还要使用Int
blue = int(my_values.get('blue',[''])[0] or 0 )
这样有点麻烦，就写成三元表达式
In [68]: red = my_values.get('red',[''])
In [69]: red = int(red[0]) if red[0] else 0
In [70]:
如果是一个参数还好，如果频发使用到的话，可以写一个辅助函数。
In [70]: def get_first_int(values,key,defalut=0):
...: found = values.get(key, [''])
...: if found[0]:
...: found = int(found[0])
...: else:
...: found = defalut
...: return found
...:
In [71]: get_first_int(my_values,'red')
Out[71]: 5
In [72]: get_first_int(my_values,'blue')
Out[72]: 0
In [73]:
好无聊的一个章节，这个书有点买亏了
第5条：了解切割序列的方法。
切片赋值属于浅拷贝，切片数值[a:b]取头不取尾，-1取最后一个数值，a就是头的下标不能越界。
后面讲了对切片进行赋值
In [91]: a = list(range(9)) In [92]: a Out[92]: [0, 1, 2, 3, 4, 5, 6, 7, 8] In [93]: a[2:5] = ['a','b'] In [94]: a Out[94]: [0, 1, 'a', 'b', 5, 6, 7, 8] In [95]:
都是一个套路，很多书中以前就有过介绍。
第6条 在单词切片中，不要同时指定start、end、stride
In [95]: a = list(range(10)) In [96]: a Out[96]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] In [97]: a[::3] Out[97]: [0, 3, 6, 9] In [98]: b = 'hello' In [99]: b[::-1] Out[99]: 'olleh' In [100]:
书中主要说了，如果有切片了，就不要写步进，分开好比较好，我觉的都无所谓。
第7条：用列表推导取代map和filter
列表推导式的强大，确实可以完全取代map与filter，reduce还是有点意思的。
In [100]: from functools import reduce In [101]: reduce(lambda x,y:x+y, range(10)) Out[101]: 45 In [102]: map(lambda x: x**2, range(10)) Out[102]: <map at 0x1142e4e90> In [103]: list(map(lambda x: x**2, range(10))) Out[103]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] In [104]: [x**2 for x in range(10)] Out[104]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] In [105]: list(filter(lambda x: x%2, range(10))) Out[105]: [1, 3, 5, 7, 9] In [107]: [x for x in range(10) if x%2!=0] Out[107]: [1, 3, 5, 7, 9] In [108]:
字典，集合都支持列表推导式的结构。
第8条:不要使用含有两个以上表达式的列表推导
双for的列表推导式，可以将矩阵（即二维列表）简化成维列表，也可以改变二维列表内的元素
In [113]: matrix = [[1,2,3],[4,5,6],[7,8,9]] In [114]: flat = [x for row in matrix for x in row] In [115]: flat Out[115]: [1, 2, 3, 4, 5, 6, 7, 8, 9] In [116]:
跟for循环的顺序一样，第一次循环写前面，第二次循环写后面
下面是改变矩阵的数据
In [118]: squared = [[x**2 for x in row] for row in matrix] In [119]: squared Out[119]: [[1, 4, 9], [16, 25, 36], [49, 64, 81]] In [120]:
但如果层数太多的话，就不建议使用列表推导式，应该会让人看过去很头痛。
列表推导式还支持多个if条件。
In [120]: a = list(range(1,11)) In [121]: a Out[121]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] In [122]: b = [x for x in a if x > 4 if x%2==0] In [123]: c = [x for x in a if x > 4 and x%2==0] In [124]: b Out[124]: [6, 8, 10] In [125]: b==c Out[125]: True In [126]:
可以看出两个答案是等价的。
每一层循环的for表达式后面都可以指定条件。
In [127]: filtered = [[x for x in row if x%3==0] for row in matrix if sum(row) >=10] In [128]: filtered Out[128]: [[6], [9]] In [129]:
这种写法还是很骚包的
第9条:用生成器表达式来改写数据量较大的列表推导
假如读取一份文件并返回每行的字符数，若采用列表推导来做，则需要文件每一行的长度度保存在内存中。
如果文件非常大，那可能会内存溢出或者运行很慢，可以采取生成器表达式，就是把[]换成()
it = (x for x in open('/tmp/file.txt'))
可以通过next函数对数据进行读取
使用生成器还有一个好处，就是可以互相组合。
In [129]: generatpr = (i for i in range(10)) In [130]: generatpr Out[130]: <generator object <genexpr> at 0x1144f0dd0> In [131]: roots = ((x,x**2) for x in generatpr) In [132]: next(roots) Out[132]: (0, 0) In [133]: next(roots) Out[133]: (1, 1) In [134]: next(roots) Out[134]: (2, 4) In [135]:
外围的迭代器每次前进时，都会推动内部那个迭代器，这就产生了连锁效应，使得执行循环、评估条件表达式、对接输入和输出等逻辑度组合在了一期。
第10条： 尽量用enumerate取代range
本章主要讲了enumerate可以将一个迭代器包装成一个生成器。而且包装的对象会自动加上索引。
In [7]: a = enumerate('0123')
In [8]: next(a)
Out[8]: (0, '0')
In [9]: next(a)
Out[9]: (1, '1')
In [10]: next(a)
Out[10]: (2, '2')
In [11]: next(a)
Out[11]: (3, '3')
In [12]: next(a)
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-12-15841f3f11d4> in <module>
----> 1 next(a)
StopIteration:
In [13]: b = enumerate('123',1)
In [14]: next(b)
Out[14]: (1, '1')
In [15]: next(b)
Out[15]: (2, '2')
In [16]:
感觉还是挺不错的，第二个参数是开始计数使用的值（默认为0）
第11条：用zip函数同事遍历两个迭代器
zip可以平行的遍历多个可迭代对象。
In [16]: z = zip('abc',[1,2,3])
In [17]: for chart, index in z:
...: print(chart, index)
...:
a 1
b 2
c 3
In [18]: for o in z:
...: print(o)
...:
...:
In [19]: z = zip('abc',[1,2,3])
In [20]: for o in z:
...: print(o)
...:
...:
('a', 1)
('b', 2)
('c', 3)
In [21]:
如果提供的可迭代对象长度不等，则以短的为准
In [21]: z = zip('a',range(3))
In [22]: next(z)
Out[22]: ('a', 0)
In [23]: next(z)
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-23-cf9ac561a401> in <module>
----> 1 next(z)
StopIteration:
In [24]:
如果想不在长度是否相等，可以用itertools.zip_longest
第12条：不要在for和while循环后面写else块
这个我个人其实觉的蛮好用的，很装逼，但很多进阶的书都说这种功能不是太好。
书中主要通过return的方式打断返回，或者在循环外部定义一个变量，break之前修改变量。
我感觉其实都不是太好，还for或者while+else好。
主要记住，正常循环完毕会执行else条件，如果中间打断了，就不执行else条件。
第13条：合理利用try/except/else/finally结构中的每个代码块
try：编写可能会报错的逻辑
except：捕获错误的信息
esle：写需要返回的结果情况，与try中可能存在的错误分离
finaly:写肯定会执行的逻辑
try，可以配合finaly直接使用
使用了else必须带上except
Chapter2
函数
第14条：尽量用异常来表示特殊请， 而不要返回None
编写工具函数的时候，有些程序员喜欢将错误捕获，直接返货None
def divide(a, b):
try:
return a / b
except ZeroDivisionError:
return None
这样会存在一些问题，很多时候，我们拿到函数运行，会直接把返回值拿到if条件中。
None的效果与0，空字符串，等效果相等，所以当分子是的0，分母不为0的时候，就会出现问题。
解决的方法应该不反悔None，而是把异常抛给上一级，使得调用者必须应对它。下面就是把ZeroDivisionError转换成ValueError，表示输入无效
def divide(a, b):
try:
return a / b
except ZeroDivisionError as e:
raise ValueError('Invalid inputs') from e
if __name__ == '__main__':
x, y = 5, 2
try:
res = divide(x, y)
except ValueError:
print('Invalid inputs')
else:
print('Result is %.1f' % res)
这个再写工具函数的时候确实一个不错的选择，错误的捕获可以上浮正确的错误形式，让上级去处理。
第15条： 了解如何在闭包里使用外围作用域中的变量
先来一个特定要求的排序，再特定组里面的数组排队优先，写的很棒
def sort_priority(values, group):
def helper(x):
if x in group:
return (0, x)
return (1, x)
values.sort(key=helper)
这是我两个月来见过写的最有意思的函数。
使用了闭包，内部函数引用了外包函数的变量，而且排序的时候，使用的多元素比较，第一元素比好以后，比第二元素。
后面书中讲了闭包的作用域问题LEGB，已经内部作用域可以引用外部作用域变量，可以修改外部作用域的可变对象。
但内部作用域与外部作用域变量名同名时，想修改外部作用域变量不能操作。因为赋值操作，当前作用域没有这个变量，会新建这么一个变量，有的话就修改。
书中也介绍了nolocal语句，来表明该变量名，可以修改外部变量的指向。但这个只能用再较短的函数，对于一些比较长的函数。使用class，内部建议__call__，到时候实例一个可调用的对象，对象内保存状态
def sort_priority(values, group):
found = False
def helper(x):
if x in group:
nonlocal found
found = True
return (0, x)
return (1, x)
values.sort(key=helper)
return found
nolocal的用法
def sort_priority(values, group):
sort_priority.found = False
def helper(x):
if x in group:
sort_priority.found = True
return (0, x)
return (1, x)
values.sort(key=helper)
return sort_priority.found
我自己想的通过函数对象赋值一个属性。
class Sorter:
def __init__(self, group):
self.group = group
self.found = False
def __call__(self, x):
if x in self.group:
self.found = True
return (0, x)
return (1, x)
上面时书上面特意写了一个用于被排序用的可调用对象。
在Python2中没有nolocal，可以在闭包的参数设置为可变参数，这样内部的函数就可以改变该参数的内部属性。
这个章节的一些内容以前看过，就当再理解一下，那个排序的写法，第一次看到，真的让我眼前一亮。
第16条： 考虑用生成器来改写直接返回列表的函数
def index_words(text):
result = []
if text:
result.append(0)
for index, letter in enumerate(text, 1):
if letter == ' ':
result.append(index)
return result
这个一个标准版的返回各个单词首字母索引的函数。书中说明，这个函数有两个不好的地方
1：函数内定义了一个result的列表，最后返回这么一个列表，显的很啰嗦
2：假如这个text很大，那这个列表也会输入量很大，那么程序就有可能耗尽内存并奔溃。
def index_words_iter(text):
if text:
yield 0
for index, letter in enumerate(text, 1):
if letter == ' ':
yield index
这种生成器的写法就可以避免这样的问题发生，而且用生成器表达更加清晰。
最后记录一下，书中一个处理文件的生成器函数
def index_file(handle):
offset = 0
for line in handle:
if line:
yield offset
# 这时真正函数运行消耗内存的地方，需要读取一行数据
for letter in line:
offset += 1
if letter == ' ':
yield offset
表名了处理文档，函数真正消耗内存的地方
第17条：在参数上面迭代时，要多加小心
一个函数如果对一个迭代器进行操作，务必要小心，因为迭代器保存一种状态，一但被读取完以后，就不能返回开始的状态。
def normalize(numbers):
total = sum(numbers)
result = []
for value in numbers:
percent = 100 * value / total
result.append(percent)
return result
visits = [15, 35, 80]
percentages = normalize(visits)
print(percentages)
这是一个函数，处理每个数据的百分比，当传入的是一个容器对象的时候就没事。
但传入一个迭代器的时候，就出问题了，sum函数会把迭代器里面的内容读取完毕，后面的for循环去读取numbers的时候，里面是没有数据的。
def normalize(numbers):
numbers = list(numbers)
total = sum(numbers)
result = []
for value in numbers:
percent = 100 * value / total
result.append(percent)
return result
这样是最简单偷懒的方式，但这样函数这样处理大数据的时候就会出问题，还有一个方式就是参数接收另外一个函数，那个函数调用完都会返回一个新的迭代器
def normalize_func(get_iter):
total = sum(get_iter())
result = []
for value in get_iter():
percent = 100 * value / total
result.append(percent)
return result
# 传入一个lambda函数，后面的是一个返回生成器的函数
percentahes = normalize_func(lambda : read_bisits(path))
这样看过去比较不舒服，那就自己定一个可迭代的容器。
class ReadVisits:
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)
visits = ReadVisits('/user/haha.txt')
percentages = normalize(visits)
通过自己定义的类，实例化以后的对象，当需要对这个容器进行操作的时候，都会调用__iter__方式返回的迭代器。比如sum，for，max，min等
迭代器协议有这样的约定：如果把迭代器对象传给内置的iter函数，那么此函数会把该迭代器返回，也就是返回自身，反之，如果传给iter函数的是个容器类型对象，那么iter函数则每次返回新的迭代器对象。
由于我们前面定义的函数需要处理容器对象，所以对进来的参数可以通过前面的方式进行过滤
def normalize_defensive(numbers):
# 判断是否是容器对象
if iter(numbers) is iter(numbers):
raise TypeError('Must suplly a container')
total = sum(numbers)
result = []
for value in numbers:
percent = 100 * value / total
result.append(percent)
return result
本章节我主要很好的学到了自定义容器对象，以及容器对象每次iter返回的都是不同内存地址的迭代器，也就是不同的对象。但迭代器iter返回的是自身。
而且可以看出来容器对象与迭代器没有啥必然的关系，两种也是各自为政的对象.
第18条:用数量可变的未知参数减少视觉杂讯
本条主要讲了*args接收不定长参数的使用。
def log(message, *value):
if not value:
print(message)
else:
value_str = ', '.join(str(x) for x in value)
print('%s: %s' % (message, value_str))
上面的例子中*value可以接收任意长度的参数，在函数内部value会转化成元祖
书中还有一个就是通过解包的方式传递参数
如果传递进去的是一个序列
l = [1,2,3,4]
可以在传递的时候通过*l的方式解包，里面的每一个元祖都会被视为位置参数，如果解包的是一个迭代器，如果数据过大就会消耗大量的内存。
第19条：用关键字参数来表达可选的行为。
def remainder(number, divisor):
return number % divisor
assert remainder(20, 7) == 6
上面的传参形式就是标准的位置传参。
可以通过下面的形式传参
remainder(20, divisor=7) remainder(numver=20, divisor=7) remainder(divisor=7, number=20)
Python中有规定，位置参数必须在关键字参数之前，每个参数只能被指定一次【也就是说，位置参数传参过以后，不能再通过关键字传参】
remainer(number=20, 7)
assert remainder(number=7, 20) == 6
^
SyntaxError: positional argument follows keyword argument
语法错误
emainder(20, number=7) == 6
assert remainder(20, number=7) == 6 TypeError: remainder() got multiple values for argument 'number'
类型错误
书中简单说明了关键字传参的好处，能让人了解，提供默认值，扩展函数参数的有效性。
第20条：用None和文档字符串来秒速具有默认值的参数。
import time
from datetime import datetime
def log(message, when=datetime.now()):
print('%s: %s' % (message, when))
log('Hi there !')
time.sleep(0.1)
log('Hi, again')
print(log.__defaults__)
输出
Hi there !: 2020-09-13 13:06:55.770035
Hi, again: 2020-09-13 13:06:55.770035
(datetime.datetime(2020, 9, 13, 13, 6, 55, 770035),)
流畅的Python中介绍，以及本人的理解，默认参数会成为函数对象的属性。在函数进行初始化的时候进行运行一次。
后面就不会再重新运行加载，所以会出现前面的情况。
import time
from datetime import datetime
def log(message, when=None):
when = datetime.now() if when is None else when
print('%s: %s' % (message, when))
log('Hi there !')
time.sleep(0.1)
log('Hi, again')
print(log.__defaults__)
改成上面这样
输出
Hi there !: 2020-09-13 13:10:11.295604 Hi, again: 2020-09-13 13:10:11.400005 (None,)
后面介绍了，传参给了一个可变对象，多人调用这个函数修改这个参数。
这个在流畅的Python中也有详细的介绍：
书中原文【在Python中，函数得到参数的副本，但是参数始终是引用。因此，如果参数引用的是可变对象，那么对象可能被修改，但是参数的表示不变】
第21条：用只能以关键字形式指定的参数来确保代码明晰
这里主要讲诉了如果传参必须要关键字传参的操作，
在Python3中可以通过*操作，
def demo(x,y,* must_show):
....
在Python2中没有*操作，只能通过**kwargs的方式接收关键字传参的不定长参数
然后在函数体内进行逻辑判断。
第三章 类与继承
第22条：尽量用辅助类来维护程序的状态，而不要用字典和元祖。
书中前面讲了，如果通过一个类保存一个复杂的数据结构状态。
如果保存程序的数据结构一旦变得过于复杂，就应该将其拆解为类，以便提供更为明确的接口。并更好的封装数据。这样做也能够在接口和具体实现之间创建抽象层。
后面都为本人的理解
最为对象层级最底层的grade（成绩），书中了用了nametuple进行了对象封装。
成绩对象的封装写法
import collections
# 一个权重，一个成绩
Grade = collections.namedtuple('Grade', ('score', 'weight'))
然后每一次成绩称为科目的对象的元素之一，科目有一个属性_grades的列表保存每一次成绩
class Subject:
def __init__(self):
self._grades = []
# 在科目对象装入成绩对象
def report_grade(self, score, weight):
self._grades.append(Grade(score, weight))
# 求出这门功课的平均分
def average_grade(self):
total, total_weight = 0, 0
for grade in self._grades:
total += grade.score * grade.weight
total_weight += grade.weight
return total / total_weight
科目可以称为学生的属性，一个学生会有很多科目。学生的科目用的是dictionaries保存
class Student:
def __init__(self):
self._subject = {}
# 写入一门功课
def subject(self, name):
return self._subject.setdefault(name, Subject())
# 求出一个学生所有功课的平均分
def average_grade(self):
total, count = 0, 0
for subject in self._subject.values():
total += subject.average_grade()
count += 1
return total / count
学生又是班级花名册里面的一个对象，所有最后定一个花名册
#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import collections
# 一个权重，一个成绩
Grade = collections.namedtuple('Grade', ('score', 'weight'))
class Subject:
def __init__(self):
self._grades = []
# 在科目对象装入成绩对象
def report_grade(self, score, weight):
self._grades.append(Grade(score, weight))
# 求出这门功课的平均分
def average_grade(self):
total, total_weight = 0, 0
for grade in self._grades:
total += grade.score * grade.weight
total_weight += grade.weight
return total / total_weight
class Student:
def __init__(self):
self._subject = {}
# 写入一门功课
def subject(self, name):
return self._subject.setdefault(name, Subject())
# 求出一个学生所有功课的平均分
def average_grade(self):
total, count = 0, 0
for subject in self._subject.values():
total += subject.average_grade()
count += 1
return total / count
class Gradebook:
def __init__(self):
self._student = {}
def student(self, name):
return self._student.setdefault(name, Student())
if __name__ == '__main__':
book = Gradebook()
# 学生
albert = book.student('Albert Einstein')
# 学生添加功课
math = albert.subject('Math')
# 功课添加成绩与权重
math.report_grade(90,0.3)
math.report_grade(95, 0.5)
print(book.student('Albert Einstein').average_grade())
上面直接上了，整体代码，首先定义一个成绩对象，需要几个属性就写几个，用了nametuple，然后成绩方位具体课程的对象中，由于一个课程可以有多门成绩，所以用列表来保存所有的成绩。
还在课程对象中直接定义了，该课程求出平均成绩的方法。
然后课程可以作为学生对象的元素，由于每个课程的都是一个独立的对象，考虑要后期需要取出该课程信息，所有用了dictionaries来保存，key是课程的名称，value是课程对象
后面同样的方式，把学生对象放入花名册。
这个其实主要考虑的是一个抽象的思考能力，在模型复杂的过程中，层层剥离对象，使一个对象称为另一个对象的属性。
书中的案例，是先写好最小的对象，层层方法，一个对象是另外一个的属性，这也是非常不错的思考方式，值的我学习，借鉴。
第23条：简单的接口应该接收函数，而不是类的实例。
def increment_with_report(current, increments):
added_count = 0
# 定义一个回调函数
def missing():
nonlocal added_count
added_count += 1
return 0
# 使用defaultdict调用missing函数
result = defaultdict(missing, current)
for key, amount in increments:
result[key] += amount
return result, added_count
result, count = increment_with_report(current, increments)
print(result)
print(count)
运行输出：
defaultdict(<function increment_with_report.<locals>.missing at 0x118403268>, {'green': 12, 'blue': 20, 'red': 5, 'orange': 9})
2
上面通过了使用了闭包，内部函数调用了外部的非全局变量。内部定义一个函数给当做回调函数。
通过闭包来保存一种状态也可以，当当过辅助类是一种相对更加好理解的方式
class BetterCountMissing:
def __init__(self):
self.added = 0
# 实例化以后， 称为一个可调用对象。
def __call__(self, *args, **kwargs):
self.added += 1
return 0
count = BetterCountMissing()
result = defaultdict(count, current)
for key, amount in increments:
result[key] += amount
print(count.added)
__call__方法强烈地暗示了该类的用途，它告诉我们，这个类的功能就相当与一个带有状态的闭包。
第24条：用@classmethod形式的多态去通用地构建对象。
在这一个章节，书中主要介绍了通过装饰器@classmethod，类方式去初始化一些特定的对象。还有就是介绍了一个有趣的模块 tempfile.TemporaryDirectory,建立一个临时目录，当对象删除的时候，目录也没了。
书中展示了一个输入处理类，和一个工作类的衔接。
#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import abc
import os
from threading import Thread
from tempfile import TemporaryDirectory
class InputData:
@abc.abstractmethod
def read(self):
raise NotImplementedError
# 处理输入的
class PathInputData(InputData):
def __init__(self, path):
super(PathInputData, self).__init__()
self.path = path
def read(self):
return open(self.path).read()
# 工作线程基类
class Worker:
def __init__(self, input_data):
self.input_data = input_data
self.result = None
@abc.abstractmethod
def map(self):
raise NotImplementedError
@abc.abstractmethod
def reduce(self, other):
raise NotImplementedError
# 处理有几行的工作类
class LineCountWorker(Worker):
def map(self):
data = self.input_data.read()
self.result = data.count('\n')
def reduce(self, other):
self.result += other.result
# 返回文件夹下面所有文件的处理对象生成器
def generate_inputs(data_dir):
for name in os.listdir(data_dir):
yield PathInputData(os.path.join(data_dir, name))
# 返回的处理文档对象，建立工作实例对象列表
def create_workers(input_list):
workers = []
for input_data in input_list:
workers.append(LineCountWorker(input_data))
return workers
# 最后面多线程执行工作对象
def execute(workers):
threads = [Thread(target=w.map) for w in workers]
for thread in threads: thread.start()
for thread in threads: thread.join()
first, rest = workers[0], workers[1:]
for worker in rest:
first.reduce(worker)
return first.result
# 然后把前面的打包成一个函数
def mapreduce(data_dir):
inputs = generate_inputs(data_dir)
workers = create_workers(inputs)
return execute(workers)
def write_test_files(tmpdir):
for i in 'abcde':
abs_path = os.path.join(tmpdir, i)
with open(abs_path, 'w') as f:
f.writelines(['2', '\n', '3','\n'])
with TemporaryDirectory() as tmpdir:
print(tmpdir)
write_test_files(tmpdir)
result = mapreduce(tmpdir)
print('There are', result, 'lines')
书中通过对象的调用，函数式的方式完成了任务
但是这个写法有个大问题，那就是mapreduce函数不够通用。如果要编写其它的InputData或Woker子类，那就要重写generate_inpurs, create_workers, mapreduce函数，以便与之匹配。
书中不知道是翻译的僵硬，还是我的理解能力不够，主要介绍了，编写基类的方式，通过类方法的继承实现类方法的多态，返回所需要的要求
# 基类
class GenericInputData:
def read(self):
raise NotImplementedError
@classmethod
def generate_inputs(cls, config):
raise NotImplementedError
class PathInputData(GenericInputData):
def __init__(self, path):
self.path = path
def read(self):
return open(self.path).read()
# 类方法直接返回一个生成器
@classmethod
def generate_inputs(cls, config):
data_dir = config['data_dir']
for name in os.listdir(data_dir):
yield cls(os.path.join(data_dir, name))
# 工作的基类
class GenericWorker:
def __init__(self, input_data):
self.input_data = input_data
self.result = None
def map(self):
raise NotImplementedError
def reduce(self, other):
raise NotImplementedError
# 返回需要处理的的workers容器列表
@classmethod
def create_workers(cls, input_class, config):
workers = []
# 调用前面的类方法，产生的生成器
for input_data in input_class.generate_inputs(config):
workers.append(cls(input_data))
return workers
class LineCountWorker(GenericWorker):
def map(self):
data = self.input_data.read()
self.result = data.count('\n')
def reduce(self, other):
self.result += other.result
def mapreduce(worker_class, input_class, config):
workers = worker_class.create_workers(input_class, config)
return execute(workers)
with TemporaryDirectory() as tmpdir:
write_test_files(tmpdir)
config = {'data_dir': tmpdir}
result = mapreduce(LineCountWorker, PathInputData, config)
print(result)
这是书中通过类方法的方式写的，通过定义通用接口。
在Python中，类只有一个构造器函数__init__，可以通过@classmethod的方式来丰富创建对象的形式。按照就可以直接通过类方法，返回列表，生成器等。__init__可是没有返回值的。
第25条 用super初始化父类
