python
diff --git a/‎.stat.json‎
Lines changed: 1 addition & 1 deletion b/‎.stat.json‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎tutorial/datastructures.po‎
Lines changed: 68 additions & 45 deletions b/‎tutorial/datastructures.po‎
Lines changed: 68 additions & 45 deletions
@@ -1 +1 @@
-{"translation": "99.88%", "updated_at": "2025-10-07T10:14:37Z"}
+{"translation": "99.77%", "updated_at": "2025-10-07T16:15:22Z"}
@@ -5,15 +5,16 @@
 # 
 # Translators:
 # python-doc bot, 2025
+# Freesand Leo <yuqinju@163.com>, 2025
 # 
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.14\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-09-07 14:14+0000\n"
+"POT-Creation-Date: 2025-10-07 14:17+0000\n"
 "PO-Revision-Date: 2025-09-16 00:02+0000\n"
-"Last-Translator: python-doc bot, 2025\n"
+"Last-Translator: Freesand Leo <yuqinju@163.com>, 2025\n"
 "Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
@@ -903,13 +904,23 @@ msgid ""
 "The main operations on a dictionary are storing a value with some key and "
 "extracting the value given the key.  It is also possible to delete a "
 "key:value pair with ``del``. If you store using a key that is already in "
-"use, the old value associated with that key is forgotten.  It is an error to"
-" extract a value using a non-existent key."
+"use, the old value associated with that key is forgotten."
 msgstr ""
-"字典的主要用途是通过关键字存储、提取值。用 ``del`` "
-"可以删除键值对。用已存在的关键字存储值，与该关键字关联的旧值会被取代。通过不存在的键提取值，则会报错。"
+"字典的主要操作是通过键来存储值并根据给定的键来提取值。 通过 ``del`` 也可以删除键值对。 "
+"如果你使用已存在的键进行存储，则与该键相关联的旧值将丢失。"
 
-#: ../../tutorial/datastructures.rst:518
+#: ../../tutorial/datastructures.rst:517
+msgid ""
+"Extracting a value for a non-existent key by subscripting (``d[key]``) "
+"raises a :exc:`KeyError`. To avoid getting this error when trying to access "
+"a possibly non-existent key, use the :meth:`~dict.get` method instead, which"
+" returns ``None`` (or a specified default value) if the key is not in the "
+"dictionary."
+msgstr ""
+"通过下标操作 (``d[key]``) 提取不存在的键的值会引发 :exc:`KeyError`。 要避免在试图访问可能不存在的键时遇到这种错误，可改用"
+" :meth:`~dict.get` 方法，它会在字典不存在某个键时返回 ``None`` (或指定的默认值)。"
+
+#: ../../tutorial/datastructures.rst:522
 msgid ""
 "Performing ``list(d)`` on a dictionary returns a list of all the keys used "
 "in the dictionary, in insertion order (if you want it sorted, just use "
@@ -919,18 +930,24 @@ msgstr ""
 "对字典执行 ``list(d)`` 操作，返回该字典中所有键的列表，按插入次序排列（如需排序，请使用 "
 "``sorted(d)``）。检查字典里是否存在某个键，使用关键字 :keyword:`in`。"
 
-#: ../../tutorial/datastructures.rst:523
+#: ../../tutorial/datastructures.rst:527
 msgid "Here is a small example using a dictionary::"
 msgstr "以下是一些字典的简单示例："
 
-#: ../../tutorial/datastructures.rst:525
+#: ../../tutorial/datastructures.rst:529
 msgid ""
 ">>> tel = {'jack': 4098, 'sape': 4139}\n"
 ">>> tel['guido'] = 4127\n"
 ">>> tel\n"
 "{'jack': 4098, 'sape': 4139, 'guido': 4127}\n"
 ">>> tel['jack']\n"
 "4098\n"
+">>> tel['irv']\n"
+"Traceback (most recent call last):\n"
+"  File \"<stdin>\", line 1, in <module>\n"
+"KeyError: 'irv'\n"
+">>> print(tel.get('irv'))\n"
+"None\n"
 ">>> del tel['sape']\n"
 ">>> tel['irv'] = 4127\n"
 ">>> tel\n"
@@ -950,6 +967,12 @@ msgstr ""
 "{'jack': 4098, 'sape': 4139, 'guido': 4127}\n"
 ">>> tel['jack']\n"
 "4098\n"
+">>> tel['irv']\n"
+"Traceback (most recent call last):\n"
+"  File \"<stdin>\", line 1, in <module>\n"
+"KeyError: 'irv'\n"
+">>> print(tel.get('irv'))\n"
+"None\n"
 ">>> del tel['sape']\n"
 ">>> tel['irv'] = 4127\n"
 ">>> tel\n"
@@ -963,59 +986,59 @@ msgstr ""
 ">>> 'jack' not in tel\n"
 "False"
 
-#: ../../tutorial/datastructures.rst:544
+#: ../../tutorial/datastructures.rst:554
 msgid ""
 "The :func:`dict` constructor builds dictionaries directly from sequences of "
 "key-value pairs::"
 msgstr ":func:`dict` 构造函数可以直接用键值对序列创建字典："
 
-#: ../../tutorial/datastructures.rst:547
+#: ../../tutorial/datastructures.rst:557
 msgid ""
 ">>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])\n"
 "{'sape': 4139, 'guido': 4127, 'jack': 4098}"
 msgstr ""
 ">>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])\n"
 "{'sape': 4139, 'guido': 4127, 'jack': 4098}"
 
-#: ../../tutorial/datastructures.rst:550
+#: ../../tutorial/datastructures.rst:560
 msgid ""
 "In addition, dict comprehensions can be used to create dictionaries from "
 "arbitrary key and value expressions::"
 msgstr "字典推导式可以用任意键值表达式创建字典："
 
-#: ../../tutorial/datastructures.rst:553
+#: ../../tutorial/datastructures.rst:563
 msgid ""
 ">>> {x: x**2 for x in (2, 4, 6)}\n"
 "{2: 4, 4: 16, 6: 36}"
 msgstr ""
 ">>> {x: x**2 for x in (2, 4, 6)}\n"
 "{2: 4, 4: 16, 6: 36}"
 
-#: ../../tutorial/datastructures.rst:556
+#: ../../tutorial/datastructures.rst:566
 msgid ""
 "When the keys are simple strings, it is sometimes easier to specify pairs "
 "using keyword arguments::"
 msgstr "关键字是比较简单的字符串时，直接用关键字参数指定键值对更便捷："
 
-#: ../../tutorial/datastructures.rst:559
+#: ../../tutorial/datastructures.rst:569
 msgid ""
 ">>> dict(sape=4139, guido=4127, jack=4098)\n"
 "{'sape': 4139, 'guido': 4127, 'jack': 4098}"
 msgstr ""
 ">>> dict(sape=4139, guido=4127, jack=4098)\n"
 "{'sape': 4139, 'guido': 4127, 'jack': 4098}"
 
-#: ../../tutorial/datastructures.rst:566
+#: ../../tutorial/datastructures.rst:576
 msgid "Looping Techniques"
 msgstr "循环的技巧"
 
-#: ../../tutorial/datastructures.rst:568
+#: ../../tutorial/datastructures.rst:578
 msgid ""
 "When looping through dictionaries, the key and corresponding value can be "
 "retrieved at the same time using the :meth:`~dict.items` method. ::"
 msgstr "当对字典执行循环时，可以使用 :meth:`~dict.items` 方法同时提取键及其对应的值。 ::"
 
-#: ../../tutorial/datastructures.rst:571
+#: ../../tutorial/datastructures.rst:581
 msgid ""
 ">>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}\n"
 ">>> for k, v in knights.items():\n"
@@ -1031,13 +1054,13 @@ msgstr ""
 "gallahad the pure\n"
 "robin the brave"
 
-#: ../../tutorial/datastructures.rst:578
+#: ../../tutorial/datastructures.rst:588
 msgid ""
 "When looping through a sequence, the position index and corresponding value "
 "can be retrieved at the same time using the :func:`enumerate` function. ::"
 msgstr "在序列中循环时，用 :func:`enumerate` 函数可以同时取出位置索引和对应的值："
 
-#: ../../tutorial/datastructures.rst:581
+#: ../../tutorial/datastructures.rst:591
 msgid ""
 ">>> for i, v in enumerate(['tic', 'tac', 'toe']):\n"
 "...     print(i, v)\n"
@@ -1053,13 +1076,13 @@ msgstr ""
 "1 tac\n"
 "2 toe"
 
-#: ../../tutorial/datastructures.rst:588
+#: ../../tutorial/datastructures.rst:598
 msgid ""
 "To loop over two or more sequences at the same time, the entries can be "
 "paired with the :func:`zip` function. ::"
 msgstr "同时循环两个或多个序列时，用 :func:`zip` 函数可以将其内的元素一一匹配："
 
-#: ../../tutorial/datastructures.rst:591
+#: ../../tutorial/datastructures.rst:601
 msgid ""
 ">>> questions = ['name', 'quest', 'favorite color']\n"
 ">>> answers = ['lancelot', 'the holy grail', 'blue']\n"
@@ -1079,13 +1102,13 @@ msgstr ""
 "What is your quest?  It is the holy grail.\n"
 "What is your favorite color?  It is blue."
 
-#: ../../tutorial/datastructures.rst:600
+#: ../../tutorial/datastructures.rst:610
 msgid ""
 "To loop over a sequence in reverse, first specify the sequence in a forward "
 "direction and then call the :func:`reversed` function. ::"
 msgstr "为了逆向对序列进行循环，可以求出欲循环的正向序列，然后调用 :func:`reversed` 函数："
 
-#: ../../tutorial/datastructures.rst:603
+#: ../../tutorial/datastructures.rst:613
 msgid ""
 ">>> for i in reversed(range(1, 10, 2)):\n"
 "...     print(i)\n"
@@ -1105,13 +1128,13 @@ msgstr ""
 "3\n"
 "1"
 
-#: ../../tutorial/datastructures.rst:612
+#: ../../tutorial/datastructures.rst:622
 msgid ""
 "To loop over a sequence in sorted order, use the :func:`sorted` function "
 "which returns a new sorted list while leaving the source unaltered. ::"
 msgstr "按指定顺序循环序列，可以用 :func:`sorted` 函数，在不改动原序列的基础上，返回一个重新的序列："
 
-#: ../../tutorial/datastructures.rst:615
+#: ../../tutorial/datastructures.rst:625
 msgid ""
 ">>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']\n"
 ">>> for i in sorted(basket):\n"
@@ -1135,7 +1158,7 @@ msgstr ""
 "orange\n"
 "pear"
 
-#: ../../tutorial/datastructures.rst:626
+#: ../../tutorial/datastructures.rst:636
 msgid ""
 "Using :func:`set` on a sequence eliminates duplicate elements. The use of "
 ":func:`sorted` in combination with :func:`set` over a sequence is an "
@@ -1145,7 +1168,7 @@ msgstr ""
 "使用 :func:`set` 去除序列中的重复元素。使用 :func:`sorted` 加 :func:`set` "
 "则按排序后的顺序，循环遍历序列中的唯一元素："
 
-#: ../../tutorial/datastructures.rst:630
+#: ../../tutorial/datastructures.rst:640
 msgid ""
 ">>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']\n"
 ">>> for f in sorted(set(basket)):\n"
@@ -1165,13 +1188,13 @@ msgstr ""
 "orange\n"
 "pear"
 
-#: ../../tutorial/datastructures.rst:639
+#: ../../tutorial/datastructures.rst:649
 msgid ""
 "It is sometimes tempting to change a list while you are looping over it; "
 "however, it is often simpler and safer to create a new list instead. ::"
 msgstr "一般来说，在循环中修改列表的内容时，创建新列表比较简单，且安全："
 
-#: ../../tutorial/datastructures.rst:642
+#: ../../tutorial/datastructures.rst:652
 msgid ""
 ">>> import math\n"
 ">>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]\n"
@@ -1193,17 +1216,17 @@ msgstr ""
 ">>> filtered_data\n"
 "[56.2, 51.7, 55.3, 52.5, 47.8]"
 
-#: ../../tutorial/datastructures.rst:656
+#: ../../tutorial/datastructures.rst:666
 msgid "More on Conditions"
 msgstr "深入条件控制"
 
-#: ../../tutorial/datastructures.rst:658
+#: ../../tutorial/datastructures.rst:668
 msgid ""
 "The conditions used in ``while`` and ``if`` statements can contain any "
 "operators, not just comparisons."
 msgstr "``while`` 和 ``if`` 条件句不只可以进行比较，还可以使用任意运算符。"
 
-#: ../../tutorial/datastructures.rst:662
+#: ../../tutorial/datastructures.rst:672
 msgid ""
 "The comparison operators ``in`` and ``not in`` are membership tests that "
 "determine whether a value is in (or not in) a container.  The operators "
@@ -1214,13 +1237,13 @@ msgstr ""
 "比较运算符 ``in`` 和 ``not in`` 用于执行确定一个值是否存在（或不存在）于某个容器中的成员检测。 运算符 ``is`` 和 ``is "
 "not`` 用于比较两个对象是否是同一个对象。 所有比较运算符的优先级都一样，且低于任何数值运算符。"
 
-#: ../../tutorial/datastructures.rst:668
+#: ../../tutorial/datastructures.rst:678
 msgid ""
 "Comparisons can be chained.  For example, ``a < b == c`` tests whether ``a``"
 " is less than ``b`` and moreover ``b`` equals ``c``."
 msgstr "比较操作支持链式操作。例如，``a < b == c`` 校验 ``a`` 是否小于 ``b``，且 ``b`` 是否等于 ``c``。"
 
-#: ../../tutorial/datastructures.rst:671
+#: ../../tutorial/datastructures.rst:681
 msgid ""
 "Comparisons may be combined using the Boolean operators ``and`` and ``or``, "
 "and the outcome of a comparison (or of any other Boolean expression) may be "
@@ -1233,7 +1256,7 @@ msgstr ""
 "取反。这些操作符的优先级低于比较操作符；``not`` 的优先级最高， ``or`` 的优先级最低，因此，``A and not B or C`` "
 "等价于 ``(A and (not B)) or C``。与其他运算符操作一样，此处也可以用圆括号表示想要的组合。"
 
-#: ../../tutorial/datastructures.rst:678
+#: ../../tutorial/datastructures.rst:688
 msgid ""
 "The Boolean operators ``and`` and ``or`` are so-called *short-circuit* "
 "operators: their arguments are evaluated from left to right, and evaluation "
@@ -1246,13 +1269,13 @@ msgstr ""
 " ``C`` 为真，``B`` 为假，那么 ``A and B and C`` 不会对 ``C`` "
 "求值。用作普通值而不是布尔值时，短路运算符的返回值通常是最后一个求了值的参数。"
 
-#: ../../tutorial/datastructures.rst:685
+#: ../../tutorial/datastructures.rst:695
 msgid ""
 "It is possible to assign the result of a comparison or other Boolean "
 "expression to a variable.  For example, ::"
 msgstr "还可以把比较运算或其它布尔表达式的结果赋值给变量，例如："
 
-#: ../../tutorial/datastructures.rst:688
+#: ../../tutorial/datastructures.rst:698
 msgid ""
 ">>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'\n"
 ">>> non_null = string1 or string2 or string3\n"
@@ -1264,7 +1287,7 @@ msgstr ""
 ">>> non_null\n"
 "'Trondheim'"
 
-#: ../../tutorial/datastructures.rst:693
+#: ../../tutorial/datastructures.rst:703
 msgid ""
 "Note that in Python, unlike C, assignment inside expressions must be done "
 "explicitly with the :ref:`walrus operator <why-can-t-i-use-an-assignment-in-"
@@ -1274,11 +1297,11 @@ msgstr ""
 "注意，Python 与 C 不同，在表达式内部赋值必须显式使用 :ref:`海象运算符 <why-can-t-i-use-an-assignment-"
 "in-an-expression>` ``:=``。 这避免了 C 程序中常见的问题：要在表达式中写 ``==`` 时，却写成了 ``=``。"
 
-#: ../../tutorial/datastructures.rst:703
+#: ../../tutorial/datastructures.rst:713
 msgid "Comparing Sequences and Other Types"
 msgstr "序列和其他类型的比较"
 
-#: ../../tutorial/datastructures.rst:704
+#: ../../tutorial/datastructures.rst:714
 msgid ""
 "Sequence objects typically may be compared to other objects with the same "
 "sequence type. The comparison uses *lexicographical* ordering: first the "
@@ -1297,7 +1320,7 @@ msgstr ""
 "顺序：首先，比较前两个对应元素，如果不相等，则可确定比较结果；如果相等，则比较之后的两个元素，以此类推，直到其中一个序列结束。如果要比较的两个元素本身是相同类型的序列，则递归地执行字典式顺序比较。如果两个序列中所有的对应元素都相等，则两个序列相等。如果一个序列是另一个的初始子序列，则较短的序列可被视为较小（较少）的序列。"
 " 对于字符串来说，字典式顺序使用 Unicode 码位序号排序单个字符。下面列出了一些比较相同类型序列的例子："
 
-#: ../../tutorial/datastructures.rst:716
+#: ../../tutorial/datastructures.rst:726
 msgid ""
 "(1, 2, 3)              < (1, 2, 4)\n"
 "[1, 2, 3]              < [1, 2, 4]\n"
@@ -1315,7 +1338,7 @@ msgstr ""
 "(1, 2, 3)             == (1.0, 2.0, 3.0)\n"
 "(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)"
 
-#: ../../tutorial/datastructures.rst:724
+#: ../../tutorial/datastructures.rst:734
 msgid ""
 "Note that comparing objects of different types with ``<`` or ``>`` is legal "
 "provided that the objects have appropriate comparison methods.  For example,"
@@ -1327,11 +1350,11 @@ msgstr ""
 "进行比较。例如，混合的数字类型通过数字值进行比较，所以，0 等于 0.0，等等。如果没有提供合适的比较方法，解释器不会随便给出一个比较结果，而是引发 "
 ":exc:`TypeError` 异常。"
 
-#: ../../tutorial/datastructures.rst:732
+#: ../../tutorial/datastructures.rst:742
 msgid "Footnotes"
 msgstr "备注"
 
-#: ../../tutorial/datastructures.rst:733
+#: ../../tutorial/datastructures.rst:743
 msgid ""
 "Other languages may return the mutated object, which allows method chaining,"
 " such as ``d->insert(\"a\")->remove(\"b\")->sort();``."
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-{"translation": "99.88%", "updated_at": "2025-10-07T10:14:37Z"}`
	`1`	`+{"translation": "99.77%", "updated_at": "2025-10-07T16:15:22Z"}`