Translate new/fuzzy entries from upstream sync (cpython 92cab347)

Rebased cron/sync/3.14 onto upstream (7 new sync commits), then
translated every new-or-fuzzy msgid relative to origin/3.14: 336 new
entries and 28 fuzzy entries across 27 files, including the new
library/time-complexity.po page (120 entries) and the XML DOM/SAX
family (library/xml.dom.po, xml.dom.minidom.po, xml.dom.pulldom.po,
xml.etree.elementtree.po, xml.sax*.po).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ErrfGR94u9Jau7pF3GMdJa

Author: claude

faq/design.po

@@ -883,7 +883,7 @@ msgstr ""
 #: ../../faq/design.rst:448
 msgid ""
 "See :ref:`time-complexity` for the costs of the various list operations."
-msgstr ""
+msgstr "各種串列操作的成本請參閱\\ :ref:`time-complexity`\\ 。"
 
 #: ../../faq/design.rst:454
 msgid "How are dictionaries implemented in CPython?"
@@ -921,7 +921,7 @@ msgstr ""
 msgid ""
 "See :ref:`time-complexity` for the costs of the various dictionary "
 "operations."
-msgstr ""
+msgstr "各種字典操作的成本請參閱\\ :ref:`time-complexity`\\ 。"
 
 #: ../../faq/design.rst:473
 msgid "Why must dictionary keys be immutable?"

faq/programming.po

@@ -2200,7 +2200,6 @@ msgid "What is the most efficient way to concatenate many strings together?"
 msgstr "將多個字串連接在一起最有效率的方法是什麼？"
 
 #: ../../faq/programming.rst:1136
-#, fuzzy
 msgid ""
 ":class:`str` and :class:`bytes` objects are immutable, therefore "
 "concatenating many strings together is inefficient as each concatenation "
@@ -2210,7 +2209,7 @@ msgid ""
 msgstr ""
 ":class:`str` 和 :class:`bytes` 物件是不可變的，因此將多個字串連接在一起的效率"
 "很低，因為每次連接都會建立一個新物件。在一般情況下，總 runtime 成本與總字串長"
-"度呈二次方關係。"
+"度呈二次方關係。詳情請參閱\\ :ref:`time-complexity`\\ 。"
 
 #: ../../faq/programming.rst:1141
 msgid ""

glossary.po

@@ -2084,15 +2084,14 @@ msgid "list"
 msgstr "list（串列）"
 
 #: ../../glossary.rst:943
-#, fuzzy
 msgid ""
 "A built-in Python :term:`sequence`.  Despite its name it is more akin to an "
 "array in other languages than to a linked list since access to elements is "
 "*O*\\ (1).  See :ref:`time-complexity`."
 msgstr ""
 "一個 Python 內建的 :term:`sequence` （序列）。儘管它的名字是 list，它其實更類"
 "似其他語言中的一個陣列 (array) 而較不像一個鏈結串列 (linked list)，因為存取元"
-"素的時間複雜度是 *O*\\ (1)。"
+"素的時間複雜度是 *O*\\ (1)。詳情請參閱\\ :ref:`time-complexity`\\ 。"
 
 #: ../../glossary.rst:946
 msgid "list comprehension"

howto/curses.po

@@ -483,6 +483,10 @@ msgid ""
 "this defaults to the default system encoding as returned by :func:`locale."
 "getencoding`."
 msgstr ""
+":meth:`~curses.window.addstr` 方法接受 Python 字串或位元組字串作為要顯示的"
+"值。位元組字串的內容會被原封不動地傳送到終端機。在未支援寬字元的建置版本中，"
+"字串會用該視窗的 :attr:`~window.encoding` 屬性值來編碼；此屬性預設為 :func:"
+"`locale.getencoding` 所回傳的系統預設編碼。"
 
 #: ../../howto/curses.rst:307
 msgid ""
@@ -497,6 +501,9 @@ msgid ""
 "`ACS_ULCORNER` is the upper left corner of a box (handy for drawing "
 "borders).  You can also use the appropriate Unicode character."
 msgstr ""
+"終端機替代字元集的字元都有提供對應的常數。舉例來說，:const:`ACS_PLMINUS` 是一"
+"個 +/- 符號，而 :const:`ACS_ULCORNER` 則是方框的左上角（在繪製邊框時很好"
+"用）。你也可以直接使用對應的 Unicode 字元。"
 
 #: ../../howto/curses.rst:317
 msgid ""
@@ -517,6 +524,9 @@ msgid ""
 "leaves the cursor wherever the last update put it, instead of moving it back "
 "to the window's cursor position."
 msgstr ""
+"如果你的應用程式完全不需要閃爍游標，可以呼叫 ``curs_set(False)`` 使其隱藏。視"
+"窗方法 :meth:`~curses.window.leaveok` 則有不同的作用：當其引數為真時，curses "
+"會讓游標留在最後一次更新所在的位置，而不是把它移回視窗的游標位置。"
 
 #: ../../howto/curses.rst:334
 msgid "Attributes and Color"
@@ -707,7 +717,7 @@ msgstr ""
 
 #: ../../howto/curses.rst:436
 msgid "There are three methods for getting input from a window:"
-msgstr ""
+msgstr "有三種方法可以取得視窗的輸入："
 
 #: ../../howto/curses.rst:438
 msgid ""
@@ -716,6 +726,9 @@ msgid ""
 "called earlier.  You can optionally specify a coordinate to which the cursor "
 "should be moved before pausing."
 msgstr ""
+":meth:`~curses.window.get_wch` 會重新整理螢幕，然後等待使用者按下按鍵，如果先"
+"前呼叫過 :func:`~curses.echo`，還會顯示該按鍵。你可以選擇性地指定一個座標，讓"
+"游標在暫停前先移動到該處。"
 
 #: ../../howto/curses.rst:443
 msgid ""
@@ -724,13 +737,19 @@ msgid ""
 "encoding in the current locale, so a character encoded with several bytes "
 "takes several calls, one byte per call."
 msgstr ""
+":meth:`~curses.window.getch` 做的是同樣的事情，但回傳的是按鍵的代碼而不是字"
+"元。在 ncurses 中，這會是該按鍵在目前語言環境 (locale) 中編碼的單一位元組，因"
+"此以多個位元組編碼的字元需要多次呼叫，每次呼叫回傳一個位元組。"
 
 #: ../../howto/curses.rst:449
 msgid ""
 ":meth:`~curses.window.getkey` does the same as :meth:`!getch` but returns a "
 "string: an ordinary key as a 1-character string, and a special key as its "
 "name, such as ``KEY_UP``."
 msgstr ""
+":meth:`~curses.window.getkey` 做的事情和 :meth:`!getch` 相同，但回傳的是字"
+"串：一般按鍵會以長度為 1 的字串回傳，特殊按鍵則以其名稱回傳，例如 "
+"``KEY_UP``。"
 
 #: ../../howto/curses.rst:454
 msgid ""
@@ -743,6 +762,12 @@ msgid ""
 "specified delay (measured in tenths of a second), the read fails the same "
 "way."
 msgstr ""
+"你可以使用視窗方法 :meth:`~curses.window.nodelay` 來不等待使用者輸入。呼叫 "
+"``nodelay(True)`` 之後，該視窗的讀取操作會變成非阻塞的。為了表示目前沒有可用"
+"的輸入，:meth:`!get_wch` 和 :meth:`!getkey` 會引發例外，而 :meth:`!getch` 會"
+"回傳 ``-1``。此外還有一個 :func:`~curses.halfdelay` 函式，可以用來（實際上）"
+"為每次讀取設定一個計時器；如果在指定的延遲時間內（以十分之一秒為單位）沒有可"
+"用的輸入，讀取就會以同樣的方式失敗。"
 
 #: ../../howto/curses.rst:465
 msgid ""
@@ -752,6 +777,10 @@ msgid ""
 "const:`curses.KEY_PPAGE`, :const:`curses.KEY_HOME`, or :const:`curses."
 "KEY_LEFT`.  The main loop of your program may look something like this::"
 msgstr ""
+"諸如 Page Up、Home 或方向鍵之類的特殊按鍵，這三種方法都會回傳其中一個 :ref:"
+"`KEY_* 常數 <curses-key-constants>`，其值都大於 255。你可以將回傳值和諸如 :"
+"const:`curses.KEY_PPAGE`、:const:`curses.KEY_HOME` 或 :const:`curses."
+"KEY_LEFT` 之類的常數做比較。你的程式主迴圈可能會長得像這樣： ::"
 
 #: ../../howto/curses.rst:473
 msgid ""
@@ -764,6 +793,14 @@ msgid ""
 "    elif c == curses.KEY_HOME:\n"
 "        x = y = 0"
 msgstr ""
+"while True:\n"
+"    c = stdscr.get_wch()\n"
+"    if c == 'p':\n"
+"        PrintDocument()\n"
+"    elif c == 'q':\n"
+"        break  # 跳出 while 迴圈\n"
+"    elif c == curses.KEY_HOME:\n"
+"        x = y = 0"
 
 #: ../../howto/curses.rst:482
 msgid ""
@@ -783,6 +820,9 @@ msgid ""
 "and the Enter key, which terminates the line. It returns a bytes object, and "
 "can optionally be limited to a fixed number of bytes. ::"
 msgstr ""
+"還有一個方法可以取得整行輸入，:meth:`~curses.window.getstr`。它不常被使用，因"
+"為它的功能相當有限；可用的編輯按鍵只有清除字元和刪除字元，以及用來結束該行的 "
+"Enter 鍵。它會回傳一個 bytes 物件，也可以選擇性地限制為固定的位元組數。 ::"
 
 #: ../../howto/curses.rst:496
 msgid ""
@@ -791,6 +831,10 @@ msgid ""
 "# Get a line of at most 15 bytes, with the cursor on the top line\n"
 "s = stdscr.getstr(0,0, 15)"
 msgstr ""
+"curses.echo()            # 啟用字元回顯\n"
+"\n"
+"# 取得最多 15 個位元組的一行，游標位於頂端那一行\n"
+"s = stdscr.getstr(0,0, 15)"
 
 #: ../../howto/curses.rst:501
 msgid ""

library/ast.po

@@ -4172,14 +4172,13 @@ msgstr ""
 "``type_ignores`` 屬性回傳（否則它始終是一個空串列）。"
 
 #: ../../library/ast.rst:2258
-#, fuzzy
 msgid ""
 "In addition, if ``mode`` is ``'func_type'``, the input syntax is modified to "
 "correspond to :pep:`484` \"signature type comments\", for example ``(str, "
 "int) -> List[str]``."
 msgstr ""
 "此外，如果 ``mode`` 是 ``'func_type'``，則輸入語法將會依據 :pep:`484`\\ 「簽"
-"名型別註解 (signature type comments)」而被修改，例如 ``(str, int) -> "
+"名型別註釋 (signature type comments)」而被修改，例如 ``(str, int) -> "
 "List[str]``。"
 
 #: ../../library/ast.rst:2262

library/asyncio-dev.po

@@ -572,6 +572,31 @@ msgid ""
 "\n"
 "asyncio.run(main())"
 msgstr ""
+"import asyncio\n"
+"work_done = False\n"
+"\n"
+"async def cursor():\n"
+"    try:\n"
+"        yield 1\n"
+"    finally:\n"
+"        assert work_done\n"
+"\n"
+"async def rows():\n"
+"    global work_done\n"
+"    try:\n"
+"        yield 2\n"
+"    finally:\n"
+"        await asyncio.sleep(0.1) # 模擬一些非同步工作\n"
+"        work_done = True\n"
+"\n"
+"\n"
+"async def main():\n"
+"    async for c in cursor():\n"
+"        async for r in rows():\n"
+"            break\n"
+"        break\n"
+"\n"
+"asyncio.run(main())"
 
 #: ../../library/asyncio-dev.rst:319
 msgid "For this example, we get the following output::"

library/atexit.po

@@ -30,22 +30,25 @@ msgid ""
 "called or the main module's execution completes) or, more generally, upon :"
 "term:`interpreter shutdown`."
 msgstr ""
+":mod:`!atexit` 模組定義了用於註冊和註銷\\ :dfn:`退出處理函式`\\ 的函式：這些"
+"函式會在「退出時」自動執行，也就是在程式正常終止時（例如呼叫 :func:`sys."
+"exit` 或主模組執行完成時），或更廣義地說，在\\ :term:`直譯器關閉 "
+"<interpreter shutdown>`\\ 時。"
 
 #: ../../library/atexit.rst:18
-#, fuzzy
 msgid ""
 "At exit, all registered exit handlers are called in the *reverse* order in "
 "which they were registered. If you register ``A``, ``B``, and ``C``, at "
 "interpreter shutdown time they will be run in the order ``C``, ``B``, ``A``. "
 "The assumption is that lower level modules will normally be imported before "
 "higher level modules and thus must be cleaned up later."
 msgstr ""
-"在程式正常終止時（例如呼叫 :func:`sys.exit` 或主要模組執行完成），所有已註冊"
-"函式都會依照後進先出的順序呼叫。這邊做的假設是較低階的模組通常會在較高階模組"
-"之前被引入，因此較低階模組必須在比較後面才被清理。"
+"退出時，所有已註冊的退出處理函式都會按照註冊順序的\\ *反序*\\ 被呼叫。如果你"
+"註冊了 ``A``、``B`` 和 ``C``，則在直譯器關閉時，它們會按照 ``C``、``B``、"
+"``A`` 的順序執行。這邊做的假設是較低階的模組通常會在較高階模組之前被引入，因"
+"此較低階模組必須在比較後面才被清理。"
 
 #: ../../library/atexit.rst:25
-#, fuzzy
 msgid ""
 "If an exception is raised during execution of an exit handler, a traceback "
 "is printed (unless :exc:`SystemExit` is raised) and the exception "
@@ -64,16 +67,19 @@ msgid ""
 "C API :c:func:`Py_EndInterpreter`). Registration functions in this module "
 "only affect the interpreter they are called from."
 msgstr ""
+"在使用多個直譯器的程式中，每個直譯器都有自己的退出處理函式堆疊，這些函式會在"
+"該直譯器關閉時執行（例如透過 :meth:`concurrent.interpreters.Interpreter."
+"close` 或 C API :c:func:`Py_EndInterpreter`）。此模組中的註冊函式只會影響呼叫"
+"它們的那個直譯器。"
 
 #: ../../library/atexit.rst:37
-#, fuzzy
 msgid ""
 "**Note:** Exit handlers are not called when the program is killed by a "
 "signal not handled by Python, when a Python fatal internal error is "
 "detected, or when :func:`os._exit` is called."
 msgstr ""
-"**注意：**\\ 當程式被一個不是來自 Python 的訊號終止、偵測到有 Python 嚴重內部"
-"錯誤時或者 :func:`os._exit` 被呼叫時，透過此模組註冊的函式就不會被呼叫。"
+"**注意：**\\ 當程式被一個 Python 未處理的訊號終止、偵測到 Python 發生嚴重內部"
+"錯誤，或者 :func:`os._exit` 被呼叫時，退出處理函式就不會被呼叫。"
 
 #: ../../library/atexit.rst:41
 msgid ""
@@ -87,39 +93,39 @@ msgid ""
 "that other exit handlers may still run arbitrary Python code after you clean "
 "up. Such code should succeed or fail with an exception, rather than crash."
 msgstr ""
+"在撰寫退出處理函式時，特別是在 C API 擴充套件中，請記住其他退出處理函式可能會"
+"在你清理完成之後，仍然執行任意的 Python 程式碼。這樣的程式碼應該成功執行或以"
+"例外表示失敗，而不是造成崩潰 (crash)。"
 
 #: ../../library/atexit.rst:50
-#, fuzzy
 msgid ""
 "Attempts to start a new thread or :func:`os.fork` a new process in an exit "
 "handler now leads to :exc:`RuntimeError`. Previously, this could cause race "
 "conditions between the main Python runtime thread freeing thread states "
 "while internal :mod:`threading` routines or the new process try to use that "
 "state, which could lead to crashes rather than clean shutdown."
 msgstr ""
-"啟動新執行緒或從已註冊函式呼叫 :func:`os.fork` 可能會導致 Python 主要 "
-"runtime 執行緒釋放執行緒狀態，而內部 :mod:`threading` 例程或新行程嘗試使用該"
-"狀態所形成的競態條件 (race condition)。這可能會導致崩潰 (crash) 而不是完整關"
-"閉中止。"
+"在退出處理函式中嘗試啟動新執行緒或以 :func:`os.fork` 建立新行程，現在會導致"
+"\\ :exc:`RuntimeError`。在此之前，這可能會在 Python 主要 runtime 執行緒釋放執"
+"行緒狀態的同時，內部 :mod:`threading` 例程或新行程嘗試使用該狀態，兩者間形成"
+"競態條件 (race condition)，進而導致崩潰 (crash) 而非乾淨的關閉。"
 
 #: ../../library/atexit.rst:58
-#, fuzzy
 msgid ""
 "When used with subinterpreters, registered functions are local to the "
 "interpreter they were registered in."
 msgstr ""
-"當與 C-API 子直譯器 (subinterpreter) 一起使用時，已註冊函式對於它們所註冊的直"
-"譯器來說是區域的 (local)。"
+"當與子直譯器 (subinterpreter) 一起使用時，已註冊函式對於它們所註冊的直譯器來"
+"說是區域的 (local)。"
 
 #: ../../library/atexit.rst:64
-#, fuzzy
 msgid ""
 "Register *func* as an exit handler. Any optional arguments that are to be "
 "passed to *func* must be passed as arguments to :func:`register`. It is "
 "possible to register the same function and arguments more than once."
 msgstr ""
-"將 *func* 註冊為要在終止時執行的函式。任何要傳遞給 *func* 的可選引數都必須作"
-"為引數傳遞給 :func:`register`。可以多次註冊相同的函式和引數。"
+"將 *func* 註冊為一個退出處理函式。任何要傳遞給 *func* 的可選引數都必須作為引"
+"數傳遞給 :func:`register`。可以多次註冊相同的函式和引數。"
 
 #: ../../library/atexit.rst:69
 msgid ""
@@ -128,7 +134,6 @@ msgid ""
 msgstr "該函式回傳 *func*，這使得可以將其作為裝飾器使用。"
 
 #: ../../library/atexit.rst:74
-#, fuzzy
 msgid ""
 "Remove *func* from the list of exit handlers. :func:`unregister` silently "
 "does nothing if *func* was not previously registered.  If *func* has been "
@@ -137,10 +142,10 @@ msgid ""
 "internally during unregistration, so function references do not need to have "
 "matching identities."
 msgstr ""
-"從在直譯器中止時會執行之函式串列中刪除 *func*。如果 *func* 先前未被註冊，則 :"
-"func:`unregister` 不會執行任何操作。如果 *func* 已被註冊多次，則該函式在 :"
-"mod:`!atexit` 呼叫堆疊 (call stack) 中的所有存在都會被刪除。會在註銷期間於內"
-"部使用相等性比較 (``==``)，因此函式參照不需要具有匹配的識別性。"
+"從退出處理函式串列中移除 *func*。如果 *func* 先前未被註冊，則 :func:"
+"`unregister` 不會執行任何操作。如果 *func* 已被註冊多次，則該函式在 :mod:`!"
+"atexit` 呼叫堆疊 (call stack) 中的所有存在都會被刪除。會在註銷期間於內部使用"
+"相等性比較 (``==``)，因此函式參照不需要具有匹配的識別性。"
 
 #: ../../library/atexit.rst:84
 msgid "Module :mod:`readline`"

library/concurrent.interpreters.po

@@ -312,7 +312,7 @@ msgstr ""
 msgid ""
 "There are a small number of Python types that actually share mutable data "
 "between interpreters:"
-msgstr ""
+msgstr "有少數幾種 Python 型別會實際在直譯器之間共享可變資料："
 
 #: ../../library/concurrent.interpreters.rst:200
 msgid ":class:`memoryview`"
@@ -417,7 +417,7 @@ msgstr ""
 msgid ""
 "Return the result of running the given function in the interpreter (in the "
 "current thread)."
-msgstr ""
+msgstr "回傳在該直譯器（於目前執行緒中）執行給定函式的結果。"
 
 #: ../../library/concurrent.interpreters.rst:287
 msgid "Run the given function in the interpreter (in a new thread)."

library/curses.po

@@ -1236,6 +1236,9 @@ msgid ""
 "for example with :meth:`window.subwin`. By default, current locale encoding "
 "is used (see :func:`locale.getencoding`)."
 msgstr ""
+"在未支援寬字元的建置版本中，用來編碼方法的字串引數以及解碼其回傳結果的編碼。"
+"當建立子視窗時（例如透過 :meth:`window.subwin`），編碼屬性會繼承自父視窗。預"
+"設情況下會使用目前的區域編碼（請參閱 :func:`locale.getencoding`）。"
 
 #: ../../library/curses.rst:1001
 msgid "Clear the window."