python
diff --git a/‎.stat.json‎
Lines changed: 1 addition & 1 deletion b/‎.stat.json‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎glossary.po‎
Lines changed: 170 additions & 74 deletions b/‎glossary.po‎
Lines changed: 170 additions & 74 deletions
diff --git a/‎howto/sorting.po‎
Lines changed: 66 additions & 36 deletions b/‎howto/sorting.po‎
Lines changed: 66 additions & 36 deletions
@@ -1 +1 @@
-{"translation": "66.44%", "updated_at": "2025-09-23T13:21:05Z"}
+{"translation": "82.06%", "updated_at": "2025-09-23T14:19:13Z"}
@@ -11,7 +11,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.9\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-01-03 16:35+0000\n"
+"POT-Creation-Date: 2025-09-22 21:56+0000\n"
 "PO-Revision-Date: 2025-09-22 17:54+0000\n"
 "Last-Translator: python-doc bot, 2025\n"
 "Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"
@@ -23,40 +23,40 @@ msgstr ""
 
 #: ../../howto/sorting.rst:4
 msgid "Sorting HOW TO"
-msgstr ""
+msgstr "排序指南"
 
 #: ../../howto/sorting.rst:0
 msgid "Author"
 msgstr "作者"
 
 #: ../../howto/sorting.rst:6
 msgid "Andrew Dalke and Raymond Hettinger"
-msgstr ""
+msgstr "Andrew Dalke 与 Raymond Hettinger"
 
 #: ../../howto/sorting.rst:0
 msgid "Release"
 msgstr "发布版本"
 
 #: ../../howto/sorting.rst:7
 msgid "0.1"
-msgstr ""
+msgstr "0.1"
 
 #: ../../howto/sorting.rst:10
 msgid ""
 "Python lists have a built-in :meth:`list.sort` method that modifies the list"
 " in-place.  There is also a :func:`sorted` built-in function that builds a "
 "new sorted list from an iterable."
-msgstr ""
+msgstr "内置列表方法 :meth:`list.sort` 原地修改列表，而内置函数 :func:`sorted` 由可迭代对象新建有序列表。"
 
 #: ../../howto/sorting.rst:14
 msgid ""
 "In this document, we explore the various techniques for sorting data using "
 "Python."
-msgstr ""
+msgstr "在本文档中，我们将探索使用 Python 对数据进行排序的各种技术。"
 
 #: ../../howto/sorting.rst:18
 msgid "Sorting Basics"
-msgstr ""
+msgstr "排序的基础知识"
 
 #: ../../howto/sorting.rst:20
 msgid ""
@@ -71,50 +71,54 @@ msgid ""
 "than :func:`sorted` - but if you don't need the original list, it's slightly"
 " more efficient."
 msgstr ""
+"亦可用 :meth:`list.sort` 方法。它原地修改原列表（并返回 ``None`` 以避免混淆）。往往不如 :func:`sorted` "
+"方便——但若不需原列表，用它会略高效些。"
 
 #: ../../howto/sorting.rst:36
 msgid ""
 "Another difference is that the :meth:`list.sort` method is only defined for "
 "lists. In contrast, the :func:`sorted` function accepts any iterable."
-msgstr ""
+msgstr "另一个区别是 :meth:`list.sort` 方法只为列表定义，而 :func:`sorted` 函数接受任何可迭代对象。"
 
 #: ../../howto/sorting.rst:43
 msgid "Key Functions"
-msgstr ""
+msgstr "键函数"
 
 #: ../../howto/sorting.rst:45
 msgid ""
 "Both :meth:`list.sort` and :func:`sorted` have a *key* parameter to specify "
 "a function (or other callable) to be called on each list element prior to "
 "making comparisons."
 msgstr ""
+":meth:`list.sort` 和 :func:`sorted` 皆有 *key* "
+"形参用以指定在比较前要对每个列表元素调用的函数（或其它可调用对象）。"
 
 #: ../../howto/sorting.rst:49
 msgid "For example, here's a case-insensitive string comparison:"
-msgstr ""
+msgstr "例如，这是个不区分大小写的字符串比较："
 
 #: ../../howto/sorting.rst:54
 msgid ""
 "The value of the *key* parameter should be a function (or other callable) "
 "that takes a single argument and returns a key to use for sorting purposes. "
 "This technique is fast because the key function is called exactly once for "
 "each input record."
-msgstr ""
+msgstr "*key* 形参的值需为一元函数（或其它可调用对象），其返回值用于排序。这很快，因为键函数只需在输入的每个记录上调用恰好一次。"
 
 #: ../../howto/sorting.rst:59
 msgid ""
 "A common pattern is to sort complex objects using some of the object's "
 "indices as keys. For example:"
-msgstr ""
+msgstr "常见的模式是用对象的某一些索引作为键对复杂对象排序。例如："
 
 #: ../../howto/sorting.rst:70
 msgid ""
 "The same technique works for objects with named attributes. For example:"
-msgstr ""
+msgstr "同样的方法对于有具名属性的对象也适用。例如："
 
 #: ../../howto/sorting.rst:89
 msgid "Operator Module Functions"
-msgstr ""
+msgstr "Operator 模块函数"
 
 #: ../../howto/sorting.rst:91
 msgid ""
@@ -123,31 +127,36 @@ msgid ""
 ":mod:`operator` module has :func:`~operator.itemgetter`, "
 ":func:`~operator.attrgetter`, and a :func:`~operator.methodcaller` function."
 msgstr ""
+"上面显示的键函数模式非常常见，因此 Python 提供了便利功能，使访问器功能更容易，更快捷。  :mod:`operator` 模块有 "
+":func:`~operator.itemgetter` 、 :func:`~operator.attrgetter` 和 "
+":func:`~operator.methodcaller` 函数。"
 
 #: ../../howto/sorting.rst:96
 msgid "Using those functions, the above examples become simpler and faster:"
-msgstr ""
+msgstr "用了那些函数之后，前面的示例变得更简单，运行起来也更快："
 
 #: ../../howto/sorting.rst:106
 msgid ""
 "The operator module functions allow multiple levels of sorting. For example,"
 " to sort by *grade* then by *age*:"
-msgstr ""
+msgstr "运算符模块的函数可以用来作多级排序。例如，按 *grade* 排序，然后按 *age* 排序："
 
 #: ../../howto/sorting.rst:116
 msgid "Ascending and Descending"
-msgstr ""
+msgstr "升序与降序"
 
 #: ../../howto/sorting.rst:118
 msgid ""
 "Both :meth:`list.sort` and :func:`sorted` accept a *reverse* parameter with "
 "a boolean value. This is used to flag descending sorts. For example, to get "
 "the student data in reverse *age* order:"
 msgstr ""
+":meth:`list.sort` 和 :func:`sorted` 接受布尔形参 *reverse* 用于标记降序排序。例如，将学生数据按 *age*"
+" 倒序排序："
 
 #: ../../howto/sorting.rst:129
 msgid "Sort Stability and Complex Sorts"
-msgstr ""
+msgstr "排序稳定性与复杂排序"
 
 #: ../../howto/sorting.rst:131
 msgid ""
@@ -156,105 +165,113 @@ msgid ""
 "that when multiple records have the same key, their original order is "
 "preserved."
 msgstr ""
+"排序保证 `稳定 "
+"<https://en.wikipedia.org/wiki/Sorting_algorithm#Stability>`_：等键记录保持原始顺序。"
 
 #: ../../howto/sorting.rst:139
 msgid ""
 "Notice how the two records for *blue* retain their original order so that "
 "``('blue', 1)`` is guaranteed to precede ``('blue', 2)``."
-msgstr ""
+msgstr "注意 *blue* 的两个记录是如何保序的：``('blue', 1)`` 保证先于 ``('blue', 2)``。"
 
 #: ../../howto/sorting.rst:142
 msgid ""
 "This wonderful property lets you build complex sorts in a series of sorting "
 "steps. For example, to sort the student data by descending *grade* and then "
 "ascending *age*, do the *age* sort first and then sort again using *grade*:"
 msgstr ""
+"这个了不起的特性使得借助一系列排序步骤构建出复杂排序成为可能。例如，要按 *grade* 降序后 *age* 升序排序学生数据，只需先用 *age* "
+"排序再用 *grade* 排序即可："
 
 #: ../../howto/sorting.rst:150
 msgid ""
 "This can be abstracted out into a wrapper function that can take a list and "
 "tuples of field and order to sort them on multiple passes."
-msgstr ""
+msgstr "可抽象为包装函数，依据接收的一些字段序的元组对接收的列表做多趟排序。"
 
 #: ../../howto/sorting.rst:161
 msgid ""
 "The `Timsort <https://en.wikipedia.org/wiki/Timsort>`_ algorithm used in "
 "Python does multiple sorts efficiently because it can take advantage of any "
 "ordering already present in a dataset."
 msgstr ""
+"Python 中曾用的 `Timsort <https://en.wikipedia.org/wiki/Timsort>`_ "
+"算法借助数据集中任何已有的有序性来高效进行多种排序。"
 
 #: ../../howto/sorting.rst:166
 msgid "The Old Way Using Decorate-Sort-Undecorate"
-msgstr ""
+msgstr "使用装饰-排序-去装饰的旧方法"
 
 #: ../../howto/sorting.rst:168
 msgid "This idiom is called Decorate-Sort-Undecorate after its three steps:"
-msgstr ""
+msgstr "装饰-排序-去装饰 (Decorate-Sort-Undecorate) 得名于它的三个步骤："
 
 #: ../../howto/sorting.rst:170
 msgid ""
 "First, the initial list is decorated with new values that control the sort "
 "order."
-msgstr ""
+msgstr "首先，用控制排序顺序的新值装饰初始列表。"
 
 #: ../../howto/sorting.rst:172
 msgid "Second, the decorated list is sorted."
-msgstr ""
+msgstr "其次，排序装饰后的列表。"
 
 #: ../../howto/sorting.rst:174
 msgid ""
 "Finally, the decorations are removed, creating a list that contains only the"
 " initial values in the new order."
-msgstr ""
+msgstr "最后，去除装饰即得按新顺序排列的初始值的列表。"
 
 #: ../../howto/sorting.rst:177
 msgid ""
 "For example, to sort the student data by *grade* using the DSU approach:"
-msgstr ""
+msgstr "例如，用 DSU 方法按 *grade* 排序学生数据："
 
 #: ../../howto/sorting.rst:184
 msgid ""
 "This idiom works because tuples are compared lexicographically; the first "
 "items are compared; if they are the same then the second items are compared,"
 " and so on."
-msgstr ""
+msgstr "这方法语有效是因为元组按字典顺序进行比较，先比较第一项；如果它们相同则比较第二个项目，依此类推。"
 
 #: ../../howto/sorting.rst:188
 msgid ""
 "It is not strictly necessary in all cases to include the index *i* in the "
 "decorated list, but including it gives two benefits:"
-msgstr ""
+msgstr "不一定在所有情况下都要在装饰列表中包含索引 *i* ，但包含它有两个好处："
 
 #: ../../howto/sorting.rst:191
 msgid ""
 "The sort is stable -- if two items have the same key, their order will be "
 "preserved in the sorted list."
-msgstr ""
+msgstr "排序是稳定的——如果两个项具有相同的键，它们的顺序将保留在排序列表中。"
 
 #: ../../howto/sorting.rst:194
 msgid ""
 "The original items do not have to be comparable because the ordering of the "
 "decorated tuples will be determined by at most the first two items. So for "
 "example the original list could contain complex numbers which cannot be "
 "sorted directly."
-msgstr ""
+msgstr "原始项目不必具有可比性，因为装饰元组的排序最多由前两项决定。 因此，例如原始列表可能包含无法直接排序的复数。"
 
 #: ../../howto/sorting.rst:199
 msgid ""
 "Another name for this idiom is `Schwartzian transform "
 "<https://en.wikipedia.org/wiki/Schwartzian_transform>`_\\, after Randal L. "
 "Schwartz, who popularized it among Perl programmers."
 msgstr ""
+"这个方法的另一个名字是 Randal L. Schwartz 在 Perl 程序员中推广的 `Schwartzian transform "
+"<https://en.wikipedia.org/wiki/Schwartzian_transform>`_\\ 。"
 
 #: ../../howto/sorting.rst:203
 msgid ""
 "Now that Python sorting provides key-functions, this technique is not often "
 "needed."
-msgstr ""
+msgstr "既然 Python 排序提供了键函数，那么通常不需要这种技术。"
 
 #: ../../howto/sorting.rst:207
 msgid "The Old Way Using the *cmp* Parameter"
-msgstr ""
+msgstr "使用 *cmp* 参数的旧方法"
 
 #: ../../howto/sorting.rst:209
 msgid ""
@@ -263,13 +280,17 @@ msgid ""
 "arguments. Instead, all of the Py2.x versions supported a *cmp* parameter to"
 " handle user specified comparison functions."
 msgstr ""
+"本 HOWTO 中给出的许多结构都假定为 Python 2.4 或更高版本。在此之前，没有内置 :func:`sorted` ， "
+":meth:`list.sort` 也没有关键字参数。相反，所有 Py2.x 版本都支持 *cmp* 参数来处理用户指定的比较函数。"
 
 #: ../../howto/sorting.rst:214
 msgid ""
 "In Py3.0, the *cmp* parameter was removed entirely (as part of a larger "
 "effort to simplify and unify the language, eliminating the conflict between "
 "rich comparisons and the :meth:`__cmp__` magic method)."
 msgstr ""
+"在 Py3.0 中， *cmp* 参数被完全删除（作为简化和统一语言努力的一部分，消除了丰富的比较与 :meth:`__cmp__` "
+"魔术方法之间的冲突）。"
 
 #: ../../howto/sorting.rst:218
 msgid ""
@@ -278,10 +299,12 @@ msgid ""
 "then return a negative value for less-than, return zero if they are equal, "
 "or return a positive value for greater-than. For example, we can do:"
 msgstr ""
+"在 Py2.x 中， sort "
+"允许一个可选函数，可以调用它来进行比较。该函数应该采用两个参数进行比较，然后返回负值为小于，如果它们相等则返回零，或者返回大于大于的正值。例如，我们可以这样做："
 
 #: ../../howto/sorting.rst:228
 msgid "Or you can reverse the order of comparison with:"
-msgstr ""
+msgstr "或者你可反转比较的顺序："
 
 #: ../../howto/sorting.rst:235
 msgid ""
@@ -292,23 +315,26 @@ msgstr ""
 
 #: ../../howto/sorting.rst:258
 msgid "To convert to a key function, just wrap the old comparison function:"
-msgstr ""
+msgstr "要转换为键函数，只需包装旧的比较函数："
 
 #: ../../howto/sorting.rst:269
 msgid ""
 "In Python 3.2, the :func:`functools.cmp_to_key` function was added to the "
 ":mod:`functools` module in the standard library."
 msgstr ""
+"在 Python 3.2 中， :func:`functools.cmp_to_key` 函数被添加到标准库中的 :mod:`functools` "
+"模块中。"
 
 #: ../../howto/sorting.rst:273
 msgid "Odd and Ends"
-msgstr ""
+msgstr "其它"
 
 #: ../../howto/sorting.rst:275
 msgid ""
 "For locale aware sorting, use :func:`locale.strxfrm` for a key function or "
 ":func:`locale.strcoll` for a comparison function."
 msgstr ""
+"对于区域相关的排序，请使用 :func:`locale.strxfrm` 作为键函数，或者 :func:`locale.strcoll` 作为比较函数。"
 
 #: ../../howto/sorting.rst:278
 msgid ""
@@ -317,6 +343,8 @@ msgid ""
 "simulated without the parameter by using the builtin :func:`reversed` "
 "function twice:"
 msgstr ""
+"*reverse* 参数仍然保持排序稳定性（因此具有相等键的记录保留原始顺序）。 有趣的是，通过使用内置的 :func:`reversed` "
+"函数两次，可以在没有参数的情况下模拟该效果："
 
 #: ../../howto/sorting.rst:290
 msgid ""
@@ -330,11 +358,13 @@ msgid ""
 "However, note that ``<`` can fall back to using :meth:`__gt__` if "
 ":meth:`__lt__` is not implemented (see :func:`object.__lt__`)."
 msgstr ""
+"然而，请注意，如果 :meth:`__gt__` 没有实现，``<`` 可以退回到使用 :meth:`__lt__` （见 "
+":func:`object.__lt__` ）。"
 
 #: ../../howto/sorting.rst:301
 msgid ""
 "Key functions need not depend directly on the objects being sorted. A key "
 "function can also access external resources. For instance, if the student "
 "grades are stored in a dictionary, they can be used to sort a separate list "
 "of student names:"
-msgstr ""
+msgstr "键函数不需要直接依赖于被排序的对象。键函数还可以访问外部资源。例如，如果学生成绩存储在字典中，则可以使用它们对单独的学生姓名列表进行排序："
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-{"translation": "66.44%", "updated_at": "2025-09-23T13:21:05Z"}`
	`1`	`+{"translation": "82.06%", "updated_at": "2025-09-23T14:19:13Z"}`