multiprocessing.shared_memory.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Matt Wang <mattwang44@gmail.com>, 2023-2024
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-09-23 07:52+0800\n"
"PO-Revision-Date: 2023-12-11 00:03+0800\n"
"Last-Translator: Matt Wang <mattwang44@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../../library/multiprocessing.shared_memory.rst:2
msgid ""
":mod:`!multiprocessing.shared_memory` --- Shared memory for direct access "
"across processes"
msgstr ""
":mod:`!multiprocessing.shared_memory` --- 對於共享記憶體的跨行程直接存取"

#: ../../library/multiprocessing.shared_memory.rst:7
msgid "**Source code:** :source:`Lib/multiprocessing/shared_memory.py`"
msgstr "**原始碼：**\\ :source:`Lib/multiprocessing/shared_memory.py`"

#: ../../library/multiprocessing.shared_memory.rst:18
msgid ""
"This module provides a class, :class:`SharedMemory`, for the allocation and "
"management of shared memory to be accessed by one or more processes on a "
"multicore or symmetric multiprocessor (SMP) machine.  To assist with the "
"life-cycle management of shared memory especially across distinct processes, "
"a :class:`~multiprocessing.managers.BaseManager` subclass, :class:"
"`~multiprocessing.managers.SharedMemoryManager`, is also provided in the :"
"mod:`multiprocessing.managers` module."
msgstr ""
"該模組提供了一個 :class:`SharedMemory` 類別，用於分配和管理被多核心或對稱多處"
"理器 (symmetric multiprocessor, SMP) 機器上的一個或多個行程存取的共享記憶體。"
"為了協助共享記憶體的生命週期管理，特別是跨不同行程的管理，:mod:"
"`multiprocessing.managers` 模組中還提供了一個 :class:`~multiprocessing."
"managers.BaseManager` 子類別 :class:`~multiprocessing.managers."
"SharedMemoryManager`。"

#: ../../library/multiprocessing.shared_memory.rst:26
msgid ""
"In this module, shared memory refers to \"POSIX style\" shared memory blocks "
"(though is not necessarily implemented explicitly as such) and does not "
"refer to \"distributed shared memory\".  This style of shared memory permits "
"distinct processes to potentially read and write to a common (or shared) "
"region of volatile memory.  Processes are conventionally limited to only "
"have access to their own process memory space but shared memory permits the "
"sharing of data between processes, avoiding the need to instead send "
"messages between processes containing that data.  Sharing data directly via "
"memory can provide significant performance benefits compared to sharing data "
"via disk or socket or other communications requiring the serialization/"
"deserialization and copying of data."
msgstr ""
"在此模組中，共享記憶體是指「POSIX 風格」的共享記憶體區塊（儘管不一定如此明確"
"實作），而不是指「分散式共享記憶體 (distributed shared memory)」。這種型別的"
"共享記憶體允許不同的行程潛在地讀取和寫入揮發性記憶體 (volatile memory) 的公開"
"（或共享）區域。通常行程只能存取自己的行程記憶體空間，但共享記憶體允許在行程"
"之間共享資料，從而避免需要跨行程傳遞資料的情境。與透過硬碟或 socket 或其他需"
"要序列化/還原序列化 (serialization/deserialization) 和複製資料的通訊方式以共"
"享資料相比，直接透過記憶體共享資料可以提供顯著的性能優勢。"

#: ../../library/multiprocessing.shared_memory.rst:41
msgid ""
"Create an instance of the :class:`!SharedMemory` class for either creating a "
"new shared memory block or attaching to an existing shared memory block.  "
"Each shared memory block is assigned a unique name. In this way, one process "
"can create a shared memory block with a particular name and a different "
"process can attach to that same shared memory block using that same name."
msgstr ""
"建立 :class:`!SharedMemory` 類別的實例，用於建立新的共享記憶體區塊或附加到現"
"有的共享記憶體區塊。每個共享記憶體區塊都被分配了一個唯一的名稱。透過這種方"
"式，一個行程可以建立具有特定名稱的共享記憶體區塊，而不同的行程可以使用該相同"
"名稱附加到同一共享記憶體塊。"

#: ../../library/multiprocessing.shared_memory.rst:48
msgid ""
"As a resource for sharing data across processes, shared memory blocks may "
"outlive the original process that created them.  When one process no longer "
"needs access to a shared memory block that might still be needed by other "
"processes, the :meth:`close` method should be called. When a shared memory "
"block is no longer needed by any process, the :meth:`unlink` method should "
"be called to ensure proper cleanup."
msgstr ""
"作為跨行程共享資料的資源，共享記憶體區塊的壽命可能比建立它們的原始行程還要"
"長。當一個行程不再需要存取但其他行程可能仍需要的共享記憶體區塊時，應該呼叫 :"
"meth:`close` 方法。當任何行程不再需要共享記憶體區塊時，應呼叫 :meth:`unlink` "
"方法以確保正確清理。"

#: ../../library/multiprocessing.shared_memory.rst:0
msgid "Parameters"
msgstr "參數"

#: ../../library/multiprocessing.shared_memory.rst:55
msgid ""
"The unique name for the requested shared memory, specified as a string. When "
"creating a new shared memory block, if ``None`` (the default) is supplied "
"for the name, a novel name will be generated."
msgstr ""
"所請求的共享記憶體的唯一名稱，指定為字串。建立新的共享記憶體區塊時，如果名稱"
"提供為 ``None``\\ （預設值），則會生成一個新的名稱。"

#: ../../library/multiprocessing.shared_memory.rst:61
msgid ""
"Control whether a new shared memory block is created (``True``) or an "
"existing shared memory block is attached (``False``)."
msgstr ""
"控制是否建立新的共享記憶體區塊 (``True``) 或附加現有的共享記憶體區塊 "
"(``False``)。"

#: ../../library/multiprocessing.shared_memory.rst:65
msgid ""
"The requested number of bytes when creating a new shared memory block. "
"Because some platforms choose to allocate chunks of memory based upon that "
"platform's memory page size, the exact size of the shared memory block may "
"be larger or equal to the size requested. When attaching to an existing "
"shared memory block, the *size* parameter is ignored."
msgstr ""
"指定建立新共享記憶體區塊時請求的位元組數。由於某些平台會根據該平台的記憶體頁 "
"(memory page) 大小來選擇分配記憶體區塊，因此共享記憶體區塊的確切大小可能大於"
"或等於請求的大小。當附加到現有共享記憶體區塊時，``size`` 參數將被忽略。"

#: ../../library/multiprocessing.shared_memory.rst:73
msgid ""
"When ``True``, register the shared memory block with a resource tracker "
"process on platforms where the OS does not do this automatically. The "
"resource tracker ensures proper cleanup of the shared memory even if all "
"other processes with access to the memory exit without doing so. Python "
"processes created from a common ancestor using :mod:`multiprocessing` "
"facilities share a single resource tracker process, and the lifetime of "
"shared memory segments is handled automatically among these processes. "
"Python processes created in any other way will receive their own resource "
"tracker when accessing shared memory with *track* enabled. This will cause "
"the shared memory to be deleted by the resource tracker of the first process "
"that terminates. To avoid this issue, users of :mod:`subprocess` or "
"standalone Python processes should set *track* to ``False`` when there is "
"already another process in place that does the bookkeeping. *track* is "
"ignored on Windows, which has its own tracking and automatically deletes "
"shared memory when all handles to it have been closed."
msgstr ""

#: ../../library/multiprocessing.shared_memory.rst:91
msgid "Added the *track* parameter."
msgstr "新增 *track* 參數。"

#: ../../library/multiprocessing.shared_memory.rst:96
msgid ""
"Close the file descriptor/handle to the shared memory from this instance.  :"
"meth:`close` should be called once access to the shared memory block from "
"this instance is no longer needed.  Depending on operating system, the "
"underlying memory may or may not be freed even if all handles to it have "
"been closed.  To ensure proper cleanup, use the :meth:`unlink` method."
msgstr ""

#: ../../library/multiprocessing.shared_memory.rst:105
msgid ""
"Delete the underlying shared memory block.  This should be called only once "
"per shared memory block regardless of the number of handles to it, even in "
"other processes. :meth:`unlink` and :meth:`close` can be called in any "
"order, but trying to access data inside a shared memory block after :meth:"
"`unlink` may result in memory access errors, depending on platform."
msgstr ""

#: ../../library/multiprocessing.shared_memory.rst:112
msgid ""
"This method has no effect on Windows, where the only way to delete a shared "
"memory block is to close all handles."
msgstr ""

#: ../../library/multiprocessing.shared_memory.rst:117
msgid "A memoryview of contents of the shared memory block."
msgstr "共享記憶體區塊內容的記憶體視圖 (memoryview)。"

#: ../../library/multiprocessing.shared_memory.rst:121
msgid "Read-only access to the unique name of the shared memory block."
msgstr "對共享記憶體區塊之唯一名稱的唯讀存取。"

#: ../../library/multiprocessing.shared_memory.rst:125
msgid "Read-only access to size in bytes of the shared memory block."
msgstr "對共享記憶體區塊大小（以位元組為單位）的唯讀存取。"

#: ../../library/multiprocessing.shared_memory.rst:128
msgid ""
"The following example demonstrates low-level use of :class:`SharedMemory` "
"instances::"
msgstr "以下範例示範了 :class:`SharedMemory` 實例的低階使用方式： ::"

#: ../../library/multiprocessing.shared_memory.rst:131
msgid ""
">>> from multiprocessing import shared_memory\n"
">>> shm_a = shared_memory.SharedMemory(create=True, size=10)\n"
">>> type(shm_a.buf)\n"
"<class 'memoryview'>\n"
">>> buffer = shm_a.buf\n"
">>> len(buffer)\n"
"10\n"
">>> buffer[:4] = bytearray([22, 33, 44, 55])  # Modify multiple at once\n"
">>> buffer[4] = 100                           # Modify single byte at a "
"time\n"
">>> # Attach to an existing shared memory block\n"
">>> shm_b = shared_memory.SharedMemory(shm_a.name)\n"
">>> import array\n"
">>> array.array('b', shm_b.buf[:5])  # Copy the data into a new array.array\n"
"array('b', [22, 33, 44, 55, 100])\n"
">>> shm_b.buf[:5] = b'howdy'  # Modify via shm_b using bytes\n"
">>> bytes(shm_a.buf[:5])      # Access via shm_a\n"
"b'howdy'\n"
">>> shm_b.close()   # Close each SharedMemory instance\n"
">>> shm_a.close()\n"
">>> shm_a.unlink()  # Call unlink only once to release the shared memory"
msgstr ""

#: ../../library/multiprocessing.shared_memory.rst:154
msgid ""
"The following example demonstrates a practical use of the :class:"
"`SharedMemory` class with `NumPy arrays <https://numpy.org/>`_, accessing "
"the same :class:`!numpy.ndarray` from two distinct Python shells:"
msgstr ""
"以下範例示範了 :class:`SharedMemory` 類別與 `NumPy 陣列 <https://numpy.org/"
">`_\\ 的實際用法：從兩個不同的 Python shell 存取相同的 :class:`!numpy."
"ndarray`："

#: ../../library/multiprocessing.shared_memory.rst:158
msgid ""
">>> # In the first Python interactive shell\n"
">>> import numpy as np\n"
">>> a = np.array([1, 1, 2, 3, 5, 8])  # Start with an existing NumPy array\n"
">>> from multiprocessing import shared_memory\n"
">>> shm = shared_memory.SharedMemory(create=True, size=a.nbytes)\n"
">>> # Now create a NumPy array backed by shared memory\n"
">>> b = np.ndarray(a.shape, dtype=a.dtype, buffer=shm.buf)\n"
">>> b[:] = a[:]  # Copy the original data into shared memory\n"
">>> b\n"
"array([1, 1, 2, 3, 5, 8])\n"
">>> type(b)\n"
"<class 'numpy.ndarray'>\n"
">>> type(a)\n"
"<class 'numpy.ndarray'>\n"
">>> shm.name  # We did not specify a name so one was chosen for us\n"
"'psm_21467_46075'\n"
"\n"
">>> # In either the same shell or a new Python shell on the same machine\n"
">>> import numpy as np\n"
">>> from multiprocessing import shared_memory\n"
">>> # Attach to the existing shared memory block\n"
">>> existing_shm = shared_memory.SharedMemory(name='psm_21467_46075')\n"
">>> # Note that a.shape is (6,) and a.dtype is np.int64 in this example\n"
">>> c = np.ndarray((6,), dtype=np.int64, buffer=existing_shm.buf)\n"
">>> c\n"
"array([1, 1, 2, 3, 5, 8])\n"
">>> c[-1] = 888\n"
">>> c\n"
"array([  1,   1,   2,   3,   5, 888])\n"
"\n"
">>> # Back in the first Python interactive shell, b reflects this change\n"
">>> b\n"
"array([  1,   1,   2,   3,   5, 888])\n"
"\n"
">>> # Clean up from within the second Python shell\n"
">>> del c  # Unnecessary; merely emphasizing the array is no longer used\n"
">>> existing_shm.close()\n"
"\n"
">>> # Clean up from within the first Python shell\n"
">>> del b  # Unnecessary; merely emphasizing the array is no longer used\n"
">>> shm.close()\n"
">>> shm.unlink()  # Free and release the shared memory block at the very end"
msgstr ""

#: ../../library/multiprocessing.shared_memory.rst:208
msgid ""
"A subclass of :class:`multiprocessing.managers.BaseManager` which can be "
"used for the management of shared memory blocks across processes."
msgstr ""
":class:`multiprocessing.managers.BaseManager` 的子類別，可用於跨行程管理共享"
"記憶體區塊。"

#: ../../library/multiprocessing.shared_memory.rst:211
msgid ""
"A call to :meth:`~multiprocessing.managers.BaseManager.start` on a :class:`!"
"SharedMemoryManager` instance causes a new process to be started. This new "
"process's sole purpose is to manage the life cycle of all shared memory "
"blocks created through it.  To trigger the release of all shared memory "
"blocks managed by that process, call :meth:`~multiprocessing.managers."
"BaseManager.shutdown` on the instance. This triggers a :meth:"
"`~multiprocessing.shared_memory.SharedMemory.unlink` call on all of the :"
"class:`SharedMemory` objects managed by that process and then stops the "
"process itself.  By creating :class:`!SharedMemory` instances through a :"
"class:`!SharedMemoryManager`, we avoid the need to manually track and "
"trigger the freeing of shared memory resources."
msgstr ""
"在 :class:`!SharedMemoryManager` 實例上呼叫 :meth:`~multiprocessing.managers."
"BaseManager.start` 會啟動一個新行程。這個新行程的唯一目的是管理那些透過它建立"
"出的所有共享記憶體區塊的生命週期。要觸發釋放該行程管理的所有共享記憶體區塊，"
"請在實例上呼叫 :meth:`~multiprocessing.managers.BaseManager.shutdown`，這會觸"
"發對該行程管理的所有 :class:`SharedMemory` 物件的 :meth:`~multiprocessing."
"shared_memory.SharedMemory.unlink` 呼叫，然後再停止這個行程。透過 :class:`!"
"SharedMemoryManager` 建立  :class:`!SharedMemory` 實例，我們無需手動追蹤和觸"
"發共享記憶體資源的釋放。"

#: ../../library/multiprocessing.shared_memory.rst:223
msgid ""
"This class provides methods for creating and returning :class:`SharedMemory` "
"instances and for creating a list-like object (:class:`ShareableList`) "
"backed by shared memory."
msgstr ""
"此類別提供了用於建立和回傳 :class:`SharedMemory` 實例以及建立由共享記憶體支援"
"的類串列物件 (:class:`ShareableList`) 的方法。"

#: ../../library/multiprocessing.shared_memory.rst:227
msgid ""
"Refer to :class:`~multiprocessing.managers.BaseManager` for a description of "
"the inherited *address* and *authkey* optional input arguments and how they "
"may be used to connect to an existing :class:`!SharedMemoryManager` service "
"from other processes."
msgstr ""
"請參閱 :class:`~multiprocessing.managers.BaseManager` 了解繼承的 *address* "
"和 *authkey* 可選輸入引數的描述以及如何使用它們從其他行程連接到現有的 :class:"
"`!SharedMemoryManager` 服務。"

#: ../../library/multiprocessing.shared_memory.rst:234
msgid ""
"Create and return a new :class:`SharedMemory` object with the specified "
"*size* in bytes."
msgstr ""
"建立並回傳一個新的 :class:`SharedMemory` 物件，該物件具有指定的 *size*\\ （以"
"位元組為單位）。"

#: ../../library/multiprocessing.shared_memory.rst:239
msgid ""
"Create and return a new :class:`ShareableList` object, initialized by the "
"values from the input *sequence*."
msgstr ""
"建立並回傳一個新的 :class:`ShareableList` 物件，該物件由輸入 *sequence* 中的"
"值初始化。"

#: ../../library/multiprocessing.shared_memory.rst:243
msgid ""
"The following example demonstrates the basic mechanisms of a :class:"
"`~multiprocessing.managers.SharedMemoryManager`:"
msgstr ""
"以下範例示範了 :class:`~multiprocessing.managers.SharedMemoryManager` 的基本"
"作用機制："

#: ../../library/multiprocessing.shared_memory.rst:246
msgid ""
">>> from multiprocessing.managers import SharedMemoryManager\n"
">>> smm = SharedMemoryManager()\n"
">>> smm.start()  # Start the process that manages the shared memory blocks\n"
">>> sl = smm.ShareableList(range(4))\n"
">>> sl\n"
"ShareableList([0, 1, 2, 3], name='psm_6572_7512')\n"
">>> raw_shm = smm.SharedMemory(size=128)\n"
">>> another_sl = smm.ShareableList('alpha')\n"
">>> another_sl\n"
"ShareableList(['a', 'l', 'p', 'h', 'a'], name='psm_6572_12221')\n"
">>> smm.shutdown()  # Calls unlink() on sl, raw_shm, and another_sl"
msgstr ""

#: ../../library/multiprocessing.shared_memory.rst:261
msgid ""
"The following example depicts a potentially more convenient pattern for "
"using :class:`~multiprocessing.managers.SharedMemoryManager` objects via "
"the :keyword:`with` statement to ensure that all shared memory blocks are "
"released after they are no longer needed:"
msgstr ""
"以下範例描述了一種可能更方便的模式，即透過 :keyword:`with` 陳述式使用 :class:"
"`~multiprocessing.managers.SharedMemoryManager` 物件，以確保所有共享記憶體區"
"塊不再被需要後都被釋放："

#: ../../library/multiprocessing.shared_memory.rst:266
msgid ""
">>> with SharedMemoryManager() as smm:\n"
"...     sl = smm.ShareableList(range(2000))\n"
"...     # Divide the work among two processes, storing partial results in "
"sl\n"
"...     p1 = Process(target=do_work, args=(sl, 0, 1000))\n"
"...     p2 = Process(target=do_work, args=(sl, 1000, 2000))\n"
"...     p1.start()\n"
"...     p2.start()  # A multiprocessing.Pool might be more efficient\n"
"...     p1.join()\n"
"...     p2.join()   # Wait for all work to complete in both processes\n"
"...     total_result = sum(sl)  # Consolidate the partial results now in sl"
msgstr ""

#: ../../library/multiprocessing.shared_memory.rst:280
msgid ""
"When using a :class:`~multiprocessing.managers.SharedMemoryManager` in a :"
"keyword:`with` statement, the shared memory blocks created using that "
"manager are all released when the :keyword:`!with` statement's code block "
"finishes execution."
msgstr ""
"在 :keyword:`with` 陳述式中使用 :class:`~multiprocessing.managers."
"SharedMemoryManager` 時，當 :keyword:`!with` 陳述式的程式碼區塊執行完畢時，使"
"用該管理器建立的共享記憶體區塊都會被釋放。"

#: ../../library/multiprocessing.shared_memory.rst:288
msgid ""
"Provide a mutable list-like object where all values stored within are stored "
"in a shared memory block. This constrains storable values to the following "
"built-in data types:"
msgstr ""
"提供一個類似 list 的可變物件，其中儲存的所有值都儲存在共享記憶體區塊中。這將"
"可儲存值限制為以下內建資料型別："

#: ../../library/multiprocessing.shared_memory.rst:292
msgid ":class:`int` (signed 64-bit)"
msgstr ":class:`int` （有符號 64 位元）"

#: ../../library/multiprocessing.shared_memory.rst:293
msgid ":class:`float`"
msgstr ":class:`float`"

#: ../../library/multiprocessing.shared_memory.rst:294
msgid ":class:`bool`"
msgstr ":class:`bool`"

#: ../../library/multiprocessing.shared_memory.rst:295
msgid ":class:`str` (less than 10M bytes each when encoded as UTF-8)"
msgstr ":class:`str` （編碼為 UTF-8 時每個小於 10M 位元組）"

#: ../../library/multiprocessing.shared_memory.rst:296
msgid ":class:`bytes` (less than 10M bytes each)"
msgstr ":class:`bytes` （每個小於 10M 位元組）"

#: ../../library/multiprocessing.shared_memory.rst:297
msgid "``None``"
msgstr "``None``"

#: ../../library/multiprocessing.shared_memory.rst:299
msgid ""
"It also notably differs from the built-in :class:`list` type in that these "
"lists can not change their overall length (i.e. no :meth:`!append`, :meth:`!"
"insert`, etc.) and do not support the dynamic creation of new :class:`!"
"ShareableList` instances via slicing."
msgstr ""
"它也與內建 :class:`list` 型別明顯不同，因為這些 list 不能更改其總長度（即沒"
"有 :meth:`!append`、:meth:`!insert` 等）並且不支援通過切片動態建立新的 :"
"class:`!ShareableList` 實例。"

#: ../../library/multiprocessing.shared_memory.rst:305
msgid ""
"*sequence* is used in populating a new :class:`!ShareableList` full of "
"values. Set to ``None`` to instead attach to an already existing :class:`!"
"ShareableList` by its unique shared memory name."
msgstr ""
"*sequence* 用於填充 (populate) 一個充滿值的新 :class:`!ShareableList`。設定"
"為 ``None`` 以透過其唯一的共享記憶體名稱來附加到已經存在的 :class:`!"
"ShareableList`。"

#: ../../library/multiprocessing.shared_memory.rst:309
msgid ""
"*name* is the unique name for the requested shared memory, as described in "
"the definition for :class:`SharedMemory`.  When attaching to an existing :"
"class:`!ShareableList`, specify its shared memory block's unique name while "
"leaving *sequence* set to ``None``."
msgstr ""
"如 :class:`SharedMemory` 的定義中所述，*name* 是被請求之共享記憶體的唯一名"
"稱。當附加到現有的 :class:`!ShareableList` 時，指定其共享記憶體區塊的唯一名"
"稱，同時將 *sequence* 設定為 ``None``。"

#: ../../library/multiprocessing.shared_memory.rst:316
msgid ""
"A known issue exists for :class:`bytes` and :class:`str` values. If they end "
"with ``\\x00`` nul bytes or characters, those may be *silently stripped* "
"when fetching them by index from the :class:`!ShareableList`. This ``."
"rstrip(b'\\x00')`` behavior is considered a bug and may go away in the "
"future. See :gh:`106939`."
msgstr ""
":class:`bytes` 和 :class:`str` 值存在一個已知問題。如果它們以 ``\\x00`` nul "
"位元組或字元結尾，那麼當透過索引從 :class:`!ShareableList` 中獲取它們時，這些"
"位元組或字元可能會被\\ *默默地剝離 (silently stripped)*。這種 ``."
"rstrip(b'\\x00')`` 行為被認為是一個錯誤，將來可能會消失。請參閱 :gh:"
"`106939`。"

#: ../../library/multiprocessing.shared_memory.rst:322
msgid ""
"For applications where rstripping of trailing nulls is a problem, work "
"around it by always unconditionally appending an extra non-0 byte to the end "
"of such values when storing and unconditionally removing it when fetching:"
msgstr ""
"對於去除尾隨空值 (rstripping of trailing nulls) 會出問題的應用程式，變通解法 "
"(workaround) 是始終無條件地在儲存時於此類值的末尾追加一個額外非 0 位元組，並"
"在獲取時也無條件地刪除它："

#: ../../library/multiprocessing.shared_memory.rst:327
msgid ""
">>> from multiprocessing import shared_memory\n"
">>> nul_bug_demo = shared_memory.ShareableList(['?\\x00', "
"b'\\x03\\x02\\x01\\x00\\x00\\x00'])\n"
">>> nul_bug_demo[0]\n"
"'?'\n"
">>> nul_bug_demo[1]\n"
"b'\\x03\\x02\\x01'\n"
">>> nul_bug_demo.shm.unlink()\n"
">>> padded = shared_memory.ShareableList(['?\\x00\\x07', "
"b'\\x03\\x02\\x01\\x00\\x00\\x00\\x07'])\n"
">>> padded[0][:-1]\n"
"'?\\x00'\n"
">>> padded[1][:-1]\n"
"b'\\x03\\x02\\x01\\x00\\x00\\x00'\n"
">>> padded.shm.unlink()"
msgstr ""
">>> from multiprocessing import shared_memory\n"
">>> nul_bug_demo = shared_memory.ShareableList(['?\\x00', "
"b'\\x03\\x02\\x01\\x00\\x00\\x00'])\n"
">>> nul_bug_demo[0]\n"
"'?'\n"
">>> nul_bug_demo[1]\n"
"b'\\x03\\x02\\x01'\n"
">>> nul_bug_demo.shm.unlink()\n"
">>> padded = shared_memory.ShareableList(['?\\x00\\x07', "
"b'\\x03\\x02\\x01\\x00\\x00\\x00\\x07'])\n"
">>> padded[0][:-1]\n"
"'?\\x00'\n"
">>> padded[1][:-1]\n"
"b'\\x03\\x02\\x01\\x00\\x00\\x00'\n"
">>> padded.shm.unlink()"

#: ../../library/multiprocessing.shared_memory.rst:345
msgid "Return the number of occurrences of *value*."
msgstr "回傳 *value* 出現的次數。"

#: ../../library/multiprocessing.shared_memory.rst:349
msgid ""
"Return first index position of *value*. Raise :exc:`ValueError` if *value* "
"is not present."
msgstr ""
"回傳 *value* 的第一個索引位置。如果 *value* 不存在，則引發 :exc:"
"`ValueError`。"

#: ../../library/multiprocessing.shared_memory.rst:354
msgid ""
"Read-only attribute containing the :mod:`struct` packing format used by all "
"currently stored values."
msgstr "唯讀屬性，包含所有目前有儲存的值所使用的 :mod:`struct` 打包格式。"

#: ../../library/multiprocessing.shared_memory.rst:359
msgid "The :class:`SharedMemory` instance where the values are stored."
msgstr "儲存值的 :class:`SharedMemory` 實例。"

#: ../../library/multiprocessing.shared_memory.rst:362
msgid ""
"The following example demonstrates basic use of a :class:`ShareableList` "
"instance:"
msgstr "以下範例示範了 :class:`ShareableList` 實例的基本用法："

#: ../../library/multiprocessing.shared_memory.rst:395
msgid ""
"The following example depicts how one, two, or many processes may access the "
"same :class:`ShareableList` by supplying the name of the shared memory block "
"behind it:"
msgstr ""
"以下範例描述了一個、兩個或多個行程如何透過提供後面的共享記憶體區塊名稱來存取"
"同一個 :class:`ShareableList`："

#: ../../library/multiprocessing.shared_memory.rst:410
msgid ""
"The following examples demonstrates that :class:`ShareableList` (and "
"underlying :class:`SharedMemory`) objects can be pickled and unpickled if "
"needed. Note, that it will still be the same shared object. This happens, "
"because the deserialized object has the same unique name and is just "
"attached to an existing object with the same name (if the object is still "
"alive):"
msgstr ""
"以下範例示範了如果需要，可以對 :class:`ShareableList`\\ （和底層 :class:"
"`SharedMemory`\\ ）物件進行 pickle 和 unpickle。請注意，它仍然是相同的共享物"
"件。發生這種情況是因為反序列化的物件具有相同的唯一名稱，並且只是附加到具有相"
"同名稱的現有物件（如果該物件仍然存在）："

#: ../../library/multiprocessing.shared_memory.rst:11
msgid "Shared Memory"
msgstr "Shared Memory（共享記憶體）"

#: ../../library/multiprocessing.shared_memory.rst:11
msgid "POSIX Shared Memory"
msgstr "POSIX Shared Memory（POSIX 共享記憶體）"

#: ../../library/multiprocessing.shared_memory.rst:11
msgid "Named Shared Memory"
msgstr "Named Shared Memory（附名共享記憶體）"

#~ msgid ""
#~ "Close access to the shared memory from this instance.  In order to ensure "
#~ "proper cleanup of resources, all instances should call :meth:`close` once "
#~ "the instance is no longer needed.  Note that calling :meth:`!close` does "
#~ "not cause the shared memory block itself to be destroyed."
#~ msgstr ""
#~ "關閉從此實例對共享記憶體的存取。為了確保正確清理資源，一旦實例不再被需要，"
#~ "所有實例都應該呼叫 :meth:`close`。請注意，呼叫 :meth:`!close` 不會使得共享"
#~ "記憶體區塊本身被銷毀。"

#~ msgid ""
#~ "Request that the underlying shared memory block be destroyed.  In order "
#~ "to ensure proper cleanup of resources, :meth:`unlink` should be called "
#~ "once (and only once) across all processes which have need for the shared "
#~ "memory block.  After requesting its destruction, a shared memory block "
#~ "may or may not be immediately destroyed and this behavior may differ "
#~ "across platforms.  Attempts to access data inside the shared memory block "
#~ "after :meth:`!unlink` has been called may result in memory access "
#~ "errors.  Note: the last process relinquishing its hold on a shared memory "
#~ "block may call :meth:`!unlink` and :meth:`close` in either order."
#~ msgstr ""
#~ "請求銷毀底層共享記憶體區塊。為了確保正確清理資源，應該在需要共享記憶體區塊"
#~ "的所有行程中呼叫一次（且僅一次）\\ :meth:`unlink`。請求銷毀後，共享記憶體"
#~ "區塊可能會也可能不會立即銷毀，此行為可能因平台而異。呼叫 :meth:`!unlink` "
#~ "後嘗試存取共享記憶體區塊內的資料可能會導致記憶體存取錯誤。注意：最後一個放"
#~ "棄持有某共享記憶體區塊的行程可以按任意順序呼叫 :meth:`!unlink` 和 :meth:"
#~ "`close`。"