lee-coder
diff --git a/‎source/c01/p01_unpack_sequence_into_separate_variables.rst
+4-4 b/‎source/c01/p01_unpack_sequence_into_separate_variables.rst
+4-4
diff --git a/‎source/c01/p02_unpack_elements_from_iterables.rst
+12-13 b/‎source/c01/p02_unpack_elements_from_iterables.rst
+12-13
diff --git a/‎source/c01/p03_keep_last_n_items.rst
+7-8 b/‎source/c01/p03_keep_last_n_items.rst
+7-8
diff --git a/‎source/c01/p04_find_largest_or_smallest_n_items.rst
+15-14 b/‎source/c01/p04_find_largest_or_smallest_n_items.rst
+15-14
diff --git a/‎source/c01/p05_implement_a_priority_queue.rst
+7-8 b/‎source/c01/p05_implement_a_priority_queue.rst
+7-8
diff --git a/‎source/c01/p06_map_keys_to_multiple_values_in_dict.rst
+4-4 b/‎source/c01/p06_map_keys_to_multiple_values_in_dict.rst
+4-4
diff --git a/‎source/c01/p07_keep_dict_in_order.rst
+2-2 b/‎source/c01/p07_keep_dict_in_order.rst
+2-2
diff --git a/‎source/c01/p08_calculating_with_dict.rst
+4-4 b/‎source/c01/p08_calculating_with_dict.rst
+4-4
diff --git a/‎source/c01/p09_find_commonalities_in_dicts.rst
+4-5 b/‎source/c01/p09_find_commonalities_in_dicts.rst
+4-5
@@ -5,12 +5,12 @@
 ----------
 问题
 ----------
-现在有一个包含N个元素的元组或者是序列，怎样将它里面的值解压后同时赋值给N个变量？
+现在有一个包含 N 个元素的元组或者是序列，怎样将它里面的值解压后同时赋值给 N 个变量？
 
 ----------
 解决方案
 ----------
-任何的序列(或者是可迭代对象)可以通过一个简单的赋值语句解压并赋值给多个变量。
+任何的序列（或者是可迭代对象）可以通过一个简单的赋值语句解压并赋值给多个变量。
 唯一的前提就是变量的数量必须跟序列元素的数量是一样的。
 
 代码示例：
@@ -74,7 +74,7 @@
     'o'
     >>>
 
-有时候，你可能只想解压一部分，丢弃其他的值。对于这种情况Python并没有提供特殊的语法。
+有时候，你可能只想解压一部分，丢弃其他的值。对于这种情况 Python 并没有提供特殊的语法。
 但是你可以使用任意变量名去占位，到时候丢掉这些变量就行了。
 
 代码示例：
@@ -89,4 +89,4 @@
     91.1
     >>>
 
-你必须保证你选用的那些占位变量名在其他地方没被使用到。
+你必须保证你选用的那些占位变量名在其他地方没被使用到。
@@ -6,14 +6,14 @@
 问题
 ----------
 如果一个可迭代对象的元素个数超过变量个数时，会抛出一个 ``ValueError`` 。
-那么怎样才能从这个可迭代对象中解压出N个元素出来？
+那么怎样才能从这个可迭代对象中解压出 N 个元素出来？
 
 ----------
 解决方案
 ----------
-Python的星号表达式可以用来解决这个问题。比如，你在学习一门课程，在学期末的时候，
+Python 的星号表达式可以用来解决这个问题。比如，你在学习一门课程，在学期末的时候，
 你想统计下家庭作业的平均成绩，但是排除掉第一个和最后一个分数。如果只有四个分数，你可能就直接去简单的手动赋值，
-但如果有24个呢？这时候星号表达式就派上用场了：
+但如果有 24 个呢？这时候星号表达式就派上用场了：
 
 .. code-block:: python
 
@@ -35,19 +35,19 @@ Python的星号表达式可以用来解决这个问题。比如，你在学习
     >>> phone_numbers
     ['773-555-1212', '847-555-1212']
     >>>
-值得注意的是上面解压出的 ``phone_numbers`` 变量永远都是列表类型，不管解压的电话号码数量是多少(包括0个)。
+值得注意的是上面解压出的 ``phone_numbers`` 变量永远都是列表类型，不管解压的电话号码数量是多少（包括 0 个）。
 所以，任何使用到 ``phone_numbers`` 变量的代码就不需要做多余的类型检查去确认它是否是列表类型了。
 
-星号表达式也能用在列表的开始部分。比如，你有一个公司前8个月销售数据的序列，
-但是你想看下最近一个月数据和前面7个月的平均值的对比。你可以这样做：
+星号表达式也能用在列表的开始部分。比如，你有一个公司前 8 个月销售数据的序列，
+但是你想看下最近一个月数据和前面 7 个月的平均值的对比。你可以这样做：
 
 .. code-block:: python
 
     *trailing_qtrs, current_qtr = sales_record
     trailing_avg = sum(trailing_qtrs) / len(trailing_qtrs)
     return avg_comparison(trailing_avg, current_qtr)
 
-下面是在Python解释器中执行的结果：
+下面是在 Python 解释器中执行的结果：
 
 .. code-block:: python
 
@@ -61,7 +61,7 @@ Python的星号表达式可以用来解决这个问题。比如，你在学习
 讨论
 ----------
 扩展的迭代解压语法是专门为解压不确定个数或任意个数元素的可迭代对象而设计的。
-通常，这些可迭代对象的元素结构有确定的规则（比如第1个元素后面都是电话号码），
+通常，这些可迭代对象的元素结构有确定的规则（比如第 1 个元素后面都是电话号码），
 星号表达式让开发人员可以很容易的利用这些规则来解压出元素来。
 而不是通过一些比较复杂的手段去获取这些关联的的元素值。
 
@@ -105,7 +105,7 @@ Python的星号表达式可以用来解决这个问题。比如，你在学习
     >>>
 
 有时候，你想解压一些元素后丢弃它们，你不能简单就使用 ``*`` ，
-但是你可以使用一个普通的废弃名称，比如 ``_`` 或者 ``ign`` 。
+但是你可以使用一个普通的废弃名称，比如 ``_`` 或者 ``ign`` （ignore）。
 
 代码示例：
 
@@ -137,13 +137,12 @@ Python的星号表达式可以用来解决这个问题。比如，你在学习
 .. code-block:: python
 
     >>> def sum(items):
-    ... head, *tail = items
-    ... return head + sum(tail) if tail else head
+    ...     head, *tail = items
+    ...     return head + sum(tail) if tail else head
     ...
     >>> sum(items)
     36
     >>>
 
-然后，由于语言层面的限制，递归并不是Python擅长的。
+然后，由于语言层面的限制，递归并不是 Python 擅长的。
 因此，最后那个递归演示仅仅是个好奇的探索罢了，对这个不要太认真了。
-
@@ -1,5 +1,5 @@
 ================================
-1.3 保留最后N个元素
+1.3 保留最后 N 个元素
 ================================
 
 ----------
@@ -20,10 +20,10 @@
 
     def search(lines, pattern, history=5):
         previous_lines = deque(maxlen=history)
-        for li in lines:
-            if pattern in li:
-                yield li, previous_lines
-            previous_lines.append(li)
+        for line in lines:
+            if pattern in line:
+                yield line, previous_lines
+            previous_lines.append(line)
 
     # Example use on a file
     if __name__ == '__main__':
@@ -38,7 +38,7 @@
 讨论
 ----------
 我们在写查询元素的代码时，通常会使用包含 ``yield`` 表达式的生成器函数，也就是我们上面示例代码中的那样。
-这样可以将搜索过程代码和使用搜索结果代码解耦。如果你还不清楚什么是生成器，请参看4.3节。
+这样可以将搜索过程代码和使用搜索结果代码解耦。如果你还不清楚什么是生成器，请参看 4.3 节。
 
 使用 ``deque(maxlen=N)`` 构造函数会新建一个固定大小的队列。当新的元素加入并且这个队列已满的时候，
 最老的元素会自动被移除掉。
@@ -60,7 +60,7 @@
     >>> q
     deque([3, 4, 5], maxlen=3)
 
-尽管你也可以手动在一个列表上实现这一的操作(比如增加、删除等等)。但是这里的队列方案会更加优雅并且运行得更快些。
+尽管你也可以手动在一个列表上实现这一的操作（比如增加、删除等等）。但是这里的队列方案会更加优雅并且运行得更快些。
 
 更一般的， ``deque`` 类可以被用在任何你只需要一个简单队列数据结构的场合。
 如果你不设置最大队列大小，那么就会得到一个无限大小队列，你可以在队列的两端执行添加和弹出元素的操作。
@@ -86,4 +86,3 @@
     4
 
 在队列两端插入或删除元素时间复杂度都是 ``O(1)`` ，而在列表的开头插入或删除元素的时间复杂度为 ``O(N)`` 。
-
@@ -1,16 +1,16 @@
 ================================
-1.4 查找最大或最小的N个元素
+1.4 查找最大或最小的 N 个元素
 ================================
 
 ----------
 问题
 ----------
-怎样从一个集合中获得最大或者最小的N个元素列表？
+怎样从一个集合中获得最大或者最小的 N 个元素列表？
 
 ----------
 解决方案
 ----------
-heapq模块有两个函数：``nlargest()`` 和 ``nsmallest()`` 可以完美解决这个问题。
+heapq 模块有两个函数：``nlargest()`` 和 ``nsmallest()`` 可以完美解决这个问题。
 
 .. code-block:: python
 
@@ -39,37 +39,38 @@ heapq模块有两个函数：``nlargest()`` 和 ``nsmallest()`` 可以完美解
 ----------
 讨论
 ----------
-如果你想在一个集合中查找最小或最大的N个元素，并且N小于集合元素数量，那么这些函数提供了很好的性能。
+如果你想在一个集合中查找最小或最大的 N 个元素，并且 N 小于集合元素数量，那么这些函数提供了很好的性能。
 因为在底层实现里面，首先会先将集合数据进行堆排序后放入一个列表中：
 
 .. code-block:: python
 
     >>> nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]
     >>> import heapq
-    >>> heapq.heapify(nums)
+    >>> heap = list(nums)
+    >>> heapq.heapify(heap)
     >>> nums
     [-4, 2, 1, 23, 7, 2, 18, 23, 42, 37, 8]
     >>>
 
 堆数据结构最重要的特征是 ``heap[0]`` 永远是最小的元素。并且剩余的元素可以很容易的通过调用 ``heapq.heappop()`` 方法得到，
-该方法会先将第一个元素弹出来，然后用下一个最小的元素来取代被弹出元素(这种操作时间复杂度仅仅是O(log N)，N是堆大小)。
-比如，如果想要查找最小的3个元素，你可以这样做：
+该方法会先将第一个元素弹出来，然后用下一个最小的元素来取代被弹出元素（这种操作时间复杂度仅仅是 O(log N)，N 是堆大小）。
+比如，如果想要查找最小的 3 个元素，你可以这样做：
 
 .. code-block:: python
 
-    >>> heapq.heappop(nums)
+    >>> heapq.heappop(heap)
     -4
-    >>> heapq.heappop(nums)
+    >>> heapq.heappop(heap)
     1
-    >>> heapq.heappop(nums)
+    >>> heapq.heappop(heap)
     2
 
 当要查找的元素个数相对比较小的时候，函数 ``nlargest()`` 和 ``nsmallest()`` 是很合适的。
-如果你仅仅想查找唯一的最小或最大(N=1)的元素的话，那么使用 ``min()`` 和 ``max()`` 函数会更快些。
-类似的，如果N的大小和集合大小接近的时候，通常先排序这个集合然后再使用切片操作会更快点
-( ``sorted(items)[:N]`` 或者是 ``sorted(items)[-N:]`` )。
+如果你仅仅想查找唯一的最小或最大（N=1）的元素的话，那么使用 ``min()`` 和 ``max()`` 函数会更快些。
+类似的，如果 N 的大小和集合大小接近的时候，通常先排序这个集合然后再使用切片操作会更快点
+（ ``sorted(items)[:N]`` 或者是 ``sorted(items)[-N:]`` ）。
 需要在正确场合使用函数 ``nlargest()`` 和 ``nsmallest()`` 才能发挥它们的优势
-(如果N快接近集合大小了，那么使用排序操作会更好些)。
+（如果 N 快接近集合大小了，那么使用排序操作会更好些）。
 
 尽管你没有必要一定使用这里的方法，但是堆数据结构的实现是一个很有趣并且值得你深入学习的东西。
 基本上只要是数据结构和算法书籍里面都会有提及到。
 
@@ -5,7 +5,7 @@
 ----------
 问题
 ----------
-怎样实现一个按优先级排序的队列？ 并且在这个队列上面每次pop操作总是返回优先级最高的那个元素
+怎样实现一个按优先级排序的队列？ 并且在这个队列上面每次 pop 操作总是返回优先级最高的那个元素
 
 ----------
 解决方案
@@ -55,16 +55,16 @@
     >>>
 
 仔细观察可以发现，第一个 ``pop()`` 操作返回优先级最高的元素。
-另外注意到如果两个有着相同优先级的元素( ``foo`` 和 ``grok`` )，pop操作按照它们被插入到队列的顺序返回的。
+另外注意到如果两个有着相同优先级的元素（ ``foo`` 和 ``grok`` ），pop 操作按照它们被插入到队列的顺序返回的。
 
 ----------
 讨论
 ----------
 这一小节我们主要关注 ``heapq`` 模块的使用。
 函数 ``heapq.heappush()`` 和 ``heapq.heappop()`` 分别在队列 ``_queue`` 上插入和删除第一个元素，
-并且队列_queue保证第一个元素拥有最高优先级(1.4节已经讨论过这个问题)。
+并且队列 ``_queue`` 保证第一个元素拥有最高优先级（ 1.4 节已经讨论过这个问题）。
 ``heappop()`` 函数总是返回"最小的"的元素，这就是保证队列pop操作返回正确元素的关键。
-另外，由于push和pop操作时间复杂度为O(log N)，其中N是堆的大小，因此就算是N很大的时候它们运行速度也依旧很快。
+另外，由于 push 和 pop 操作时间复杂度为 O(log N)，其中 N 是堆的大小，因此就算是 N 很大的时候它们运行速度也依旧很快。
 
 在上面代码中，队列包含了一个 ``(-priority, index, item)`` 的元组。
 优先级为负数的目的是使得元素按照优先级从高到低排序。
@@ -74,7 +74,7 @@
 通过保存一个不断增加的 ``index`` 下标变量，可以确保元素按照它们插入的顺序排序。
 而且， ``index`` 变量也在相同优先级元素比较的时候起到重要作用。
 
-为了阐明这些，先假定Item实例是不支持排序的：
+为了阐明这些，先假定 ``Item`` 实例是不支持排序的：
 
 .. code-block:: python
 
@@ -103,7 +103,7 @@
     >>>
 
 通过引入另外的 ``index`` 变量组成三元组 ``(priority, index, item)`` ，就能很好的避免上面的错误，
-因为不可能有两个元素有相同的 ``index`` 值。Python在做元组比较时候，如果前面的比较已经可以确定结果了，
+因为不可能有两个元素有相同的 ``index`` 值。Python 在做元组比较时候，如果前面的比较已经可以确定结果了，
 后面的比较操作就不会发生了：
 
 .. code-block:: python
@@ -118,7 +118,6 @@
     >>>
 
 如果你想在多个线程中使用同一个队列，那么你需要增加适当的锁和信号量机制。
-可以查看12.3小节的例子演示是怎样做的。
+可以查看 12.3 小节的例子演示是怎样做的。
 
 ``heapq`` 模块的官方文档有更详细的例子程序以及对于堆理论及其实现的详细说明。
-
@@ -5,7 +5,7 @@
 ----------
 问题
 ----------
-怎样实现一个键对应多个值的字典(也叫 ``multidict`` )？
+怎样实现一个键对应多个值的字典（也叫 ``multidict``）？
 
 ----------
 解决方案
@@ -44,7 +44,7 @@
     d['a'].add(2)
     d['b'].add(4)
 
-需要注意的是， ``defaultdict`` 会自动为将要访问的键(就算目前字典中并不存在这样的键)创建映射实体。
+需要注意的是， ``defaultdict`` 会自动为将要访问的键（就算目前字典中并不存在这样的键）创建映射实体。
 如果你并不需要这样的特性，你可以在一个普通的字典上使用 ``setdefault()`` 方法来代替。比如：
 
 .. code-block:: python
@@ -54,7 +54,7 @@
     d.setdefault('a', []).append(2)
     d.setdefault('b', []).append(4)
 
-但是很多程序员觉得 ``setdefault()`` 用起来有点别扭。因为每次调用都得创建一个新的初始值的实例(例子程序中的空列表 ``[]`` )。
+但是很多程序员觉得 ``setdefault()`` 用起来有点别扭。因为每次调用都得创建一个新的初始值的实例（例子程序中的空列表 ``[]`` ）。
 
 ----------
 讨论
@@ -78,4 +78,4 @@
     for key, value in pairs:
         d[key].append(value)
 
-这一小节所讨论的问题跟数据处理中的记录归类问题有大的关联。可以参考1.15小节的例子。
+这一小节所讨论的问题跟数据处理中的记录归类问题有大的关联。可以参考 1.15 小节的例子。
@@ -27,7 +27,7 @@
         print(key, d[key])
 
 当你想要构建一个将来需要序列化或编码成其他格式的映射的时候， ``OrderedDict`` 是非常有用的。
-比如，你想精确控制以JSON编码后字段的顺序，你可以先使用 ``OrderedDict`` 来构建这样的数据：
+比如，你想精确控制以 JSON 编码后字段的顺序，你可以先使用 ``OrderedDict`` 来构建这样的数据：
 
 .. code-block:: python
 
@@ -43,5 +43,5 @@
 它会被放到链表的尾部。对于一个已经存在的键的重复赋值不会改变键的顺序。
 
 需要注意的是，一个 ``OrderedDict`` 的大小是一个普通字典的两倍，因为它内部维护着另外一个链表。
-所以如果你要构建一个需要大量 ``OrderedDict`` 实例的数据结构的时候(比如读取100,000行CSV数据到一个 ``OrderedDict`` 列表中去)，
+所以如果你要构建一个需要大量 ``OrderedDict`` 实例的数据结构的时候（比如读取 100,000 行 CSV 数据到一个 ``OrderedDict`` 列表中去），
 那么你就得仔细权衡一下是否使用 ``OrderedDict`` 带来的好处要大过额外内存消耗的影响。
@@ -5,7 +5,7 @@
 ----------
 问题
 ----------
-怎样在数据字典中执行一些计算操作(比如求最小值、最大值、排序等等)？
+怎样在数据字典中执行一些计算操作（比如求最小值、最大值、排序等等）？
 
 ----------
 解决方案
@@ -69,7 +69,7 @@
     max(prices.values()) # Returns 612.78
 
 不幸的是，通常这个结果同样也不是你想要的。
-你可能还想要知道对应的键的信息(比如那种股票价格是最低的？)。
+你可能还想要知道对应的键的信息（比如那种股票价格是最低的？）。
 
 你可以在 ``min()`` 和 ``max()`` 函数中提供 ``key`` 函数参数来获取最小值或最大值对应的键的信息。比如：
 
@@ -84,11 +84,11 @@
 
     min_value = prices[min(prices, key=lambda k: prices[k])]
 
-前面的 ``zip()`` 函数方案通过将字典"反转"为(值，键)元组序列来解决了上述问题。
+前面的 ``zip()`` 函数方案通过将字典"反转"为 (值，键) 元组序列来解决了上述问题。
 当比较两个元组的时候，值会先进行比较，然后才是键。
 这样的话你就能通过一条简单的语句就能很轻松的实现在字典上的求最值和排序操作了。
 
-需要注意的是在计算操作中使用到了(值，键)对。当多个实体拥有相同的值的时候，键会决定返回结果。
+需要注意的是在计算操作中使用到了 (值，键) 对。当多个实体拥有相同的值的时候，键会决定返回结果。
 比如，在执行 ``min()`` 和 ``max()`` 操作的时候，如果恰巧最小或最大值有重复的，那么拥有最小或最大键的实体会返回：
 
 .. code-block:: python
 
@@ -5,7 +5,7 @@
 ----------
 问题
 ----------
-怎样在两个字典中寻寻找相同点(比如相同的键、相同的值等等)？
+怎样在两个字典中寻寻找相同点（比如相同的键、相同的值等等）？
 
 ----------
 解决方案
@@ -53,12 +53,11 @@
 一个字典就是一个键集合与值集合的映射关系。
 字典的 ``keys()`` 方法返回一个展现键集合的键视图对象。
 键视图的一个很少被了解的特性就是它们也支持集合操作，比如集合并、交、差运算。
-所以，如果你想对集合的键执行一些普通的集合操作，可以直接使用键视图对象而不用先将它们转换成一个set。
+所以，如果你想对集合的键执行一些普通的集合操作，可以直接使用键视图对象而不用先将它们转换成一个 set。
 
-字典的 ``items()`` 方法返回一个包含(键，值)对的元素视图对象。
+字典的 ``items()`` 方法返回一个包含 (键，值) 对的元素视图对象。
 这个对象同样也支持集合操作，并且可以被用来查找两个字典有哪些相同的键值对。
 
 尽管字典的 ``values()`` 方法也是类似，但是它并不支持这里介绍的集合操作。
 某种程度上是因为值视图不能保证所有的值互不相同，这样会导致某些集合操作会出现问题。
-不过，如果你硬要在值上面执行这些集合操作的话，你可以先将值集合转换成set，然后再执行集合运算就行了。
-
+不过，如果你硬要在值上面执行这些集合操作的话，你可以先将值集合转换成 set，然后再执行集合运算就行了。