fix: resolve fuzzy entries in tutorial

mattwang44 · mattwang44 · commit 89b0fe8361bb · 2023-07-19T02:34:39.000+08:00
diff --git a/tutorial/appendix.po b/tutorial/appendix.po
@@ -89,8 +89,8 @@ msgid ""
 msgstr ""
 "（假設直譯器在用戶的 :envvar:`PATH` 上）在腳本的開頭並給檔案一個可執行模式。 "
 "``#!`` 必須是檔案的前兩個字元。 在某些平台上，第一行必須以 Unix 樣式的換行 "
-"(``'\\n'``) 結尾，而不是 Windows (``'\\r\\n'``) 換行。 請注意，井號 "
-"``'#'`` 用於在 Python 中開始註解。"
+"(``'\\n'``) 結尾，而不是 Windows (``'\\r\\n'``) 換行。 請注意，井號 ``'#'`` "
+"用於在 Python 中開始註解。"
 
 #: ../../tutorial/appendix.rst:52
 msgid ""
@@ -193,8 +193,8 @@ msgid ""
 "`site` module for more details."
 msgstr ""
 ":mod:`sitecustomize` 的運作方式相同，但通常是由電腦的管理員在全域 site-"
-"packages 目錄下創建，並在 :mod:`usercustomize` 之前 import 。更多細節請參閱 :mod:"
-"`site` 模組的文件。"
+"packages 目錄下創建，並在 :mod:`usercustomize` 之前 import 。更多細節請參閱 :"
+"mod:`site` 模組的文件。"
 
 #: ../../tutorial/appendix.rst:123
 msgid "Footnotes"
diff --git a/tutorial/classes.po b/tutorial/classes.po
@@ -852,16 +852,16 @@ msgstr ""
 "::"
 
 #: ../../tutorial/classes.rst:584
-#, fuzzy
 msgid ""
 "The name :class:`BaseClassName` must be defined in a namespace accessible "
 "from the scope containing the derived class definition.  In place of a base "
 "class name, other arbitrary expressions are also allowed.  This can be "
 "useful, for example, when the base class is defined in another module::"
 msgstr ""
-"名稱 :class:`BaseClassName` 被定義的作用域必須是包含 derived class 定義的作用"
-"域。要代替 base class（基底類別）的名稱，用其他任意的運算式也是被允許的。這會"
-"很有用，例如，當一個 base class 是在另一個模組中被定義時：\n"
+"名稱 :class:`BaseClassName` 必須被定義於作用域可及的命名空間，且該作用域要包"
+"含 derived class 定義。要代替 base class（基底類別）的名稱，用其他任意的運算"
+"式也是被允許的。這會很有用，例如，當一個 base class 是在另一個模組中被定義"
+"時：\n"
 "\n"
 "::"
 
diff --git a/tutorial/datastructures.po b/tutorial/datastructures.po
@@ -532,8 +532,8 @@ msgid ""
 "Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
 "are also supported::"
 msgstr ""
-"和 :ref:`list comprehensions <tut-listcomps>` 類似，也有 set "
-"comprehensions（集合綜合運算）：\n"
+"和 :ref:`list comprehensions <tut-listcomps>` 類似，也有 set comprehensions"
+"（集合綜合運算）：\n"
 "\n"
 "::"
 
@@ -839,8 +839,8 @@ msgid ""
 "Other languages may return the mutated object, which allows method chaining, "
 "such as ``d->insert(\"a\")->remove(\"b\")->sort();``."
 msgstr ""
-"其他語言可以回傳變更後的物件，這就允許 method 的串連，例如 ``d->insert(\"a"
-"\")->remove(\"b\")->sort();``\\ 。"
+"其他語言可以回傳變更後的物件，這就允許 method 的串連，例如 ``d-"
+">insert(\"a\")->remove(\"b\")->sort();``\\ 。"
 
 #~ msgid ""
 #~ "Calling ``d.keys()`` will return a :dfn:`dictionary view` object.  It "
diff --git a/tutorial/floatingpoint.po b/tutorial/floatingpoint.po
@@ -28,7 +28,6 @@ msgid "Floating Point Arithmetic:  Issues and Limitations"
 msgstr "浮點數運算：問題與限制"
 
 #: ../../tutorial/floatingpoint.rst:16
-#, fuzzy
 msgid ""
 "Floating-point numbers are represented in computer hardware as base 2 "
 "(binary) fractions.  For example, the **decimal** fraction ``0.625`` has "
@@ -38,8 +37,8 @@ msgid ""
 "fractional notation, and the second in base 2."
 msgstr ""
 "在計算機架構中，浮點數 (floating-point number) 是以基數為 2（二進位）的小數表"
-"示。例如說，在\\ **十進位**\\ 小數中 ``0.125`` 可被分為 1/10 + 2/100 + "
-"5/1000，同樣的道理，\\ **二進位**\\ 小數 ``0.001`` 可被分為 0/2 + 0/4 + 1/8。"
+"示。例如說，在\\ **十進位**\\ 小數中 ``0.625`` 可被分為 6/10 + 2/100 + "
+"5/1000，同樣的道理，\\ **二進位**\\ 小數 ``0.101`` 可被分為 1/2 + 0/4 + 1/8。"
 "這兩個小數有相同的數值，而唯一真正的不同在於前者以十進位表示，後者以二進位表"
 "示。"
 
@@ -105,7 +104,6 @@ msgstr ""
 "55``，而這樣的表示十分地接近，但不完全等同於 1/10 的真正數值。"
 
 #: ../../tutorial/floatingpoint.rst:58
-#, fuzzy
 msgid ""
 "Many users are not aware of the approximation because of the way values are "
 "displayed.  Python only prints a decimal approximation to the true decimal "
@@ -121,15 +119,12 @@ msgstr ""
 "::"
 
 #: ../../tutorial/floatingpoint.rst:67
-#, fuzzy
 msgid ""
 "That is more digits than most people find useful, so Python keeps the number "
 "of digits manageable by displaying a rounded value instead:"
 msgstr ""
 "這比一般人感到有用的位數還多，所以 Python 將位數保持在可以接受的範圍，只顯示"
-"捨入後的數值：\n"
-"\n"
-"::"
+"捨入後的數值："
 
 #: ../../tutorial/floatingpoint.rst:75
 msgid ""
@@ -180,15 +175,12 @@ msgstr ""
 "都不會顯示。）"
 
 #: ../../tutorial/floatingpoint.rst:97
-#, fuzzy
 msgid ""
 "For more pleasant output, you may wish to use string formatting to produce a "
 "limited number of significant digits:"
 msgstr ""
 "為求更優雅的輸出，你可能想要使用字串的格式化 (string formatting) 產生限定的有"
-"效位數：\n"
-"\n"
-"::"
+"效位數："
 
 #: ../../tutorial/floatingpoint.rst:111
 msgid ""
@@ -199,36 +191,28 @@ msgstr ""
 "正機器數值所\\ *展示的值*\\ 。"
 
 #: ../../tutorial/floatingpoint.rst:114
-#, fuzzy
 msgid ""
 "One illusion may beget another.  For example, since 0.1 is not exactly 1/10, "
 "summing three values of 0.1 may not yield exactly 0.3, either:"
 msgstr ""
 "這種幻覺可能會產生下一個幻覺。舉例來說，因為 0.1 不是真正的 1/10，把三個 0.1 "
-"的值相加，也不會產生精準的 0.3：\n"
-"\n"
-"::"
+"的值相加，也不會產生精準的 0.3："
 
 #: ../../tutorial/floatingpoint.rst:122
-#, fuzzy
 msgid ""
 "Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 "
 "cannot get any closer to the exact value of 3/10, then pre-rounding with :"
 "func:`round` function cannot help:"
 msgstr ""
 "同時，因為 0.1 不能再更接近精準的 1/10，還有 0.3 不能再更接近精準的 3/10，預"
-"先用 :func:`round` 函式捨入並不會有幫助：\n"
-"\n"
-"::"
+"先用 :func:`round` 函式捨入並不會有幫助："
 
 #: ../../tutorial/floatingpoint.rst:131
-#, fuzzy
 msgid ""
 "Though the numbers cannot be made closer to their intended exact values, "
 "the :func:`math.isclose` function can be useful for comparing inexact values:"
 msgstr ""
-"雖然數字不會再更接近他們的精準數值，但 :func:`round` 函式可以對事後的捨入有所"
-"幫助，如此一來，不精確的數值就變得可以互相比較：\n"
+"雖然數字不會再更接近他們的精準數值，但 :func:`math.isclose` 函式可以用來比較不精確的值：\n"
 "\n"
 "::"
 
@@ -314,48 +298,35 @@ msgstr ""
 "的許多用於數學和統計學運算的其他套件。請參閱 <https://scipy.org>。"
 
 #: ../../tutorial/floatingpoint.rst:181
-#, fuzzy
 msgid ""
 "Python provides tools that may help on those rare occasions when you really "
 "*do* want to know the exact value of a float.  The :meth:`float."
 "as_integer_ratio` method expresses the value of a float as a fraction:"
 msgstr ""
 "在罕見情況下，當你\\ *真的*\\ 想知道一個 float 的精準值，Python 提供的工具可"
 "協助達成。\\ :meth:`float.as_integer_ratio` method 可將一個 float 的值表示為"
-"分數：\n"
-"\n"
-"::"
+"分數："
 
 #: ../../tutorial/floatingpoint.rst:192
-#, fuzzy
 msgid ""
 "Since the ratio is exact, it can be used to losslessly recreate the original "
 "value:"
 msgstr ""
-"由於該比率是精準的，它可無損地再現該原始值：\n"
-"\n"
-"::"
+"由於該比率是精準的，它可無損地再現該原始值："
 
 #: ../../tutorial/floatingpoint.rst:200
-#, fuzzy
 msgid ""
 "The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
 "again giving the exact value stored by your computer:"
 msgstr ""
 ":meth:`float.hex` method 以十六進位（基數為 16）表示 float，一樣可以給出你的"
-"電腦所儲存的精準值：\n"
-"\n"
-"::"
+"電腦所儲存的精準值："
 
 #: ../../tutorial/floatingpoint.rst:208
-#, fuzzy
 msgid ""
 "This precise hexadecimal representation can be used to reconstruct the float "
 "value exactly:"
-msgstr ""
-"這種精確的十六進位表示法可用於精準地重建 float 值：\n"
-"\n"
-"::"
+msgstr "這種精確的十六進位表示法可用於精準地重建 float 值："
 
 #: ../../tutorial/floatingpoint.rst:216
 msgid ""
@@ -443,36 +414,26 @@ msgstr ""
 "::"
 
 #: ../../tutorial/floatingpoint.rst:286
-#, fuzzy
 msgid ""
 "and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
 "2**53``), the best value for *N* is 56:"
 msgstr ""
 "而前面提到 *J* 有精準的 53 位元（即 ``>= 2**52`` 但 ``< 2**53``），所以 *N* "
-"的最佳數值是 56：\n"
-"\n"
-"::"
+"的最佳數值是 56："
 
 #: ../../tutorial/floatingpoint.rst:294
-#, fuzzy
 msgid ""
 "That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits.  "
 "The best possible value for *J* is then that quotient rounded:"
 msgstr ""
 "意即，要使 *J* 正好有 53 位元，則 56 會是 *N* 的唯一值。而 *J* 最有可能的數值"
-"就是經過捨入後的該商數：\n"
-"\n"
-"::"
+"就是經過捨入後的該商數："
 
 #: ../../tutorial/floatingpoint.rst:303
-#, fuzzy
 msgid ""
 "Since the remainder is more than half of 10, the best approximation is "
 "obtained by rounding up:"
-msgstr ""
-"由於餘數超過 10 的一半，所以最佳的近似值是透過進位而得：\n"
-"\n"
-"::"
+msgstr "由於餘數超過 10 的一半，所以最佳的近似值是透過進位而得："
 
 #: ../../tutorial/floatingpoint.rst:313
 msgid ""
@@ -511,17 +472,12 @@ msgstr ""
 "::"
 
 #: ../../tutorial/floatingpoint.rst:334
-#, fuzzy
 msgid ""
 "If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
 "decimal digits:"
-msgstr ""
-"如果將該分數乘以 10\\*\\*55，則可以看到該值以 55 個十進位數字顯示：\n"
-"\n"
-"::"
+msgstr "如果將該分數乘以 10\\*\\*55，則可以看到該值以 55 個十進位數字顯示："
 
 #: ../../tutorial/floatingpoint.rst:342
-#, fuzzy
 msgid ""
 "meaning that the exact number stored in the computer is equal to the decimal "
 "value 0.1000000000000000055511151231257827021181583404541015625. Instead of "
@@ -530,32 +486,9 @@ msgid ""
 msgstr ""
 "這表示儲存在電腦中的精準數值等於十進位值 "
 "0.1000000000000000055511151231257827021181583404541015625。與其顯示完整的十進"
-"位數值，許多語言（包括 Python 的舊版本）選擇將結果捨入至 17 個有效位數：\n"
-"\n"
-"::"
+"位數值，許多語言（包括 Python 的舊版本）選擇將結果捨入至 17 個有效位數："
 
 #: ../../tutorial/floatingpoint.rst:352
-#, fuzzy
 msgid ""
 "The :mod:`fractions` and :mod:`decimal` modules make these calculations easy:"
-msgstr ""
-":mod:`fractions` 與 :mod:`decimal` 模組能使這些計算變得容易：\n"
-"\n"
-"::"
-
-#~ msgid ""
-#~ "Floating-point numbers are represented in computer hardware as base 2 "
-#~ "(binary) fractions.  For example, the decimal fraction ::"
-#~ msgstr ""
-#~ "在計算機架構中，浮點數 (floating-point number) 是以基數為 2（二進位）的小"
-#~ "數表示。例如說，在十進位小數中：\n"
-#~ "\n"
-#~ "::"
-
-#~ msgid ""
-#~ "has value 1/10 + 2/100 + 5/1000, and in the same way the binary "
-#~ "fraction ::"
-#~ msgstr ""
-#~ "可被分為 1/10 + 2/100 + 5/1000，同樣的道理，二進位小數：\n"
-#~ "\n"
-#~ "::"
+msgstr ":mod:`fractions` 與 :mod:`decimal` 模組能使這些計算變得容易："
diff --git a/tutorial/interpreter.po b/tutorial/interpreter.po
@@ -29,14 +29,13 @@ msgid "Invoking the Interpreter"
 msgstr "啟動直譯器"
 
 #: ../../tutorial/interpreter.rst:13
-#, fuzzy
 msgid ""
 "The Python interpreter is usually installed as :file:`/usr/local/bin/"
 "python3.12` on those machines where it is available; putting :file:`/usr/"
 "local/bin` in your Unix shell's search path makes it possible to start it by "
 "typing the command:"
 msgstr ""
-"Python 直譯器一般安裝在 :file:`/usr/local/bin/python3.11` 路徑下；將 :file:`/"
+"Python 直譯器一般安裝在 :file:`/usr/local/bin/python3.12` 路徑下；將 :file:`/"
 "usr/local/bin` 加入Unix shell 的搜索路徑，輸入以下指令就可以啟動 Python："
 
 #: ../../tutorial/interpreter.rst:21
@@ -51,7 +50,6 @@ msgstr ""
 "python` 是個很常見的另類存放路徑。）"
 
 #: ../../tutorial/interpreter.rst:26
-#, fuzzy
 msgid ""
 "On Windows machines where you have installed Python from the :ref:`Microsoft "
 "Store <windows-store>`, the :file:`python3.12` command will be available. If "
@@ -60,7 +58,7 @@ msgid ""
 "Python."
 msgstr ""
 "Windows 系統中，從 :ref:`Microsoft Store <windows-store>` 安裝 Python 後，就"
-"可以使用 :file:`python3.11` 命令了。如果安裝了 :ref:`py.exe launcher "
+"可以使用 :file:`python3.12` 命令了。如果安裝了 :ref:`py.exe launcher "
 "<launcher>` ，則可以使用 :file:`py` 命令。請參閱附錄：\\ :ref:`setting-"
 "envvars`\\ ，了解其他啟動 Python 的方式。"
 
diff --git a/tutorial/introduction.po b/tutorial/introduction.po
@@ -337,14 +337,13 @@ msgid "Note that since -0 is the same as 0, negative indices start from -1."
 msgstr "注意到因為 -0 等同於 0，負的索引值由 -1 開始。"
 
 #: ../../tutorial/introduction.rst:276
-#, fuzzy
 msgid ""
 "In addition to indexing, *slicing* is also supported.  While indexing is "
 "used to obtain individual characters, *slicing* allows you to obtain a "
 "substring::"
 msgstr ""
 "除了索引外，字串亦支援「切片 *slicing*」。索引用來拿到單獨的字元，而切片則可"
-"以讓你拿到子字串 (substring)：\n"
+"以讓你拿到一個子字串 (substring)：\n"
 "\n"
 "::"
 
diff --git a/tutorial/stdlib.po b/tutorial/stdlib.po
@@ -90,15 +90,13 @@ msgid "Command Line Arguments"
 msgstr "命令列引數"
 
 #: ../../tutorial/stdlib.rst:66
-#, fuzzy
 msgid ""
 "Common utility scripts often need to process command line arguments. These "
 "arguments are stored in the :mod:`sys` module's *argv* attribute as a list.  "
 "For instance, let's take the following :file:`demo.py` file::"
 msgstr ""
 "通用工具腳本常需要處理命令列引數。這些引數會以 list（串列）形式存放在 :mod:"
-"`sys` 模組的 *argv* 屬性中。例如在命令列執行 ``python demo.py one two "
-"three`` 會有以下輸出結果：\n"
+"`sys` 模組的 *argv* 屬性中。例如以下 :file:`demo.py` 檔案：\n"
 "\n"
 "::"
 
diff --git a/tutorial/stdlib2.po b/tutorial/stdlib2.po
diff --git a/tutorial/venv.po b/tutorial/venv.po
