[po] auto sync bot

zhsj · zhsj · commit 780c83cd69a4 · 2019-09-14T08:03:43.000+08:00
diff --git a/library/heapq.po b/library/heapq.po
@@ -5,9 +5,9 @@
 # 
 # Translators:
 # Jerry Chen <jerrychen9657@gmail.com>, 2017
-# Freesand Leo <yuqinju@163.com>, 2019
 # Meng Du <alphanow@gmail.com>, 2019
 # iceyasha <IceYasha@gmail.com>, 2019
+# Freesand Leo <yuqinju@163.com>, 2019
 # 
 #, fuzzy
 msgid ""
@@ -16,7 +16,7 @@ msgstr ""
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2019-09-01 14:24+0000\n"
 "PO-Revision-Date: 2017-02-16 23:13+0000\n"
-"Last-Translator: iceyasha <IceYasha@gmail.com>, 2019\n"
+"Last-Translator: Freesand Leo <yuqinju@163.com>, 2019\n"
 "Language-Team: Chinese (China) (https://www.transifex.com/python-doc/teams/5390/zh_CN/)\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
@@ -47,9 +47,9 @@ msgid ""
 "elements are considered to be infinite.  The interesting property of a heap "
 "is that its smallest element is always the root, ``heap[0]``."
 msgstr ""
-"堆是一个二叉树，它的每个父节点的值都只会小于或大于所有孩子节点（的值）。它使用了数组来实现：从零开始计数，对于所有的 *k* ，都有``heap[k] "
-"<= heap[2*k+1]`` 和 ``heap[k] <= heap[2*k+2]`` "
-"。为了便于比较，不存在的元素被认为是无限大。堆最有趣的特性在于最小的元素总是在根结点：``heap[0]`` 。"
+"堆是一个二叉树，它的每个父节点的值都只会小于或大于所有孩子节点（的值）。它使用了数组来实现：从零开始计数，对于所有的 *k* ，都有 ``heap[k]"
+" <= heap[2*k+1]`` 和 ``heap[k] <= heap[2*k+2]``。 为了便于比较，不存在的元素被认为是无限大。 "
+"堆最有趣的特性在于最小的元素总是在根结点：``heap[0]``。"
 
 #: ../../library/heapq.rst:26
 msgid ""
@@ -61,15 +61,17 @@ msgid ""
 "\"max heap\" is more common in texts because of its suitability for in-place"
 " sorting)."
 msgstr ""
-"这个API与教材的堆算法实现不太一样，在于两方面：（a）我们使用了基于零开始进行索引。这使得节点和其孩子节点索引之间的关系不太直观，但是更加适合"
+"这个API与教材的堆算法实现有所不同，具体区别有两方面：（a）我们使用了从零开始的索引。这使得节点和其孩子节点索引之间的关系不太直观但更加适合，因为 "
+"Python 使用从零开始的索引。 （b）我们的 pop "
+"方法返回最小的项而不是最大的项（这在教材中称为“最小堆”；而“最大堆”在教材中更为常见，因为它更适用于原地排序）。"
 
 #: ../../library/heapq.rst:33
 msgid ""
 "These two make it possible to view the heap as a regular Python list without"
 " surprises: ``heap[0]`` is the smallest item, and ``heap.sort()`` maintains "
 "the heap invariant!"
 msgstr ""
-"基于这两方面，把堆看作原生的Python list也没什么奇怪的： ``heap[0]`` 表示最小的元素，同时 ``heap.sort()`` "
+"基于这两方面，把堆看作原生的Python list也没什么奇怪的： ``heap[0]`` 表示最小的元素，同时 ``heap.sort()`` "
 "维护了堆的不变性！"
 
 #: ../../library/heapq.rst:37
@@ -107,14 +109,15 @@ msgstr ""
 
 #: ../../library/heapq.rst:64
 msgid "Transform list *x* into a heap, in-place, in linear time."
-msgstr "将list *x* 转换成堆，原地，线性时间内。"
+msgstr "将list *x* 转换成堆，原地，线性时间内。"
 
 #: ../../library/heapq.rst:69
 msgid ""
 "Pop and return the smallest item from the *heap*, and also push the new "
 "*item*. The heap size doesn't change. If the heap is empty, "
 ":exc:`IndexError` is raised."
 msgstr ""
+"弹出并返回 *heap* 中最小的一项，同时推入新的 *item*。 堆的大小不变。 如果堆为空则引发 :exc:`IndexError`。"
 
 #: ../../library/heapq.rst:72
 msgid ""
@@ -123,6 +126,8 @@ msgid ""
 "The pop/push combination always returns an element from the heap and "
 "replaces it with *item*."
 msgstr ""
+"这个单步骤操作比 :func:`heappop` 加 :func:`heappush` 更高效，并且在使用固定大小的堆时更为适宜。 pop/push "
+"组合总是会从堆中返回一个元素并将其替换为 *item*。"
 
 #: ../../library/heapq.rst:77
 msgid ""
@@ -131,24 +136,29 @@ msgid ""
 "combination returns the smaller of the two values, leaving the larger value "
 "on the heap."
 msgstr ""
+"返回的值可能会比添加的 *item* 更大。 如果不希望如此，可考虑改用 :func:`heappushpop`。 它的 push/pop "
+"组合会返回两个值中较小的一个，将较大的值留在堆中。"
 
 #: ../../library/heapq.rst:83
 msgid "The module also offers three general purpose functions based on heaps."
-msgstr ""
+msgstr "该模块还提供了三个基于堆的通用功能函数。"
 
 #: ../../library/heapq.rst:88
 msgid ""
 "Merge multiple sorted inputs into a single sorted output (for example, merge"
 " timestamped entries from multiple log files).  Returns an :term:`iterator` "
 "over the sorted values."
 msgstr ""
+"将多个已排序的输入合并为一个已排序的输出（例如，合并来自多个日志文件的带时间戳的条目）。 返回已排序值的 :term:`iterator`。"
 
 #: ../../library/heapq.rst:92
 msgid ""
 "Similar to ``sorted(itertools.chain(*iterables))`` but returns an iterable, "
 "does not pull the data into memory all at once, and assumes that each of the"
 " input streams is already sorted (smallest to largest)."
 msgstr ""
+"类似于 ``sorted(itertools.chain(*iterables))`` "
+"但返回一个可迭代对象，不会一次性地将数据全部放入内存，并假定每个输入流都是已排序的（从小到大）。"
 
 #: ../../library/heapq.rst:96
 msgid ""
@@ -161,6 +171,8 @@ msgid ""
 "extract a comparison key from each input element.  The default value is "
 "``None`` (compare the elements directly)."
 msgstr ""
+"*key* 指定带有单个参数的 :term:`key function`，用于从每个输入元素中提取比较键。 默认值为 ``None`` "
+"(直接比较元素)。"
 
 #: ../../library/heapq.rst:102
 msgid ""
@@ -169,10 +181,13 @@ msgid ""
 "to ``sorted(itertools.chain(*iterables), reverse=True)``, all iterables must"
 " be sorted from largest to smallest."
 msgstr ""
+"*reverse* 为一个布尔值。 如果设为 ``True``，则输入元素将按比较结果逆序进行合并。 要达成与 "
+"``sorted(itertools.chain(*iterables), reverse=True)`` "
+"类似的行为，所有可迭代对象必须是已从大到小排序的。"
 
 #: ../../library/heapq.rst:107
 msgid "Added the optional *key* and *reverse* parameters."
-msgstr ""
+msgstr "添加了可选的 *key* 和 *reverse* 形参。"
 
 #: ../../library/heapq.rst:113
 msgid ""
@@ -182,6 +197,9 @@ msgid ""
 "example, ``key=str.lower``).  Equivalent to:  ``sorted(iterable, key=key, "
 "reverse=True)[:n]``."
 msgstr ""
+"从 *iterable* 所定义的数据集中返回前 *n* 个最大元素组成的列表。 如果提供了 *key* 则其应指定一个单参数的函数，用于从 "
+"*iterable* 的每个元素中提取比较键 (例如 ``key=str.lower``)。 等价于:  ``sorted(iterable, "
+"key=key, reverse=True)[:n]``。"
 
 #: ../../library/heapq.rst:122
 msgid ""
@@ -191,6 +209,9 @@ msgid ""
 "example, ``key=str.lower``).  Equivalent to:  ``sorted(iterable, "
 "key=key)[:n]``."
 msgstr ""
+"从 *iterable* 所定义的数据集中返回前 *n* 个最小元素组成的列表。 如果提供了 *key* 则其应指定一个单参数的函数，用于从 "
+"*iterable* 的每个元素中提取比较键 (例如 ``key=str.lower``)。 等价于: ``sorted(iterable, "
+"key=key)[:n]``。"
 
 #: ../../library/heapq.rst:128
 msgid ""
@@ -200,6 +221,8 @@ msgid ""
 ":func:`max` functions.  If repeated usage of these functions is required, "
 "consider turning the iterable into an actual heap."
 msgstr ""
+"后两个函数在 *n* 值较小时性能最好。 对于更大的值，使用 :func:`sorted` 函数会更有效率。 此外，当 ``n==1`` 时，使用内置的"
+" :func:`min` 和 :func:`max` 函数会更有效率。 如果需要重复使用这些函数，请考虑将可迭代对象转为真正的堆。"
 
 #: ../../library/heapq.rst:136
 msgid "Basic Examples"
@@ -211,52 +234,55 @@ msgid ""
 " pushing all values onto a heap and then popping off the smallest values one"
 " at a time::"
 msgstr ""
+"`堆排序 <https://en.wikipedia.org/wiki/Heapsort>`_ 可以通过将所有值推入堆中然后每次弹出一个最小值项来实现。"
 
 #: ../../library/heapq.rst:151
 msgid ""
 "This is similar to ``sorted(iterable)``, but unlike :func:`sorted`, this "
 "implementation is not stable."
-msgstr ""
+msgstr "这类似于 ``sorted(iterable)``，但与 :func:`sorted` 不同的是这个实现是不稳定的。"
 
 #: ../../library/heapq.rst:154
 msgid ""
 "Heap elements can be tuples.  This is useful for assigning comparison values"
 " (such as task priorities) alongside the main record being tracked::"
-msgstr ""
+msgstr "堆元素可以为元组。 这适用于将比较值（例如任务优先级）与跟踪的主记录进行赋值的场合::"
 
 #: ../../library/heapq.rst:167
 msgid "Priority Queue Implementation Notes"
-msgstr ""
+msgstr "优先队列实现说明"
 
 #: ../../library/heapq.rst:169
 msgid ""
 "A `priority queue <https://en.wikipedia.org/wiki/Priority_queue>`_ is common"
 " use for a heap, and it presents several implementation challenges:"
 msgstr ""
+"`优先队列 <https://en.wikipedia.org/wiki/Priority_queue>`_ "
+"是堆的常用场合，并且它的实现包含了多个挑战："
 
 #: ../../library/heapq.rst:172
 msgid ""
 "Sort stability:  how do you get two tasks with equal priorities to be "
 "returned in the order they were originally added?"
-msgstr ""
+msgstr "排序稳定性：你该如何令相同优先级的两个任务按它们最初被加入时的顺序返回？"
 
 #: ../../library/heapq.rst:175
 msgid ""
 "Tuple comparison breaks for (priority, task) pairs if the priorities are "
 "equal and the tasks do not have a default comparison order."
-msgstr ""
+msgstr "如果优先级相同且任务没有默认比较顺序，则 (priority, task) 对的元组比较将会中断。"
 
 #: ../../library/heapq.rst:178
 msgid ""
 "If the priority of a task changes, how do you move it to a new position in "
 "the heap?"
-msgstr ""
+msgstr "如果任务优先级发生改变，你该如何将其移至堆中的新位置？"
 
 #: ../../library/heapq.rst:181
 msgid ""
 "Or if a pending task needs to be deleted, how do you find it and remove it "
 "from the queue?"
-msgstr ""
+msgstr "或者如果一个挂起的任务需要被删除，你该如何找到它并将其移出队列？"
 
 #: ../../library/heapq.rst:184
 msgid ""
@@ -267,31 +293,35 @@ msgid ""
 " same, the tuple comparison will never attempt to directly compare two "
 "tasks."
 msgstr ""
+"针对前两项挑战的一种解决方案是将条目保存为包含优先级、条目计数和任务对象 3 个元素的列表。 "
+"条目计数可用来打破平局，这样具有相同优先级的任务将按它们的添加顺序返回。 并且由于没有哪两个条目计数是相同的，元组比较将永远不会直接比较两个任务。"
 
 #: ../../library/heapq.rst:190
 msgid ""
 "Another solution to the problem of non-comparable tasks is to create a "
 "wrapper class that ignores the task item and only compares the priority "
 "field::"
-msgstr ""
+msgstr "不可比较任务问题的另一种解决方案是创建一个忽略任务条目并且只比较优先级字段的包装器类::"
 
 #: ../../library/heapq.rst:201
 msgid ""
 "The remaining challenges revolve around finding a pending task and making "
 "changes to its priority or removing it entirely.  Finding a task can be done"
 " with a dictionary pointing to an entry in the queue."
-msgstr ""
+msgstr "其余的挑战主要包括找到挂起的任务并修改其优先级或将其完全移除。 找到一个任务可使用一个指向队列中条目的字典来实现。"
 
 #: ../../library/heapq.rst:205
 msgid ""
 "Removing the entry or changing its priority is more difficult because it "
 "would break the heap structure invariants.  So, a possible solution is to "
 "mark the entry as removed and add a new entry with the revised priority::"
 msgstr ""
+"移除条目或改变其优先级的操作实现起来更为困难，因为它会破坏堆结构不变量。 "
+"因此，一种可能的解决方案是将条目标记为已移除，再添加一个改变了优先级的新条目::"
 
 #: ../../library/heapq.rst:239
 msgid "Theory"
-msgstr ""
+msgstr "理论"
 
 #: ../../library/heapq.rst:241
 msgid ""
@@ -300,12 +330,14 @@ msgid ""
 "existing elements are considered to be infinite.  The interesting property "
 "of a heap is that ``a[0]`` is always its smallest element."
 msgstr ""
+"堆是通过数组来实现的，其中的元素从 0 开始计数，对于所有的 *k* 都有 ``a[k] <= a[2*k+1]`` 且 ``a[k] <= "
+"a[2*k+2]``。 为了便于比较，不存在的元素被视为无穷大。 堆最有趣的特性在于 ``a[0]`` 总是其中最小的元素。"
 
 #: ../../library/heapq.rst:246
 msgid ""
 "The strange invariant above is meant to be an efficient memory "
 "representation for a tournament.  The numbers below are *k*, not ``a[k]``::"
-msgstr ""
+msgstr "上面的特殊不变量是用来作为一场锦标赛的高效内存表示。 下面的数字是 *k* 而不是 ``a[k]``::"
 
 #: ../../library/heapq.rst:259
 msgid ""
