# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Rafael Fontenelle <[email protected]>, 2025

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.12\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-09-22 19:59+0000\n"

"PO-Revision-Date: 2025-07-18 19:57+0000\n"

"Last-Translator: python-doc bot, 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"

"Content-Transfer-Encoding: 8bit\n"

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/asyncio-eventloop.rst:8

msgid "Event Loop"

msgstr "事件循环"

#: ../../library/asyncio-eventloop.rst:10

msgid ""

"**Source code:** :source:`Lib/asyncio/events.py`, "

":source:`Lib/asyncio/base_events.py`"

msgstr ""

"**源代码:** :source:`Lib/asyncio/events.py`, "

":source:`Lib/asyncio/base_events.py`"

#: ../../library/asyncio-eventloop.rst:16

msgid "Preface"

msgstr "前言"

#: ../../library/asyncio-eventloop.rst:17

msgid ""

"The event loop is the core of every asyncio application. Event loops run "

"asynchronous tasks and callbacks, perform network IO operations, and run "

"subprocesses."

msgstr "事件循环是每个 asyncio 应用的核心。 事件循环会运行异步任务和回调，执行网络 IO 操作，以及运行子进程。"

#: ../../library/asyncio-eventloop.rst:21

msgid ""

"Application developers should typically use the high-level asyncio "

"functions, such as :func:`asyncio.run`, and should rarely need to reference "

"the loop object or call its methods. This section is intended mostly for "

"authors of lower-level code, libraries, and frameworks, who need finer "

"control over the event loop behavior."

msgstr ""

"应用开发者通常应当使用高层级的 asyncio 函数，例如 :func:`asyncio.run`，应当很少有必要引用循环对象或调用其方法。 "

"本节所针对的主要是低层级代码、库和框架的编写者，他们需要更细致地控制事件循环行为。"

#: ../../library/asyncio-eventloop.rst:28

msgid "Obtaining the Event Loop"

msgstr "获取事件循环"

#: ../../library/asyncio-eventloop.rst:29

msgid ""

"The following low-level functions can be used to get, set, or create an "

"event loop:"

msgstr "以下低层级函数可被用于获取、设置或创建事件循环:"

#: ../../library/asyncio-eventloop.rst:34

msgid "Return the running event loop in the current OS thread."

msgstr "返回当前 OS 线程中正在运行的事件循环。"

#: ../../library/asyncio-eventloop.rst:36

msgid "Raise a :exc:`RuntimeError` if there is no running event loop."

msgstr "如果没有正在运行的事件循环则会引发 :exc:`RuntimeError`。"

#: ../../library/asyncio-eventloop.rst:38

msgid "This function can only be called from a coroutine or a callback."

msgstr "此函数只能由协程或回调来调用。"

#: ../../library/asyncio-eventloop.rst:44

msgid "Get the current event loop."

msgstr "获取当前事件循环。"

#: ../../library/asyncio-eventloop.rst:46

msgid ""

"When called from a coroutine or a callback (e.g. scheduled with call_soon or"

" similar API), this function will always return the running event loop."

msgstr "当在协程或回调中被调用时（例如通过 call_soon 或类似 API 加入计划任务），此函数将始终返回正在运行的事件循环。"

#: ../../library/asyncio-eventloop.rst:50

msgid ""

"If there is no running event loop set, the function will return the result "

"of the ``get_event_loop_policy().get_event_loop()`` call."

msgstr ""

"如果没有设置正在运行的事件循环，此函数将返回 ``get_event_loop_policy().get_event_loop()`` 调用的结果。"

#: ../../library/asyncio-eventloop.rst:53

msgid ""

"Because this function has rather complex behavior (especially when custom "

"event loop policies are in use), using the :func:`get_running_loop` function"

" is preferred to :func:`get_event_loop` in coroutines and callbacks."

msgstr ""

"由于此函数具有相当复杂的行为（特别是在使用了自定义事件循环策略的时候），更推荐在协程和回调中使用 :func:`get_running_loop` "

"函数而非 :func:`get_event_loop`。"

#: ../../library/asyncio-eventloop.rst:58

msgid ""

"As noted above, consider using the higher-level :func:`asyncio.run` "

"function, instead of using these lower level functions to manually create "

"and close an event loop."

msgstr "如上文所说，请考虑使用高层级的 :func:`asyncio.run` 函数，而不是使用这些低层级的函数来手动创建和关闭事件循环。"

#: ../../library/asyncio-eventloop.rst:62

msgid ""

"Deprecation warning is emitted if there is no current event loop. In some "

"future Python release this will become an error."

msgstr "如果没有当前事件循环则会发出弃用警告。 在未来的 Python 发布版中这将被改为错误。"

#: ../../library/asyncio-eventloop.rst:68

msgid "Set *loop* as the current event loop for the current OS thread."

msgstr "将 *loop* 设为当前 OS 线程的当前事件循环。"

#: ../../library/asyncio-eventloop.rst:72

msgid "Create and return a new event loop object."

msgstr "创建并返回一个新的事件循环对象。"

#: ../../library/asyncio-eventloop.rst:74

msgid ""

"Note that the behaviour of :func:`get_event_loop`, :func:`set_event_loop`, "

"and :func:`new_event_loop` functions can be altered by :ref:`setting a "

"custom event loop policy <asyncio-policies>`."

msgstr ""

"请注意 :func:`get_event_loop`, :func:`set_event_loop` 以及 :func:`new_event_loop`"

" 函数的行为可以通过 :ref:`设置自定义事件循环策略 <asyncio-policies>` 来改变。"

#: ../../library/asyncio-eventloop.rst:80

msgid "Contents"

msgstr "目录"

#: ../../library/asyncio-eventloop.rst:81

msgid "This documentation page contains the following sections:"

msgstr "本文档包含下列小节:"

#: ../../library/asyncio-eventloop.rst:83

msgid ""

"The `Event Loop Methods`_ section is the reference documentation of the "

"event loop APIs;"

msgstr "`事件循环方法集`_ 章节是事件循环APIs的参考文档；"

#: ../../library/asyncio-eventloop.rst:86

msgid ""

"The `Callback Handles`_ section documents the :class:`Handle` and "

":class:`TimerHandle` instances which are returned from scheduling methods "

"such as :meth:`loop.call_soon` and :meth:`loop.call_later`;"

msgstr ""

"`回调处理`_ 章节是从调度方法 例如 :meth:`loop.call_soon` 和 :meth:`loop.call_later` 中返回 "

":class:`Handle` 和 :class:`TimerHandle` 实例的文档。"

#: ../../library/asyncio-eventloop.rst:90

msgid ""

"The `Server Objects`_ section documents types returned from event loop "

"methods like :meth:`loop.create_server`;"

msgstr "`Server Objects`_ 章节记录了从事件循环方法返回的类型，比如 :meth:`loop.create_server` ；"

#: ../../library/asyncio-eventloop.rst:93

msgid ""

"The `Event Loop Implementations`_ section documents the "

":class:`SelectorEventLoop` and :class:`ProactorEventLoop` classes;"

msgstr ""

"`Event Loop Implementations`_ 章节记录了 :class:`SelectorEventLoop` 和 "

":class:`ProactorEventLoop` 类；"

#: ../../library/asyncio-eventloop.rst:96

msgid ""

"The `Examples`_ section showcases how to work with some event loop APIs."

msgstr "`Examples`_ 章节展示了如何使用某些事件循环API。"

#: ../../library/asyncio-eventloop.rst:103

msgid "Event Loop Methods"

msgstr "事件循环方法集"

#: ../../library/asyncio-eventloop.rst:105

msgid "Event loops have **low-level** APIs for the following:"

msgstr "事件循环有下列 **低级** APIs："

#: ../../library/asyncio-eventloop.rst:113

msgid "Running and stopping the loop"

msgstr "运行和停止循环"

#: ../../library/asyncio-eventloop.rst:117

msgid "Run until the *future* (an instance of :class:`Future`) has completed."

msgstr "运行直到 *future* ( :class:`Future` 的实例 ) 被完成。"

#: ../../library/asyncio-eventloop.rst:120

msgid ""

"If the argument is a :ref:`coroutine object <coroutine>` it is implicitly "

"scheduled to run as a :class:`asyncio.Task`."

msgstr ""

"如果参数是 :ref:`coroutine object <coroutine>` ，将被隐式调度为 :class:`asyncio.Task` "

"来运行。"

#: ../../library/asyncio-eventloop.rst:123

msgid "Return the Future's result or raise its exception."

msgstr "返回 Future 的结果 或者引发相关异常。"

#: ../../library/asyncio-eventloop.rst:127

msgid "Run the event loop until :meth:`stop` is called."

msgstr "运行事件循环直到 :meth:`stop` 被调用。"

#: ../../library/asyncio-eventloop.rst:129

msgid ""

"If :meth:`stop` is called before :meth:`run_forever` is called, the loop "

"will poll the I/O selector once with a timeout of zero, run all callbacks "

"scheduled in response to I/O events (and those that were already scheduled),"

" and then exit."

msgstr ""

"如果 :meth:`stop` 在调用 :meth:`run_forever` 之前被调用，循环将轮询一次 I/O "

"选择器并设置超时为零，再运行所有已加入计划任务的回调来响应 I/O 事件（以及已加入计划任务的事件），然后退出。"

#: ../../library/asyncio-eventloop.rst:134

msgid ""

"If :meth:`stop` is called while :meth:`run_forever` is running, the loop "

"will run the current batch of callbacks and then exit. Note that new "

"callbacks scheduled by callbacks will not run in this case; instead, they "

"will run the next time :meth:`run_forever` or :meth:`run_until_complete` is "

"called."

msgstr ""

"如果 :meth:`stop` 在 :meth:`run_forever` 运行期间被调用，循环将运行当前批次的回调然后退出。 "

"请注意在此情况下由回调加入计划任务的新回调将不会运行；它们将会在下次 :meth:`run_forever` 或 "

":meth:`run_until_complete` 被调用时运行。"

#: ../../library/asyncio-eventloop.rst:142

msgid "Stop the event loop."

msgstr "停止事件循环。"

#: ../../library/asyncio-eventloop.rst:146

msgid "Return ``True`` if the event loop is currently running."

msgstr "返回 ``True`` 如果事件循环当前正在运行。"

#: ../../library/asyncio-eventloop.rst:150

msgid "Return ``True`` if the event loop was closed."

msgstr "如果事件循环已经被关闭，返回 ``True`` 。"

#: ../../library/asyncio-eventloop.rst:154

msgid "Close the event loop."

msgstr "关闭事件循环。"

#: ../../library/asyncio-eventloop.rst:156

msgid ""

"The loop must not be running when this function is called. Any pending "

"callbacks will be discarded."

msgstr "当这个函数被调用的时候，循环必须处于非运行状态。pending状态的回调将被丢弃。"

#: ../../library/asyncio-eventloop.rst:159

msgid ""

"This method clears all queues and shuts down the executor, but does not wait"

" for the executor to finish."

msgstr "此方法清除所有的队列并立即关闭执行器，不会等待执行器完成。"

#: ../../library/asyncio-eventloop.rst:162

msgid ""

"This method is idempotent and irreversible. No other methods should be "

"called after the event loop is closed."

msgstr "这个方法是幂等的和不可逆的。事件循环关闭后，不应调用其他方法。"

#: ../../library/asyncio-eventloop.rst:168

msgid ""

"Schedule all currently open :term:`asynchronous generator` objects to close "

"with an :meth:`~agen.aclose` call. After calling this method, the event "

"loop will issue a warning if a new asynchronous generator is iterated. This "

"should be used to reliably finalize all scheduled asynchronous generators."

msgstr ""

"安装所有当前打开的 :term:`asynchronous generator` 对象通过 :meth:`~agen.aclose` 调用来关闭。 "

"在调用此方法后，如果有新的异步生成器被迭代则事件循环将会发出警告。 这应当被用来可靠地最终化所有已加入计划任务的异步生成器。"

#: ../../library/asyncio-eventloop.rst:174

msgid ""

"Note that there is no need to call this function when :func:`asyncio.run` is"

" used."

msgstr "请注意当使用 :func:`asyncio.run` 时不必调用此函数。"

#: ../../library/asyncio-eventloop.rst:177

#: ../../library/asyncio-eventloop.rst:1285

#: ../../library/asyncio-eventloop.rst:1707

msgid "Example::"

msgstr "示例::"

#: ../../library/asyncio-eventloop.rst:179

msgid ""

"try:\n"

" loop.run_forever()\n"

"finally:\n"

" loop.run_until_complete(loop.shutdown_asyncgens())\n"

" loop.close()"

msgstr ""

"try:\n"

" loop.run_forever()\n"

"finally:\n"

" loop.run_until_complete(loop.shutdown_asyncgens())\n"

" loop.close()"

#: ../../library/asyncio-eventloop.rst:190

msgid ""

"Schedule the closure of the default executor and wait for it to join all of "

"the threads in the :class:`~concurrent.futures.ThreadPoolExecutor`. Once "

"this method has been called, using the default executor with "

":meth:`loop.run_in_executor` will raise a :exc:`RuntimeError`."

msgstr ""

"安排默认执行器的关闭并等待它合并 :class:`~concurrent.futures.ThreadPoolExecutor` 中的所有线程。 "

"一旦此方法被调用，将默认执行器与 :meth:`loop.run_in_executor` 一起使用将引发 :exc:`RuntimeError`。"

#: ../../library/asyncio-eventloop.rst:196

msgid ""

"The *timeout* parameter specifies the amount of time (in :class:`float` "

"seconds) the executor will be given to finish joining. With the default, "

"``None``, the executor is allowed an unlimited amount of time."

msgstr ""

"*timeout* 形参指定提供给执行器结束合并的时间限制（为 :class:`float` 形式的秒数）。 在默认情况下，该值为 "

"``None``，即允许执行器无时间限制地执行。"

#: ../../library/asyncio-eventloop.rst:201

msgid ""

"If the *timeout* is reached, a :exc:`RuntimeWarning` is emitted and the "

"default executor is terminated without waiting for its threads to finish "

"joining."

msgstr "如果达到了 *timeout*，将会发出 :exc:`RuntimeWarning` 并且默认执行器将会终结而不等待其线程结束合并。"

#: ../../library/asyncio-eventloop.rst:207

msgid ""

"Do not call this method when using :func:`asyncio.run`, as the latter "

"handles default executor shutdown automatically."

msgstr "当使用 :func:`asyncio.run` 不要调用此方法，因为它会自动处理默认执行器的关闭。"

#: ../../library/asyncio-eventloop.rst:212

msgid "Added the *timeout* parameter."

msgstr "增加了 *timeout* 形参。"

#: ../../library/asyncio-eventloop.rst:216

msgid "Scheduling callbacks"

msgstr "安排回调"

#: ../../library/asyncio-eventloop.rst:220

msgid ""

"Schedule the *callback* :term:`callback` to be called with *args* arguments "

"at the next iteration of the event loop."

msgstr "安排 *callback* :term:`callback` 在事件循环的下一次迭代时附带 *args* 参数被调用。"

#: ../../library/asyncio-eventloop.rst:223

msgid ""

"Return an instance of :class:`asyncio.Handle`, which can be used later to "

"cancel the callback."

msgstr "返回一个 :class:`asyncio.Handle` 的实例，可在此后被用来取消回调。"

#: ../../library/asyncio-eventloop.rst:226

msgid ""

"Callbacks are called in the order in which they are registered. Each "

"callback will be called exactly once."

msgstr "回调按其注册顺序被调用。每个回调仅被调用一次。"

#: ../../library/asyncio-eventloop.rst:229

msgid ""

"The optional keyword-only *context* argument specifies a custom "

":class:`contextvars.Context` for the *callback* to run in. Callbacks use the"

" current context when no *context* is provided."

msgstr ""

"可选的仅限关键字参数 *context* 指定一个自定义的 :class:`contextvars.Context` 供 *callback* "

"在其中运行。 当未提供 *context* 时回调将使用当前上下文。"

#: ../../library/asyncio-eventloop.rst:233

msgid "Unlike :meth:`call_soon_threadsafe`, this method is not thread-safe."

msgstr "与 :meth:`call_soon_threadsafe` 不同，此方法不是线程安全的。"

#: ../../library/asyncio-eventloop.rst:237

msgid ""

"A thread-safe variant of :meth:`call_soon`. When scheduling callbacks from "

"another thread, this function *must* be used, since :meth:`call_soon` is not"

" thread-safe."

msgstr ""

":meth:`call_soon` 的线程安全版。 当从另一个线程安排回调时，*必须* 使用此函数，因为 :meth:`call_soon` "

"不是线程安全的。"

#: ../../library/asyncio-eventloop.rst:241

msgid ""

"This function is safe to be called from a reentrant context or signal "

"handler, however, it is not safe or fruitful to use the returned handle in "

"such contexts."

msgstr "此函数可以从一个重入上下文或信号处理器安全地调用，不过，在这样的上下文中使用所返回的句柄则不是安全或有益的。"

#: ../../library/asyncio-eventloop.rst:244

msgid ""

"Raises :exc:`RuntimeError` if called on a loop that's been closed. This can "

"happen on a secondary thread when the main application is shutting down."

msgstr "如果在已被关闭的循环上调用则会引发 :exc:`RuntimeError`。 这可能会在主应用程序被关闭时在二级线程上发生。"

#: ../../library/asyncio-eventloop.rst:248

msgid ""

"See the :ref:`concurrency and multithreading <asyncio-multithreading>` "

"section of the documentation."

msgstr ""

"参见 :ref:`concurrency and multithreading <asyncio-multithreading>` 部分的文档。"

#: ../../library/asyncio-eventloop.rst:251

#: ../../library/asyncio-eventloop.rst:301

#: ../../library/asyncio-eventloop.rst:321

msgid ""

"The *context* keyword-only parameter was added. See :pep:`567` for more "

"details."

msgstr "加入键值类形参 *context*。请参阅 :pep:`567` 查看更多细节。"

#: ../../library/asyncio-eventloop.rst:259

msgid ""

"Most :mod:`asyncio` scheduling functions don't allow passing keyword "

"arguments. To do that, use :func:`functools.partial`::"

msgstr "大多数 :mod:`asyncio` 的调度函数不让传递关键字参数。为此，请使用 :func:`functools.partial` ："

#: ../../library/asyncio-eventloop.rst:262

msgid ""

"# will schedule \"print(\"Hello\", flush=True)\"\n"

"loop.call_soon(\n"

" functools.partial(print, \"Hello\", flush=True))"

msgstr ""

"# 将把 \"print(\"Hello\", flush=True)\" 加入计划任务\n"

"loop.call_soon(\n"

" functools.partial(print, \"Hello\", flush=True))"

#: ../../library/asyncio-eventloop.rst:266

msgid ""

"Using partial objects is usually more convenient than using lambdas, as "

"asyncio can render partial objects better in debug and error messages."

msgstr "使用 partial 对象通常比使用lambda更方便，asyncio 在调试和错误消息中能更好的呈现 partial 对象。"

#: ../../library/asyncio-eventloop.rst:274

msgid "Scheduling delayed callbacks"

msgstr "调度延迟回调"

#: ../../library/asyncio-eventloop.rst:276

msgid ""

"Event loop provides mechanisms to schedule callback functions to be called "

"at some point in the future. Event loop uses monotonic clocks to track "

"time."

msgstr "事件循环提供安排调度函数在将来某个时刻调用的机制。事件循环使用单调时钟来跟踪时间。"

#: ../../library/asyncio-eventloop.rst:283

msgid ""

"Schedule *callback* to be called after the given *delay* number of seconds "

"(can be either an int or a float)."

msgstr "安排 *callback* 在给定的 *delay* 秒（可以是 int 或者 float）后被调用。"

#: ../../library/asyncio-eventloop.rst:286

#: ../../library/asyncio-eventloop.rst:318

msgid ""

"An instance of :class:`asyncio.TimerHandle` is returned which can be used to"

" cancel the callback."

msgstr "返回一个 :class:`asyncio.TimerHandle` 实例，该实例能用于取消回调。"

#: ../../library/asyncio-eventloop.rst:289

msgid ""

"*callback* will be called exactly once. If two callbacks are scheduled for "

"exactly the same time, the order in which they are called is undefined."

msgstr "*callback* 只被调用一次。如果两个回调被安排在同样的时间点，执行顺序未限定。"

#: ../../library/asyncio-eventloop.rst:293

msgid ""

"The optional positional *args* will be passed to the callback when it is "

"called. If you want the callback to be called with keyword arguments use "

":func:`functools.partial`."

msgstr ""

"可选的位置参数 *args* 在被调用的时候传递给 *callback*  。 如果你想把关键字参数传递给 *callback* ，请使用 "

":func:`functools.partial` 。"

#: ../../library/asyncio-eventloop.rst:297

msgid ""

"An optional keyword-only *context* argument allows specifying a custom "

":class:`contextvars.Context` for the *callback* to run in. The current "

"context is used when no *context* is provided."

msgstr ""

"可选键值类的参数 *context* 允许 *callback* 运行在一个指定的自定义 :class:`contextvars.Context` "

"对象中。如果没有提供 *context* ，则使用当前上下文。"

#: ../../library/asyncio-eventloop.rst:305

msgid ""

"In Python 3.7 and earlier with the default event loop implementation, the "

"*delay* could not exceed one day. This has been fixed in Python 3.8."

msgstr "在 Python 3.7 和更早版本的默认事件循环实现中， *delay* 不能超过一天。 这在 Python 3.8 中已被修复。"

#: ../../library/asyncio-eventloop.rst:312

msgid ""

"Schedule *callback* to be called at the given absolute timestamp *when* (an "

"int or a float), using the same time reference as :meth:`loop.time`."

msgstr ""

"安排 *callback* 在给定的绝对时间戳 *when* (int 或 float) 被调用，使用与 :meth:`loop.time` "

"同样的时间参考。"

#: ../../library/asyncio-eventloop.rst:316

msgid "This method's behavior is the same as :meth:`call_later`."

msgstr "本方法的行为和 :meth:`call_later` 方法相同。"

#: ../../library/asyncio-eventloop.rst:325

msgid ""

"In Python 3.7 and earlier with the default event loop implementation, the "

"difference between *when* and the current time could not exceed one day. "

"This has been fixed in Python 3.8."

msgstr ""

"在 Python 3.7 和更早版本的默认事件循环实现中，*when* 和当前时间相差不能超过一天。 在这 Python 3.8 中已被修复。"

#: ../../library/asyncio-eventloop.rst:332

msgid ""

"Return the current time, as a :class:`float` value, according to the event "

"loop's internal monotonic clock."

msgstr "根据时间循环内部的单调时钟，返回当前时间为一个 :class:`float` 值。"

#: ../../library/asyncio-eventloop.rst:336

msgid ""

"In Python 3.7 and earlier timeouts (relative *delay* or absolute *when*) "

"should not exceed one day. This has been fixed in Python 3.8."

msgstr ""

"在 Python 3.7 和更早版本中超时 (相对的 *delay* 或绝对的 *when*) 不能超过一天。 这在 Python 3.8 中已被修复。"

#: ../../library/asyncio-eventloop.rst:342

msgid "The :func:`asyncio.sleep` function."

msgstr ":func:`asyncio.sleep` 函数。"

#: ../../library/asyncio-eventloop.rst:346

msgid "Creating Futures and Tasks"

msgstr "创建 Future 和 Task"

#: ../../library/asyncio-eventloop.rst:350

msgid "Create an :class:`asyncio.Future` object attached to the event loop."

msgstr "创建一个附加到事件循环中的 :class:`asyncio.Future` 对象。"

#: ../../library/asyncio-eventloop.rst:352

msgid ""

"This is the preferred way to create Futures in asyncio. This lets third-"

"party event loops provide alternative implementations of the Future object "

"(with better performance or instrumentation)."

msgstr "这是在asyncio中创建Futures的首选方式。这让第三方事件循环可以提供Future 对象的替代实现(更好的性能或者功能)。"

#: ../../library/asyncio-eventloop.rst:360

msgid ""

"Schedule the execution of :ref:`coroutine <coroutine>` *coro*. Return a "

":class:`Task` object."

msgstr "将 :ref:`协程 <coroutine>` *coro* 的执行加入计划任务。 返回一个 :class:`Task` 对象。"

#: ../../library/asyncio-eventloop.rst:363

msgid ""

"Third-party event loops can use their own subclass of :class:`Task` for "

"interoperability. In this case, the result type is a subclass of "

":class:`Task`."

msgstr ""

"第三方的事件循环可以使用它们自己的 :class:`Task` 子类来满足互操作性。这种情况下结果类型是一个 :class:`Task` 的子类。"

#: ../../library/asyncio-eventloop.rst:367

msgid ""

"If the *name* argument is provided and not ``None``, it is set as the name "

"of the task using :meth:`Task.set_name`."

msgstr "如果提供了 *name* 参数且不为 ``None``，它会使用 :meth:`Task.set_name` 来设为任务的名称。"

#: ../../library/asyncio-eventloop.rst:370

msgid ""

"An optional keyword-only *context* argument allows specifying a custom "

":class:`contextvars.Context` for the *coro* to run in. The current context "

"copy is created when no *context* is provided."

msgstr ""

"可选的 *context* 参数允许指定自定义的 :class:`contextvars.Context` 供 *coro* 运行。 当未提供 "

"*context* 时将创建当前上下文的副本。"

#: ../../library/asyncio-eventloop.rst:374

msgid "Added the *name* parameter."

msgstr "增加了 *name* 形参。"

#: ../../library/asyncio-eventloop.rst:377

msgid "Added the *context* parameter."

msgstr "增加了 *context* 形参。"

#: ../../library/asyncio-eventloop.rst:382

msgid "Set a task factory that will be used by :meth:`loop.create_task`."

msgstr "设置一个任务工厂，它将由 :meth:`loop.create_task` 来使用。"

#: ../../library/asyncio-eventloop.rst:385

msgid ""

"If *factory* is ``None`` the default task factory will be set. Otherwise, "

"*factory* must be a *callable* with the signature matching ``(loop, coro, "

"context=None)``, where *loop* is a reference to the active event loop, and "

"*coro* is a coroutine object. The callable must return a "

":class:`asyncio.Future`-compatible object."

msgstr ""

"如果 *factory* 为 ``None`` 则将设置默认的任务工厂。 在其他情况下，*factory* 必须是一个 *可调用对象* 且其签名要匹配 "

"``(loop, coro, context=None)``，其中 *loop* 是对活动事件循环的引用，而 *coro* 是一个协程对象。 "

"该可调用对象必须返回一个兼容 :class:`asyncio.Future` 的对象。"

#: ../../library/asyncio-eventloop.rst:393

msgid "Return a task factory or ``None`` if the default one is in use."

msgstr "返回一个任务工厂，或者如果是使用默认值则返回 ``None``。"

#: ../../library/asyncio-eventloop.rst:397

msgid "Opening network connections"

msgstr "打开网络连接"

#: ../../library/asyncio-eventloop.rst:409

msgid ""

"Open a streaming transport connection to a given address specified by *host*"

" and *port*."

msgstr "打开一个流式传输连接，连接到由 *host* 和 *port* 指定的地址。"

#: ../../library/asyncio-eventloop.rst:412

msgid ""

"The socket family can be either :py:const:`~socket.AF_INET` or "

":py:const:`~socket.AF_INET6` depending on *host* (or the *family* argument, "

"if provided)."

msgstr ""

"套接字族可以是 :py:const:`~socket.AF_INET` 或 :py:const:`~socket.AF_INET6`，具体取决于 "

"*host* (或 *family* 参数，如果有提供的话)。"

#: ../../library/asyncio-eventloop.rst:416

msgid "The socket type will be :py:const:`~socket.SOCK_STREAM`."

msgstr "套接字类型将为 :py:const:`~socket.SOCK_STREAM`。"

#: ../../library/asyncio-eventloop.rst:418

#: ../../library/asyncio-eventloop.rst:1195

#: ../../library/asyncio-eventloop.rst:1212

msgid ""

"*protocol_factory* must be a callable returning an :ref:`asyncio protocol "

"<asyncio-protocol>` implementation."

msgstr ""

"*protocol_factory* 必须为一个返回 :ref:`asyncio 协议 <asyncio-protocol>` 实现的可调用对象。"

#: ../../library/asyncio-eventloop.rst:421

msgid ""

"This method will try to establish the connection in the background. When "

"successful, it returns a ``(transport, protocol)`` pair."

msgstr "这个方法会尝试在后台创建连接。当创建成功，返回 ``(transport, protocol)`` 组合。"

#: ../../library/asyncio-eventloop.rst:424

msgid "The chronological synopsis of the underlying operation is as follows:"

msgstr "底层操作的大致的执行顺序是这样的："

#: ../../library/asyncio-eventloop.rst:426

msgid ""

"The connection is established and a :ref:`transport <asyncio-transport>` is "

"created for it."

msgstr "创建连接并为其创建一个 :ref:`传输 <asyncio-transport>`。"

#: ../../library/asyncio-eventloop.rst:429

msgid ""

"*protocol_factory* is called without arguments and is expected to return a "

":ref:`protocol <asyncio-protocol>` instance."

msgstr "不带参数地调用 *protocol_factory* 并预期返回一个 :ref:`协议 <asyncio-protocol>` 实例。"

#: ../../library/asyncio-eventloop.rst:432

msgid ""

"The protocol instance is coupled with the transport by calling its "

":meth:`~BaseProtocol.connection_made` method."

msgstr "协议实例通过调用其 :meth:`~BaseProtocol.connection_made` 方法与传输进行配对。"

#: ../../library/asyncio-eventloop.rst:435

msgid "A ``(transport, protocol)`` tuple is returned on success."

msgstr "成功时返回一个 ``(transport, protocol)`` 元组。"

#: ../../library/asyncio-eventloop.rst:437

msgid ""

"The created transport is an implementation-dependent bidirectional stream."

msgstr "创建的传输是一个具体实现相关的双向流。"

#: ../../library/asyncio-eventloop.rst:440

#: ../../library/asyncio-eventloop.rst:573

msgid "Other arguments:"

msgstr "其他参数："

#: ../../library/asyncio-eventloop.rst:442

msgid ""

"*ssl*: if given and not false, a SSL/TLS transport is created (by default a "

"plain TCP transport is created). If *ssl* is a :class:`ssl.SSLContext` "

"object, this context is used to create the transport; if *ssl* is "

":const:`True`, a default context returned from "

":func:`ssl.create_default_context` is used."

msgstr ""

"*ssl*: 如果给定该参数且不为假值，则会创建一个 SSL/TLS 传输（默认创建一个纯 TCP 传输）。 如果 *ssl* 是一个 "

":class:`ssl.SSLContext` 对象，则会使用此上下文来创建传输对象；如果 *ssl* 为 :const:`True`，则会使用从 "

":func:`ssl.create_default_context` 返回的默认上下文。"

#: ../../library/asyncio-eventloop.rst:448

msgid ":ref:`SSL/TLS security considerations <ssl-security>`"

msgstr ":ref:`SSL/TLS security considerations <ssl-security>`"

#: ../../library/asyncio-eventloop.rst:450

msgid ""

"*server_hostname* sets or overrides the hostname that the target server's "

"certificate will be matched against. Should only be passed if *ssl* is not "

"``None``. By default the value of the *host* argument is used. If *host* "

"is empty, there is no default and you must pass a value for "

"*server_hostname*. If *server_hostname* is an empty string, hostname "

"matching is disabled (which is a serious security risk, allowing for "

"potential man-in-the-middle attacks)."

msgstr ""

"*server_hostname* 设置或覆盖目标服务器的证书将要匹配的主机名。 应当只在 *ssl* 不为 ``None`` 时传入。 "

"默认情况下会使用 *host* 参数的值。 如果 *host* 为空那就没有默认值，你必须为 *server_hostname* 传入一个值。 如果 "

"*server_hostname* 为空字符串，则主机名匹配会被禁用（这是一个严重的安全风险，使得潜在的中间人攻击成为可能）。"

#: ../../library/asyncio-eventloop.rst:458

msgid ""

"*family*, *proto*, *flags* are the optional address family, protocol and "

"flags to be passed through to getaddrinfo() for *host* resolution. If given,"

" these should all be integers from the corresponding :mod:`socket` module "

"constants."

msgstr ""

"*family*, *proto*, *flags* 是可选的地址族、协议和标志，它们会被传递给 getaddrinfo() 来对 *host* "

"进行解析。如果要指定的话，这些都应该是来自于 :mod:`socket` 模块的对应常量。"

#: ../../library/asyncio-eventloop.rst:463

msgid ""

"*happy_eyeballs_delay*, if given, enables Happy Eyeballs for this "

"connection. It should be a floating-point number representing the amount of "

"time in seconds to wait for a connection attempt to complete, before "

"starting the next attempt in parallel. This is the \"Connection Attempt "

"Delay\" as defined in :rfc:`8305`. A sensible default value recommended by "

"the RFC is ``0.25`` (250 milliseconds)."

msgstr ""

"如果给出 *happy_eyeballs_delay*，它将为此链接启用 Happy Eyeballs。 "

"该函数应当为一个表示在开始下一个并行尝试之前要等待连接尝试完成的秒数的浮点数。 这也就是在 :rfc:`8305` 中定义的 \"连接尝试延迟\"。 该"

" RFC 所推荐的合理默认值为 ``0.25`` (250 毫秒)。"

#: ../../library/asyncio-eventloop.rst:471

msgid ""

"*interleave* controls address reordering when a host name resolves to "

"multiple IP addresses. If ``0`` or unspecified, no reordering is done, and "

"addresses are tried in the order returned by :meth:`getaddrinfo`. If a "

"positive integer is specified, the addresses are interleaved by address "

"family, and the given integer is interpreted as \"First Address Family "

"Count\" as defined in :rfc:`8305`. The default is ``0`` if "

"*happy_eyeballs_delay* is not specified, and ``1`` if it is."

msgstr ""

"*interleave* 控制当主机名解析为多个 IP 地址时的地址重排序。 如果该参数为 ``0`` 或未指定，则不会进行重排序，这些地址会按 "

":meth:`getaddrinfo` 所返回的顺序进行尝试。 如果指定了一个正整数，这些地址会按地址族交错排列，而指定的整数会被解读为 "

":rfc:`8305` 所定义的 \"首个地址族计数\"。 如果 *happy_eyeballs_delay* 未指定则默认值为 ``0``，否则为 "

"``1``。"

#: ../../library/asyncio-eventloop.rst:480

msgid ""

"*sock*, if given, should be an existing, already connected "

":class:`socket.socket` object to be used by the transport. If *sock* is "

"given, none of *host*, *port*, *family*, *proto*, *flags*, "

"*happy_eyeballs_delay*, *interleave* and *local_addr* should be specified."

msgstr ""

"如果给出 *sock*，它应当是一个已存在、已连接并将被传输所使用的 :class:`socket.socket` 对象。 如果给出了 *sock*，则"

" *host*, *port*, *family*, *proto*, *flags*, *happy_eyeballs_delay*, "

"*interleave* 和 *local_addr* 都不应当被指定。"

#: ../../library/asyncio-eventloop.rst:488

#: ../../library/asyncio-eventloop.rst:604

#: ../../library/asyncio-eventloop.rst:836

msgid ""

"The *sock* argument transfers ownership of the socket to the transport "

"created. To close the socket, call the transport's "

":meth:`~asyncio.BaseTransport.close` method."

msgstr ""

"*sock* 参数可将套接字的所有权转给所创建的传输。 要关闭该套接字，请调用传输的 "

":meth:`~asyncio.BaseTransport.close` 方法。"

#: ../../library/asyncio-eventloop.rst:492

msgid ""

"*local_addr*, if given, is a ``(local_host, local_port)`` tuple used to bind"

" the socket locally. The *local_host* and *local_port* are looked up using "

"``getaddrinfo()``, similarly to *host* and *port*."

msgstr ""

"如果给出 *local_addr*，它应当是一个用来在本地绑定套接字的 ``(local_host, local_port)`` 元组。 "

"*local_host* 和 *local_port* 会使用 ``getaddrinfo()`` 来查找，这与 *host* 和 *port* 类似。"

#: ../../library/asyncio-eventloop.rst:496

#: ../../library/asyncio-eventloop.rst:932

msgid ""

"*ssl_handshake_timeout* is (for a TLS connection) the time in seconds to "

"wait for the TLS handshake to complete before aborting the connection. "

"``60.0`` seconds if ``None`` (default)."

msgstr ""

"*ssl_handshake_timeout* 是（用于 TLS 连接的）在放弃连接之前要等待 TLS 握手完成的秒数。 如果参数为 ``None`` "

"则使用 (默认的) ``60.0``。"

#: ../../library/asyncio-eventloop.rst:500

#: ../../library/asyncio-eventloop.rst:751

#: ../../library/asyncio-eventloop.rst:847

#: ../../library/asyncio-eventloop.rst:936

msgid ""

"*ssl_shutdown_timeout* is the time in seconds to wait for the SSL shutdown "

"to complete before aborting the connection. ``30.0`` seconds if ``None`` "

"(default)."

msgstr ""

"*ssl_shutdown_timeout* 是在放弃连接之前要等待 SSL 关闭完成的秒数。 如为 ``None`` (默认值) 则使用 "

"``30.0``。"

#: ../../library/asyncio-eventloop.rst:504

msgid ""

"*all_errors* determines what exceptions are raised when a connection cannot "

"be created. By default, only a single ``Exception`` is raised: the first "

"exception if there is only one or all errors have same message, or a single "

"``OSError`` with the error messages combined. When ``all_errors`` is "

"``True``, an ``ExceptionGroup`` will be raised containing all exceptions "

"(even if there is only one)."

msgstr ""

"*all_errors* 确定当无法创建连接时要引发何种异常。 在默认情况下，只有一个 ``Exception`` "

"会被引发：即只有一个异常或所有错误的消息相同，或者是合并了多个错误消息的单个 ``OSError``。 当 ``all_errors`` 为 "

"``True`` 时，将引发一个包含所有异常的 ``ExceptionGroup`` (即使只有一个异常)。"

#: ../../library/asyncio-eventloop.rst:514

#: ../../library/asyncio-eventloop.rst:763

msgid "Added support for SSL/TLS in :class:`ProactorEventLoop`."

msgstr ":class:`ProactorEventLoop` 类中添加 SSL/TLS 支持。"

#: ../../library/asyncio-eventloop.rst:518

msgid ""

"The socket option :ref:`socket.TCP_NODELAY <socket-unix-constants>` is set "

"by default for all TCP connections."

msgstr ""

"套接字选项 :ref:`socket.TCP_NODELAY <socket-unix-constants>` 默认将为所有 TCP 连接设置。"

#: ../../library/asyncio-eventloop.rst:523

#: ../../library/asyncio-eventloop.rst:857

msgid "Added the *ssl_handshake_timeout* parameter."

msgstr "添加了 *ssl_handshake_timeout* 形参。"

#: ../../library/asyncio-eventloop.rst:527

msgid "Added the *happy_eyeballs_delay* and *interleave* parameters."

msgstr "增加了 *happy_eyeballs_delay* 和 *interleave* 形参。"

#: ../../library/asyncio-eventloop.rst:529

msgid ""

"Happy Eyeballs Algorithm: Success with Dual-Stack Hosts. When a server's "

"IPv4 path and protocol are working, but the server's IPv6 path and protocol "

"are not working, a dual-stack client application experiences significant "

"connection delay compared to an IPv4-only client. This is undesirable "

"because it causes the dual-stack client to have a worse user experience. "

"This document specifies requirements for algorithms that reduce this user-"

"visible delay and provides an algorithm."

msgstr ""

"Happy Eyeballs 算法：成功使用双栈主机。 当服务器的 IPv4 路径和协议工作正常，但服务器的 IPv6 "

"路径和协议工作不正常时，双线客户端应用程序相比仅有 IPv4 的客户端会感受到明显的连接延迟。 这是不可接受的因为它会导致双栈客户端糟糕的用户体验。 "

"这篇文档指明了减少这种用户可见延迟的算法要求并提供了具体的算法。"

#: ../../library/asyncio-eventloop.rst:538

msgid "For more information: https://datatracker.ietf.org/doc/html/rfc6555"

msgstr "详情参见: https://datatracker.ietf.org/doc/html/rfc6555"

#: ../../library/asyncio-eventloop.rst:542

#: ../../library/asyncio-eventloop.rst:668

#: ../../library/asyncio-eventloop.rst:777

#: ../../library/asyncio-eventloop.rst:813

#: ../../library/asyncio-eventloop.rst:861

#: ../../library/asyncio-eventloop.rst:944

msgid "Added the *ssl_shutdown_timeout* parameter."

msgstr "添加了 *ssl_shutdown_timeout* 形参。"

#: ../../library/asyncio-eventloop.rst:544

msgid "*all_errors* was added."

msgstr "添加了 *all_errors*。"

#: ../../library/asyncio-eventloop.rst:549

msgid ""

"The :func:`open_connection` function is a high-level alternative API. It "

"returns a pair of (:class:`StreamReader`, :class:`StreamWriter`) that can be"

" used directly in async/await code."

msgstr ""

":func:`open_connection` 函数是一个高层级的替代 API。 它返回一对 (:class:`StreamReader`, "

":class:`StreamWriter`)，可在 async/await 代码中直接使用。"

#: ../../library/asyncio-eventloop.rst:560

msgid "Create a datagram connection."

msgstr "创建一个数据报连接。"

#: ../../library/asyncio-eventloop.rst:562

msgid ""

"The socket family can be either :py:const:`~socket.AF_INET`, "

":py:const:`~socket.AF_INET6`, or :py:const:`~socket.AF_UNIX`, depending on "

"*host* (or the *family* argument, if provided)."

msgstr ""

"套接字族可以是 :py:const:`~socket.AF_INET`, :py:const:`~socket.AF_INET6` 或 "

":py:const:`~socket.AF_UNIX`，具体取决于 *host* (或 *family* 参数，如果有提供的话)。"

#: ../../library/asyncio-eventloop.rst:566

msgid "The socket type will be :py:const:`~socket.SOCK_DGRAM`."

msgstr "套接字类型将为 :py:const:`~socket.SOCK_DGRAM`。"

#: ../../library/asyncio-eventloop.rst:568

#: ../../library/asyncio-eventloop.rst:694

#: ../../library/asyncio-eventloop.rst:828

msgid ""

"*protocol_factory* must be a callable returning a :ref:`protocol <asyncio-"

"protocol>` implementation."

msgstr "*protocol_factory* 必须为一个返回 :ref:`协议 <asyncio-protocol>` 实现的可调用对象。"

#: ../../library/asyncio-eventloop.rst:571

#: ../../library/asyncio-eventloop.rst:650

msgid "A tuple of ``(transport, protocol)`` is returned on success."

msgstr "成功时返回一个 ``(transport, protocol)`` 元组。"

#: ../../library/asyncio-eventloop.rst:575

msgid ""

"*local_addr*, if given, is a ``(local_host, local_port)`` tuple used to bind"

" the socket locally. The *local_host* and *local_port* are looked up using "

":meth:`getaddrinfo`."

msgstr ""

"如果给出 *local_addr*，它应当是一个用来在本地绑定套接字的 ``(local_host, local_port)`` 元组。 "

"*local_host* 和 *local_port* 是使用 :meth:`getaddrinfo` 来查找的。"

#: ../../library/asyncio-eventloop.rst:579

msgid ""

"*remote_addr*, if given, is a ``(remote_host, remote_port)`` tuple used to "

"connect the socket to a remote address. The *remote_host* and *remote_port*"

" are looked up using :meth:`getaddrinfo`."

msgstr ""

"*remote_addr*，如果指定的话，就是一个 ``(remote_host, remote_port)`` "

"元组，用于同一个远程地址连接。*remote_host* 和 *remote_port* 是使用 :meth:`getaddrinfo` 来查找的。"

#: ../../library/asyncio-eventloop.rst:583

msgid ""

"*family*, *proto*, *flags* are the optional address family, protocol and "

"flags to be passed through to :meth:`getaddrinfo` for *host* resolution. If "

"given, these should all be integers from the corresponding :mod:`socket` "

"module constants."

msgstr ""

"*family*, *proto*, *flags* 是可选的地址族，协议和标志，其会被传递给 :meth:`getaddrinfo` 来完成 "

"*host* 的解析。如果要指定的话，这些都应该是来自于 :mod:`socket` 模块的对应常量。"

#: ../../library/asyncio-eventloop.rst:588

msgid ""

"*reuse_port* tells the kernel to allow this endpoint to be bound to the same"

" port as other existing endpoints are bound to, so long as they all set this"

" flag when being created. This option is not supported on Windows and some "

"Unixes. If the :ref:`socket.SO_REUSEPORT <socket-unix-constants>` constant "

"is not defined then this capability is unsupported."

msgstr ""

"*reuse_port* 告知内核允许此端点绑定到其他现有端点所绑定的相同端口上，只要它们在创建时都设置了这个旗标。 这个选项在 Windows 和某些"

" Unix 上将不受支持。 如果 :ref:`socket.SO_REUSEPORT <socket-unix-constants>` "

"常量未被定义那么该功能就是不受支持的。"

#: ../../library/asyncio-eventloop.rst:594

msgid ""

"*allow_broadcast* tells the kernel to allow this endpoint to send messages "

"to the broadcast address."

msgstr "*allow_broadcast* 告知内核允许此端点向广播地址发送消息。"

#: ../../library/asyncio-eventloop.rst:597

msgid ""

"*sock* can optionally be specified in order to use a preexisting, already "

"connected, :class:`socket.socket` object to be used by the transport. If "

"specified, *local_addr* and *remote_addr* should be omitted (must be "

":const:`None`)."

msgstr ""

"*sock* 可选择通过指定此值用于使用一个预先存在的，已经处于连接状态的 :class:`socket.socket` "

"对象，并将其提供给此传输对象使用。如果指定了这个值， *local_addr* 和 *remote_addr* 就应该被忽略 (必须为 "

":const:`None`)。"

#: ../../library/asyncio-eventloop.rst:608

msgid ""

"See :ref:`UDP echo client protocol <asyncio-udp-echo-client-protocol>` and "

":ref:`UDP echo server protocol <asyncio-udp-echo-server-protocol>` examples."

msgstr ""

"参见 :ref:`UDP echo 客户端协议 <asyncio-udp-echo-client-protocol>` 和 :ref:`UDP "

"echo 服务端协议 <asyncio-udp-echo-server-protocol>` 的例子。"

#: ../../library/asyncio-eventloop.rst:611

msgid ""

"The *family*, *proto*, *flags*, *reuse_address*, *reuse_port*, "

"*allow_broadcast*, and *sock* parameters were added."

msgstr ""

"添加了 *family*, *proto*, *flags*, *reuse_address*, *reuse_port*, "

"*allow_broadcast* 和 *sock* 等形参。"

#: ../../library/asyncio-eventloop.rst:615

msgid "Added support for Windows."

msgstr "添加WIndows的支持。"

#: ../../library/asyncio-eventloop.rst:618

msgid ""

"The *reuse_address* parameter is no longer supported, as using "

":ref:`socket.SO_REUSEADDR <socket-unix-constants>` poses a significant "

"security concern for UDP. Explicitly passing ``reuse_address=True`` will "

"raise an exception."

msgstr ""

"*reuse_address* 形参已不再受支持，因为使用 :ref:`socket.SO_REUSEADDR <socket-unix-"

"constants>` 对于 UDP 会造成显著的安全问题。 显式地传入 ``reuse_address=True`` 将引发异常。"

#: ../../library/asyncio-eventloop.rst:624

msgid ""

"When multiple processes with differing UIDs assign sockets to an identical "

"UDP socket address with ``SO_REUSEADDR``, incoming packets can become "

"randomly distributed among the sockets."

msgstr ""

"当具有不同 UID 的多个进程将套接字赋给具有 ``SO_REUSEADDR`` 的相同 UDP 套接字地址时，传入的数据包可能会在套接字间随机分配。"

#: ../../library/asyncio-eventloop.rst:628

msgid ""

"For supported platforms, *reuse_port* can be used as a replacement for "

"similar functionality. With *reuse_port*, :ref:`socket.SO_REUSEPORT <socket-"

"unix-constants>` is used instead, which specifically prevents processes with"

" differing UIDs from assigning sockets to the same socket address."

msgstr ""

"对于受支持的平台，可以使用 *reuse_port* 作为类似功能的替代。 通过 *reuse_port*，将会改用 "

":ref:`socket.SO_REUSEPORT <socket-unix-constants>`，它能防止具有不同 UID "

"的进程将套接字赋给相同的套接字地址。"