sys.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# ppcfish <ppcfish@gmail.com>, 2019
# Rafael Fontenelle <rffontenelle@gmail.com>, 2023
# Freesand Leo <yuqinju@163.com>, 2024
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-11-12 10:57+0000\n"
"PO-Revision-Date: 2017-02-16 17:39+0000\n"
"Last-Translator: Freesand Leo <yuqinju@163.com>, 2024\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"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../c-api/sys.rst:6
msgid "Operating System Utilities"
msgstr "操作系统实用工具"

#: ../../c-api/sys.rst:10
msgid ""
"Return the file system representation for *path*. If the object is a "
":class:`str` or :class:`bytes` object, then its reference count is "
"incremented. If the object implements the :class:`os.PathLike` interface, "
"then :meth:`~os.PathLike.__fspath__` is returned as long as it is a "
":class:`str` or :class:`bytes` object. Otherwise :exc:`TypeError` is raised "
"and ``NULL`` is returned."
msgstr ""
"返回 *path* 在文件系统中的表示形式。 如果该对象是一个 :class:`str` 或 :class:`bytes` "
"对象，则它的引用计数将会增加。 如果该对象实现了 :class:`os.PathLike` 接口，则只要它是一个 :class:`str` 或 "
":class:`bytes` 对象就将返回 :meth:`~os.PathLike.__fspath__`。 在其他情况下将引发 "
":exc:`TypeError` 并返回 ``NULL``。"

#: ../../c-api/sys.rst:22
msgid ""
"Return true (nonzero) if the standard I/O file *fp* with name *filename* is "
"deemed interactive.  This is the case for files for which "
"``isatty(fileno(fp))`` is true.  If the global flag "
":c:data:`Py_InteractiveFlag` is true, this function also returns true if the"
" *filename* pointer is ``NULL`` or if the name is equal to one of the "
"strings ``'<stdin>'`` or ``'???'``."
msgstr ""
"如果名称为 *filename* 的标准 I/O 文件 *fp* 被确认为可交互的则返回真（非零）值。 ``isatty(fileno(fp))`` "
"为真值的文件均属于这种情况。 如果全局旗标 :c:data:`Py_InteractiveFlag` 为真值，此函数在 *filename* 指针为 "
"``NULL`` 或者其名称等于字符串 ``'<stdin>'`` 或 ``'???'`` 时也将返回真值。"

#: ../../c-api/sys.rst:31
msgid ""
"Function to prepare some internal state before a process fork.  This should "
"be called before calling :c:func:`fork` or any similar function that clones "
"the current process. Only available on systems where :c:func:`fork` is "
"defined."
msgstr ""
"在进程分叉之前准备某些内部状态的函数。 此函数应当在调用 :c:func:`fork` 或者任何类似的克隆当前进程的函数之前被调用。 只适用于定义了 "
":c:func:`fork` 的系统。"

#: ../../c-api/sys.rst:37
msgid ""
"The C :c:func:`fork` call should only be made from the :ref:`\"main\" thread"
" <fork-and-threads>` (of the :ref:`\"main\" interpreter <sub-interpreter-"
"support>`).  The same is true for ``PyOS_BeforeFork()``."
msgstr ""
"C :c:func:`fork` 调用应当只在 :ref:`\"main\" 线程 <fork-and-threads>` (位于 "
":ref:`\"main\" 解释器 <sub-interpreter-support>`) 中进行。 对于 ``PyOS_BeforeFork()``"
" 来说也是如此。"

#: ../../c-api/sys.rst:47
msgid ""
"Function to update some internal state after a process fork.  This should be"
" called from the parent process after calling :c:func:`fork` or any similar "
"function that clones the current process, regardless of whether process "
"cloning was successful. Only available on systems where :c:func:`fork` is "
"defined."
msgstr ""
"在进程分叉之后更新某些内部状态的函数。 此函数应当在调用 :c:func:`fork` 或任何类似的克隆当前进程的函数之后被调用，无论进程克隆是否成功。"
" 只适用于定义了 :c:func:`fork` 的系统。"

#: ../../c-api/sys.rst:54
msgid ""
"The C :c:func:`fork` call should only be made from the :ref:`\"main\" thread"
" <fork-and-threads>` (of the :ref:`\"main\" interpreter <sub-interpreter-"
"support>`).  The same is true for ``PyOS_AfterFork_Parent()``."
msgstr ""
"C :c:func:`fork` 调用应当只在 :ref:`\"main\" 线程 <fork-and-threads>` (位于 "
":ref:`\"main\" 解释器 <sub-interpreter-support>`) 中进行。 对于 "
"``PyOS_AfterFork_Parent()`` 来说也是如此。"

#: ../../c-api/sys.rst:64
msgid ""
"Function to update internal interpreter state after a process fork. This "
"must be called from the child process after calling :c:func:`fork`, or any "
"similar function that clones the current process, if there is any chance the"
" process will call back into the Python interpreter. Only available on "
"systems where :c:func:`fork` is defined."
msgstr ""
"在进程分叉之后更新内部解释器状态的函数。 此函数必须在调用 :c:func:`fork` "
"或任何类似的克隆当前进程的函数之后在子进程中被调用，如果该进程有机会回调到 Python 解释器的话。 只适用于定义了 :c:func:`fork` "
"的系统。"

#: ../../c-api/sys.rst:71
msgid ""
"The C :c:func:`fork` call should only be made from the :ref:`\"main\" thread"
" <fork-and-threads>` (of the :ref:`\"main\" interpreter <sub-interpreter-"
"support>`).  The same is true for ``PyOS_AfterFork_Child()``."
msgstr ""
"C :c:func:`fork` 调用应当只在 :ref:`\"main\" 线程 <fork-and-threads>` (位于 "
":ref:`\"main\" 解释器 <sub-interpreter-support>`) 中进行。 对于 "
"``PyOS_AfterFork_Child()`` 来说也是如此。"

#: ../../c-api/sys.rst:79
msgid ""
":func:`os.register_at_fork` allows registering custom Python functions to be"
" called by :c:func:`PyOS_BeforeFork()`, :c:func:`PyOS_AfterFork_Parent` and"
"  :c:func:`PyOS_AfterFork_Child`."
msgstr ""
":func:`os.register_at_fork` 允许注册可被 :c:func:`PyOS_BeforeFork()`, "
":c:func:`PyOS_AfterFork_Parent` 和 :c:func:`PyOS_AfterFork_Child` 调用的自定义 "
"Python 函数。"

#: ../../c-api/sys.rst:86
msgid ""
"Function to update some internal state after a process fork; this should be "
"called in the new process if the Python interpreter will continue to be "
"used. If a new executable is loaded into the new process, this function does"
" not need to be called."
msgstr ""
"在进程分叉之后更新某些内部状态的函数；如果要继续使用 Python 解释器则此函数应当在新进程中被调用。 "
"如果已将一个新的可执行文件载入到新进程中，则不需要调用此函数。"

#: ../../c-api/sys.rst:91
msgid "This function is superseded by :c:func:`PyOS_AfterFork_Child()`."
msgstr "此函数已被 :c:func:`PyOS_AfterFork_Child()` 取代。"

#: ../../c-api/sys.rst:97
msgid ""
"Return true when the interpreter runs out of stack space.  This is a "
"reliable check, but is only available when :const:`USE_STACKCHECK` is "
"defined (currently on Windows using the Microsoft Visual C++ compiler).  "
":const:`USE_STACKCHECK` will be defined automatically; you should never "
"change the definition in your own code."
msgstr ""
"当解释器的栈空间耗尽时返回真值。 这是一个可靠的检查，但仅在定义了 :const:`USE_STACKCHECK` 时可用（目前在 Windows "
"上使用 Microsoft Visual C++ 编译器）。 :const:`USE_STACKCHECK` "
"将被自动定义；你绝不应该在你自己的代码中改变此定义。"

#: ../../c-api/sys.rst:106
msgid ""
"Return the current signal handler for signal *i*.  This is a thin wrapper "
"around either :c:func:`sigaction` or :c:func:`signal`.  Do not call those "
"functions directly! :c:type:`PyOS_sighandler_t` is a typedef alias for "
":c:type:`void (\\*)(int)`."
msgstr ""
"返回当前用于信号 *i* 的信号处理器。 这是一个对 :c:func:`sigaction` 或 :c:func:`signal` 简单包装器。 "
"请不要直接调用那两个函数！ :c:type:`PyOS_sighandler_t` 是对应于 :c:type:`void (\\*)(int)` 的 "
"typedef 别名。"

#: ../../c-api/sys.rst:114
msgid ""
"Set the signal handler for signal *i* to be *h*; return the old signal "
"handler. This is a thin wrapper around either :c:func:`sigaction` or "
":c:func:`signal`.  Do not call those functions directly!  "
":c:type:`PyOS_sighandler_t` is a typedef alias for :c:type:`void "
"(\\*)(int)`."
msgstr ""
"将用于信号 *i* 的信号处理器设为 *h*；返回旧的信号处理器。 这是一个对 :c:func:`sigaction` 或 "
":c:func:`signal` 的简单包装器。 请不要直接调用那两个函数！  :c:type:`PyOS_sighandler_t` 是对应于 "
":c:type:`void (\\*)(int)` 的 typedef 别名。"

#: ../../c-api/sys.rst:121
msgid ""
"Decode a byte string from the locale encoding with the :ref:`surrogateescape"
" error handler <surrogateescape>`: undecodable bytes are decoded as "
"characters in range U+DC80..U+DCFF. If a byte sequence can be decoded as a "
"surrogate character, escape the bytes using the surrogateescape error "
"handler instead of decoding them."
msgstr ""

#: ../../c-api/sys.rst:127 ../../c-api/sys.rst:173
msgid "Encoding, highest priority to lowest priority:"
msgstr ""

#: ../../c-api/sys.rst:129 ../../c-api/sys.rst:175
msgid "``UTF-8`` on macOS, Android, and VxWorks;"
msgstr ""

#: ../../c-api/sys.rst:130 ../../c-api/sys.rst:176
msgid ""
"``UTF-8`` on Windows if :c:data:`Py_LegacyWindowsFSEncodingFlag` is zero;"
msgstr ""

#: ../../c-api/sys.rst:131 ../../c-api/sys.rst:177
msgid "``UTF-8`` if the Python UTF-8 mode is enabled;"
msgstr ""

#: ../../c-api/sys.rst:132 ../../c-api/sys.rst:178
msgid ""
"``ASCII`` if the ``LC_CTYPE`` locale is ``\"C\"``, ``nl_langinfo(CODESET)`` "
"returns the ``ASCII`` encoding (or an alias), and :c:func:`mbstowcs` and "
":c:func:`wcstombs` functions uses the ``ISO-8859-1`` encoding."
msgstr ""

#: ../../c-api/sys.rst:136 ../../c-api/sys.rst:182
msgid "the current locale encoding."
msgstr ""

#: ../../c-api/sys.rst:138
msgid ""
"Return a pointer to a newly allocated wide character string, use "
":c:func:`PyMem_RawFree` to free the memory. If size is not ``NULL``, write "
"the number of wide characters excluding the null character into ``*size``"
msgstr ""
"返回一个指向新分配的由宽字符组成的字符串的指针，使用 :c:func:`PyMem_RawFree` 来释放内存。 如果 size 不为 "
"``NULL``，则将排除了 null 字符的宽字符数量写入到 ``*size``"

#: ../../c-api/sys.rst:142
msgid ""
"Return ``NULL`` on decoding error or memory allocation error. If *size* is "
"not ``NULL``, ``*size`` is set to ``(size_t)-1`` on memory error or set to "
"``(size_t)-2`` on decoding error."
msgstr ""
"在解码错误或内存分配错误时返回 ``NULL``。 如果 *size* 不为 ``NULL``，则 ``*size`` 将在内存错误时设为 "
"``(size_t)-1`` 或在解码错误时设为 ``(size_t)-2``。"

#: ../../c-api/sys.rst:146
msgid ""
"Decoding errors should never happen, unless there is a bug in the C library."
msgstr "解码错误绝对不应当发生，除非 C 库有程序缺陷。"

#: ../../c-api/sys.rst:149
msgid ""
"Use the :c:func:`Py_EncodeLocale` function to encode the character string "
"back to a byte string."
msgstr "请使用 :c:func:`Py_EncodeLocale` 函数来将字符串编码回字节串。"

#: ../../c-api/sys.rst:154
msgid ""
"The :c:func:`PyUnicode_DecodeFSDefaultAndSize` and "
":c:func:`PyUnicode_DecodeLocaleAndSize` functions."
msgstr ""
":c:func:`PyUnicode_DecodeFSDefaultAndSize` 和 "
":c:func:`PyUnicode_DecodeLocaleAndSize` 函数。"

#: ../../c-api/sys.rst:159 ../../c-api/sys.rst:203
msgid "The function now uses the UTF-8 encoding in the UTF-8 mode."
msgstr ""

#: ../../c-api/sys.rst:162
msgid ""
"The function now uses the UTF-8 encoding on Windows if "
":c:data:`Py_LegacyWindowsFSEncodingFlag` is zero;"
msgstr ""
"现在如果在 Windows 上 :c:data:`Py_LegacyWindowsFSEncodingFlag` 为零则此函数将使用 UTF-8 "
"编码格式；"

#: ../../c-api/sys.rst:169
msgid ""
"Encode a wide character string to the locale encoding with the "
":ref:`surrogateescape error handler <surrogateescape>`: surrogate characters"
" in the range U+DC80..U+DCFF are converted to bytes 0x80..0xFF."
msgstr ""

#: ../../c-api/sys.rst:184
msgid "The function uses the UTF-8 encoding in the Python UTF-8 mode."
msgstr ""

#: ../../c-api/sys.rst:186
msgid ""
"Return a pointer to a newly allocated byte string, use :c:func:`PyMem_Free` "
"to free the memory. Return ``NULL`` on encoding error or memory allocation "
"error."
msgstr ""
"返回一个指向新分配的字节串的指针，使用 :c:func:`PyMem_Free` 来释放内存。 当发生编码错误或内存分配错误时返回 ``NULL``。"

#: ../../c-api/sys.rst:190
msgid ""
"If error_pos is not ``NULL``, ``*error_pos`` is set to ``(size_t)-1`` on "
"success,  or set to the index of the invalid character on encoding error."
msgstr ""
"如果 error_pos 不为 ``NULL``，则成功时会将 ``*error_pos`` 设为 "
"``(size_t)-1``，或是在发生编码错误时设为无效字符的索引号。"

#: ../../c-api/sys.rst:193
msgid ""
"Use the :c:func:`Py_DecodeLocale` function to decode the bytes string back "
"to a wide character string."
msgstr "请使用 :c:func:`Py_DecodeLocale` 函数来将字节串解码回由宽字符组成的字符串。"

#: ../../c-api/sys.rst:198
msgid ""
"The :c:func:`PyUnicode_EncodeFSDefault` and :c:func:`PyUnicode_EncodeLocale`"
" functions."
msgstr ""
":c:func:`PyUnicode_EncodeFSDefault` 和 :c:func:`PyUnicode_EncodeLocale` 函数。"

#: ../../c-api/sys.rst:206
msgid ""
"The function now uses the UTF-8 encoding on Windows if "
":c:data:`Py_LegacyWindowsFSEncodingFlag` is zero."
msgstr ""
"现在如果在 Windows 上 :c:data:`Py_LegacyWindowsFSEncodingFlag` 为零则此函数将使用 UTF-8 "
"编码格式。"

#: ../../c-api/sys.rst:214
msgid "System Functions"
msgstr "系统功能"

#: ../../c-api/sys.rst:216
msgid ""
"These are utility functions that make functionality from the :mod:`sys` "
"module accessible to C code.  They all work with the current interpreter "
"thread's :mod:`sys` module's dict, which is contained in the internal thread"
" state structure."
msgstr ""
"这些是使来自 :mod:`sys` 模块的功能可以让 C 代码访问的工具函数。 它们都可用于当前解释器线程的 :mod:`sys` "
"模块的字典，该字典包含在内部线程状态结构体中。"

#: ../../c-api/sys.rst:222
msgid ""
"Return the object *name* from the :mod:`sys` module or ``NULL`` if it does "
"not exist, without setting an exception."
msgstr "返回来自 :mod:`sys` 模块的对象 *name* 或者如果它不存在则返回 ``NULL``，并且不会设置异常。"

#: ../../c-api/sys.rst:227
msgid ""
"Set *name* in the :mod:`sys` module to *v* unless *v* is ``NULL``, in which "
"case *name* is deleted from the sys module. Returns ``0`` on success, ``-1``"
" on error."
msgstr ""
"将 :mod:`sys` 模块中的 *name* 设为 *v* 除非 *v* 为 ``NULL``，在此情况下 *name* 将从 sys "
"模块中被删除。 成功时返回 ``0``，发生错误时返回 ``-1``。"

#: ../../c-api/sys.rst:233
msgid ""
"Reset :data:`sys.warnoptions` to an empty list. This function may be called "
"prior to :c:func:`Py_Initialize`."
msgstr ""
"将 :data:`sys.warnoptions` 重置为空列表。 此函数可在 :c:func:`Py_Initialize` 之前被调用。"

#: ../../c-api/sys.rst:238
msgid ""
"Append *s* to :data:`sys.warnoptions`. This function must be called prior to"
" :c:func:`Py_Initialize` in order to affect the warnings filter list."
msgstr ""
"将 *s* 添加到 :data:`sys.warnoptions`。 此函数必须在 :c:func:`Py_Initialize` "
"之前被调用以便影响警告过滤器列表。"

#: ../../c-api/sys.rst:243
msgid "Append *unicode* to :data:`sys.warnoptions`."
msgstr "将 *unicode* 添加到 :data:`sys.warnoptions`。"

#: ../../c-api/sys.rst:245
msgid ""
"Note: this function is not currently usable from outside the CPython "
"implementation, as it must be called prior to the implicit import of "
":mod:`warnings` in :c:func:`Py_Initialize` to be effective, but can't be "
"called until enough of the runtime has been initialized to permit the "
"creation of Unicode objects."
msgstr ""
"注意：目前此函数不可在 CPython 实现之外使用，因为它必须在 :c:func:`Py_Initialize` 中的 :mod:`warnings`"
" 显式导入之前被调用，但是要等运行时已初始化到足以允许创建 Unicode 对象时才能被调用。"

#: ../../c-api/sys.rst:253
msgid ""
"Set :data:`sys.path` to a list object of paths found in *path* which should "
"be a list of paths separated with the platform's search path delimiter "
"(``:`` on Unix, ``;`` on Windows)."
msgstr ""
"将 :data:`sys.path` 设为由在 *path* 中找到的路径组成的列表对象，该参数应为使用特定平台的搜索路径分隔符 (在 Unix 上为 "
"``:``，在 Windows 上为 ``;``) 分隔的路径的列表。"

#: ../../c-api/sys.rst:259
msgid ""
"Write the output string described by *format* to :data:`sys.stdout`.  No "
"exceptions are raised, even if truncation occurs (see below)."
msgstr "将以 *format* 描述的输出字符串写入到 :data:`sys.stdout`。 不会引发任何异常，即使发生了截断（见下文）。"

#: ../../c-api/sys.rst:262
msgid ""
"*format* should limit the total size of the formatted output string to 1000 "
"bytes or less -- after 1000 bytes, the output string is truncated. In "
"particular, this means that no unrestricted \"%s\" formats should occur; "
"these should be limited using \"%.<N>s\" where <N> is a decimal number "
"calculated so that <N> plus the maximum size of other formatted text does "
"not exceed 1000 bytes.  Also watch out for \"%f\", which can print hundreds "
"of digits for very large numbers."
msgstr ""
"*format* 应当将已格式化的输出字符串的总大小限制在 1000 字节以下 -- 超过 1000 字节后，输出字符串会被截断。 "
"特别地，这意味着不应出现不受限制的 \"%s\" 格式；它们应当使用 \"%.<N>s\" 来限制，其中 <N> 是一个经计算使得 <N> "
"与其他已格式化文本的最大尺寸之和不会超过 1000 字节的十进制数字。 还要注意 \"%f\"，它可能为非常大的数字打印出数以百计的数位。"

#: ../../c-api/sys.rst:270
msgid ""
"If a problem occurs, or :data:`sys.stdout` is unset, the formatted message "
"is written to the real (C level) *stdout*."
msgstr "如果发生了错误，:data:`sys.stdout` 会被清空，已格式化的消息将被写入到真正的 (C 层级) *stdout*。"

#: ../../c-api/sys.rst:275
msgid ""
"As :c:func:`PySys_WriteStdout`, but write to :data:`sys.stderr` or *stderr* "
"instead."
msgstr "类似 :c:func:`PySys_WriteStdout`，但改为写入到 :data:`sys.stderr` 或 *stderr*。"

#: ../../c-api/sys.rst:280
msgid ""
"Function similar to PySys_WriteStdout() but format the message using "
":c:func:`PyUnicode_FromFormatV` and don't truncate the message to an "
"arbitrary length."
msgstr ""
"类似 PySys_WriteStdout() 的函数将会使用 :c:func:`PyUnicode_FromFormatV` "
"来格式化消息并且不会将消息截短至任意长度。"

#: ../../c-api/sys.rst:288
msgid ""
"As :c:func:`PySys_FormatStdout`, but write to :data:`sys.stderr` or *stderr*"
" instead."
msgstr "类似 :c:func:`PySys_FormatStdout`，但改为写入到 :data:`sys.stderr` 或 *stderr*。"

#: ../../c-api/sys.rst:295
msgid ""
"Parse *s* as a set of :option:`-X` options and add them to the current "
"options mapping as returned by :c:func:`PySys_GetXOptions`. This function "
"may be called prior to :c:func:`Py_Initialize`."
msgstr ""
"将 *s* 解析为一个由 :option:`-X` 选项组成的集合并将它们添加到 :c:func:`PySys_GetXOptions` "
"所返回的当前选项映射。 此函数可以在 :c:func:`Py_Initialize` 之前被调用。"

#: ../../c-api/sys.rst:303
msgid ""
"Return the current dictionary of :option:`-X` options, similarly to "
":data:`sys._xoptions`.  On error, ``NULL`` is returned and an exception is "
"set."
msgstr ""
"返回当前 :option:`-X` 选项的字典，类似于 :data:`sys._xoptions`。 发生错误时，将返回 ``NULL`` "
"并设置一个异常。"

#: ../../c-api/sys.rst:312
msgid ""
"Raise an auditing event with any active hooks. Return zero for success and "
"non-zero with an exception set on failure."
msgstr "引发一个审计事件并附带任何激活的钩子。 成功时返回零值或在失败时返回非零值并设置一个异常。"

#: ../../c-api/sys.rst:315
msgid ""
"If any hooks have been added, *format* and other arguments will be used to "
"construct a tuple to pass. Apart from ``N``, the same format characters as "
"used in :c:func:`Py_BuildValue` are available. If the built value is not a "
"tuple, it will be added into a single-element tuple. (The ``N`` format "
"option consumes a reference, but since there is no way to know whether "
"arguments to this function will be consumed, using it may cause reference "
"leaks.)"
msgstr ""
"如果已添加了任何钩子，则将使用 *format* 和其他参数来构造一个用入传入的元组。 除 ``N`` 以外，在 "
":c:func:`Py_BuildValue` 中使用的格式字符均可使用。 如果构建的值不是一个元组，它将被添加到一个单元素元组中。 （格式选项 "
"``N`` 会消耗一个引用，但是由于没有办法知道此函数的参数是否将被消耗，因此使用它可能导致引用泄漏。）"

#: ../../c-api/sys.rst:323
msgid ""
"Note that ``#`` format characters should always be treated as "
":c:type:`Py_ssize_t`, regardless of whether ``PY_SSIZE_T_CLEAN`` was "
"defined."
msgstr ""
"请注意 ``#`` 格式字符应当总是被当作 :c:type:`Py_ssize_t` 来处理，无论是否定义了 ``PY_SSIZE_T_CLEAN``。"

#: ../../c-api/sys.rst:326
msgid ":func:`sys.audit` performs the same function from Python code."
msgstr ":func:`sys.audit` 会执行与来自 Python 代码的函数相同的操作。"

#: ../../c-api/sys.rst:332
msgid ""
"Require :c:type:`Py_ssize_t` for ``#`` format characters. Previously, an "
"unavoidable deprecation warning was raised."
msgstr "要求 :c:type:`Py_ssize_t` 用于 ``#`` 格式字符。 在此之前，会引发一个不可避免的弃用警告。"

#: ../../c-api/sys.rst:338
msgid ""
"Append the callable *hook* to the list of active auditing hooks. Return zero"
" on success and non-zero on failure. If the runtime has been initialized, "
"also set an error on failure. Hooks added through this API are called for "
"all interpreters created by the runtime."
msgstr ""
"将可调用对象 *hook* 添加到激活的审计钩子列表。 在成功时返回零而在失败时返回非零值。 如果运行时已经被初始化，还会在失败时设置一个错误。 通过此"
" API 添加的钩子会针对在运行时创建的所有解释器被调用。"

#: ../../c-api/sys.rst:344
msgid ""
"The *userData* pointer is passed into the hook function. Since hook "
"functions may be called from different runtimes, this pointer should not "
"refer directly to Python state."
msgstr "*userData* 指针会被传入钩子函数。 因于钩子函数可能由不同的运行时调用，该指针不应直接指向 Python 状态。"

#: ../../c-api/sys.rst:348
msgid ""
"This function is safe to call before :c:func:`Py_Initialize`. When called "
"after runtime initialization, existing audit hooks are notified and may "
"silently abort the operation by raising an error subclassed from "
":class:`Exception` (other errors will not be silenced)."
msgstr ""
"此函数可在 :c:func:`Py_Initialize` 之前被安全地调用。 "
"如果在运行时初始化之后被调用，现有的审计钩子将得到通知并可能通过引发一个从 :class:`Exception` "
"子类化的错误静默地放弃操作（其他错误将不会被静默）。"

#: ../../c-api/sys.rst:353
msgid ""
"The hook function is of type :c:type:`int (*)(const char *event, PyObject "
"*args, void *userData)`, where *args* is guaranteed to be a "
":c:type:`PyTupleObject`. The hook function is always called with the GIL "
"held by the Python interpreter that raised the event."
msgstr ""
"钩子函数的类型为 :c:type:`int (*)(const char *event, PyObject *args, void "
"*userData)`，其中 *args* 保证是一个 :c:type:`PyTupleObject`。 钩子函数调用时总是附带引发该事件的 "
"Python 解释器所持有的 GIL。"

#: ../../c-api/sys.rst:358
msgid ""
"See :pep:`578` for a detailed description of auditing.  Functions in the "
"runtime and standard library that raise events are listed in the :ref:`audit"
" events table <audit-events>`. Details are in each function's documentation."
msgstr ""
"请参阅 :pep:`578` 了解有关审计的详细描述。 在运行时和标准库中会引发审计事件的函数清单见 :ref:`审计事件表 <audit-"
"events>`。 更多细节见每个函数的文档。"

#: ../../c-api/sys.rst:365
msgid ""
"If the interpreter is initialized, this function raises a auditing event "
"``sys.addaudithook`` with no arguments. If any existing hooks raise an "
"exception derived from :class:`Exception`, the new hook will not be added "
"and the exception is cleared. As a result, callers cannot assume that their "
"hook has been added unless they control all existing hooks."
msgstr ""
"如果解释器已被初始化，此函数将引发审计事件 ``sys.addaudithook`` 且不附带任何参数。 如果有任何现存的钩子引发了一个派生自 "
":class:`Exception` 的异常，新的钩子将不会被添加且该异常会被清除。 "
"因此，调用方不可假定他们的钩子已被添加除非他们能控制所有现存的钩子。"

#: ../../c-api/sys.rst:377
msgid "Process Control"
msgstr "过程控制"

#: ../../c-api/sys.rst:384
msgid ""
"Print a fatal error message and kill the process.  No cleanup is performed. "
"This function should only be invoked when a condition is detected that would"
" make it dangerous to continue using the Python interpreter; e.g., when the "
"object administration appears to be corrupted.  On Unix, the standard C "
"library function :c:func:`abort` is called which will attempt to produce a "
":file:`core` file."
msgstr ""
"打印一个致命错误消息并杀掉进程。 不会执行任何清理。 此函数应当仅在检测到可能令继续使用 Python "
"解释器变得危险的条件时被发起调用；例如，当对象管理已被破坏的时候。 在 Unix 上，标准 C 库函数 :c:func:`abort` "
"会被调用并将由它来尝试产生一个 :file:`core` 文件。"

#: ../../c-api/sys.rst:391
msgid ""
"The ``Py_FatalError()`` function is replaced with a macro which logs "
"automatically the name of the current function, unless the "
"``Py_LIMITED_API`` macro is defined."
msgstr ""
" ``Py_FatalError()`` 函数会被替换为一个将自动记录当前函数名称的宏，除非定义了 ``Py_LIMITED_API`` 宏。"

#: ../../c-api/sys.rst:395
msgid "Log the function name automatically."
msgstr "自动记录函数名称。"

#: ../../c-api/sys.rst:405
msgid ""
"Exit the current process.  This calls :c:func:`Py_FinalizeEx` and then calls"
" the standard C library function ``exit(status)``.  If "
":c:func:`Py_FinalizeEx` indicates an error, the exit status is set to 120."
msgstr ""
"退出当前进程。 这将调用 :c:func:`Py_FinalizeEx` 然后再调用标准 C 库函数 ``exit(status)``。 如果 "
":c:func:`Py_FinalizeEx` 提示错误，退出状态将被设为 120。"

#: ../../c-api/sys.rst:409
msgid "Errors from finalization no longer ignored."
msgstr "来自最终化的错误不会再被忽略。"

#: ../../c-api/sys.rst:419
msgid ""
"Register a cleanup function to be called by :c:func:`Py_FinalizeEx`.  The "
"cleanup function will be called with no arguments and should return no "
"value.  At most 32 cleanup functions can be registered.  When the "
"registration is successful, :c:func:`Py_AtExit` returns ``0``; on failure, "
"it returns ``-1``.  The cleanup function registered last is called first. "
"Each cleanup function will be called at most once.  Since Python's internal "
"finalization will have completed before the cleanup function, no Python APIs"
" should be called by *func*."
msgstr ""
"注册一个由 :c:func:`Py_FinalizeEx` 调用的清理函数。 调用清理函数将不传入任何参数且不应返回任何值。 最多可以注册32 "
"个清理函数。 当注册成功时，:c:func:`Py_AtExit` 将返回 ``0``；失败时，它将返回 ``-1``。 "
"最后注册的清理函数会最先被调用。 每个清理函数将至多被调用一次。 由于 Python 的内部最终化将在清理函数之前完成，因此 Python API "
"不应被 *func* 调用。"