# 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:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-01-03 16:35+0000\n"

"PO-Revision-Date: 2025-09-22 17:54+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:6

msgid "Event Loop"

msgstr "事件循环"

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

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:14

msgid "Preface"

msgstr "前言"

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

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:19

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:26

msgid "Obtaining the Event Loop"

msgstr "获取事件循环"

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

msgid ""

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

"event loop:"

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

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

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

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

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

msgid ""

"If there is no running event loop a :exc:`RuntimeError` is raised. This "

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

msgstr "如果没有正在运行的事件循环则会引发 :exc:`RuntimeError`。 此函数只能由协程或回调来调用。"

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

msgid "Get the current event loop."

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

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

msgid ""

"If there is no current event loop set in the current OS thread, the OS "

"thread is main, and :func:`set_event_loop` has not yet been called, asyncio "

"will create a new event loop and set it as the current one."

msgstr ""

"如果当前 OS 线程没有设置当前事件循环，该 OS 线程为主线程，并且 :func:`set_event_loop` 还没有被调用，则 asyncio "

"将创建一个新的事件循环并将其设为当前事件循环。"

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

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:53

msgid ""

"Consider also using the :func:`asyncio.run` function instead of using lower "

"level functions to manually create and close an event loop."

msgstr "应该考虑使用 :func:`asyncio.run` 函数而非使用低层级函数来手动创建和关闭事件循环。"

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

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

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

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

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

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

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

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:70

msgid "Contents"

msgstr "目录"

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

msgid "This documentation page contains the following sections:"

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

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

msgid ""

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

"event loop APIs;"

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

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

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:80

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:83

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:86

msgid ""

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

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

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

msgid "Event Loop Methods"

msgstr "事件循环方法集"

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

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

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

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

msgid "Running and stopping the loop"

msgstr "运行和停止循环"

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

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

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

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

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:113

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

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

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

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

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

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

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:124

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:132

msgid "Stop the event loop."

msgstr "停止事件循环。"

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

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

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

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

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

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

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

msgid "Close the event loop."

msgstr "关闭事件循环。"

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

msgid ""

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

"callbacks will be discarded."

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

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

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:152

msgid ""

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

"called after the event loop is closed."

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

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

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:163

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

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:166

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

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

msgid "Example::"

msgstr "示例::"

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

msgid ""

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

"the threads in the :class:`ThreadPoolExecutor`. After calling this method, a"

" :exc:`RuntimeError` will be raised if :meth:`loop.run_in_executor` is "

"called while using the default executor."

msgstr ""

"安排默认执行器的关闭并等待它合并 :class:`ThreadPoolExecutor` 中的所有线程。 在调用此方法后，如果在使用默认执行器期间调用了"

" :meth:`loop.run_in_executor` 则将会引发 :exc:`RuntimeError`。"

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

msgid "Scheduling callbacks"

msgstr "安排回调"

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

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:197

msgid ""

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

"callback will be called exactly once."

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

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

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

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:204

msgid ""

"An instance of :class:`asyncio.Handle` is returned, which can be used later "

"to cancel the callback."

msgstr "返回一个能用来取消回调的 :class:`asyncio.Handle` 实例。"

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

msgid "This method is not thread-safe."

msgstr "这个方法不是线程安全的。"

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

msgid ""

"A thread-safe variant of :meth:`call_soon`. Must be used to schedule "

"callbacks *from another thread*."

msgstr ":meth:`call_soon` 的线程安全变体。必须被用于安排 *来自其他线程* 的回调。"

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

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:218

msgid ""

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

"section of the documentation."

msgstr ""

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

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

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

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

msgid ""

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

"details."

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

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

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:236

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:244

msgid "Scheduling delayed callbacks"

msgstr "调度延迟回调"

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

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:253

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:256

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

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:259

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:263

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:275

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:282

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:286

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

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

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

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:302

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:306

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:312

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

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

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

msgid "Creating Futures and Tasks"

msgstr "创建 Future 和 Task"

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

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

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

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

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:330

msgid ""

"Schedule the execution of a :ref:`coroutine`. Return a :class:`Task` object."

msgstr "安排一个 :ref:`coroutine` 的执行。返回一个 :class:`Task` 对象。"

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

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:337

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:340

msgid "Added the ``name`` parameter."

msgstr "添加了 ``name`` 形参。"

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

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

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

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

msgid ""

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

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

" 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)``，其中 *loop* 是对活动事件循环的引用，而 *coro* 是一个协程对象。 该可调用对象必须返回一个兼容 "

":class:`asyncio.Future` 的对象。"

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

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

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

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

msgid "Opening network connections"

msgstr "打开网络连接"

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

msgid ""

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

" and *port*."

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

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

msgid ""

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

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

"if provided)."

msgstr ""

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

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

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

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

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

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

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

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

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:381

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:384

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

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

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

msgid ""

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

"created for it."

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

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

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:392

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:395

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

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

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

msgid ""

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

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

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

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

msgid "Other arguments:"

msgstr "其他参数："

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

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:408

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

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

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

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:418

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:423

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:431

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:440

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:446

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:450

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

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:456

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

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

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

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:467

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

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

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

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

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

msgid "The *ssl_handshake_timeout* parameter."

msgstr "*ssl_handshake_timeout* 形参。"

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

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

msgid ""

"The socket option :py:data:`~socket.TCP_NODELAY` is set by default for all "

"TCP connections."

msgstr "套接字选项 :py:data:`~socket.TCP_NODELAY` 默认已为所有 TCP 连接进行了设置。"

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

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

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

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

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

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:495

msgid ""

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

":py:data:`~sockets.SO_REUSEADDR` poses a significant security concern for "

"UDP. Explicitly passing ``reuse_address=True`` will raise an exception."

msgstr ""

"形参 *reuse_address* 已不再受支持，因为使用 :py:data:`~sockets.SO_REUSEADDR` 会对 UDP "

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

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

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:503

msgid ""

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

"similar functionality. With *reuse_port*, :py:data:`~sockets.SO_REUSEPORT` "

"is used instead, which specifically prevents processes with differing UIDs "

"from assigning sockets to the same socket address."

msgstr ""

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

":py:data:`~sockets.SO_REUSEPORT`，它能够防止具有不同 UID 的进程将套接字赋给相同的套接字地址。"

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

msgid "Create a datagram connection."

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

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

msgid ""

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

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

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

msgstr ""

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

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

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

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

msgstr "socket类型将是 :py:data:`~socket.SOCK_DGRAM` 。"

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

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

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

msgid ""

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

"protocol>` implementation."

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

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

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

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

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

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

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:528

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:532

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:537

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 :py:data:`~socket.SO_REUSEPORT` constant is not defined then "

"this capability is unsupported."

msgstr ""

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

" Unix 上不受支持。 如果 :py:data:`~socket.SO_REUSEPORT` 常量未定义则此功能就是不受支持的。"

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

msgid ""

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

"to the broadcast address."

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

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

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:551

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:554

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:558

msgid ""

"The *reuse_address* parameter is no longer supported due to security "

"concerns."

msgstr "出于安全考虑，*reuse_address* 形参已不再受支持。"

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

msgid "Added support for Windows."

msgstr "添加WIndows的支持。"

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

msgid "Create a Unix connection."

msgstr "创建Unix 连接"

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

msgid ""

"The socket family will be :py:data:`~socket.AF_UNIX`; socket type will be "

":py:data:`~socket.SOCK_STREAM`."

msgstr ""

"套接字族将为 :py:data:`~socket.AF_UNIX`；套接字类型将为 :py:data:`~socket.SOCK_STREAM`。"

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

msgid ""

"*path* is the name of a Unix domain socket and is required, unless a *sock* "

"parameter is specified. Abstract Unix sockets, :class:`str`, "

":class:`bytes`, and :class:`~pathlib.Path` paths are supported."

msgstr ""

"*path* 是所要求的 Unix 域套接字的名字，除非指定了 *sock* 形参。 抽象的 Unix 套接字, :class:`str`, "

":class:`bytes` 和 :class:`~pathlib.Path` 路径都是受支持的。"

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

msgid ""

"See the documentation of the :meth:`loop.create_connection` method for "

"information about arguments to this method."

msgstr "请查看 :meth:`loop.create_connection` 方法的文档了解有关此方法的参数的信息。"

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

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

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

msgid ":ref:`Availability <availability>`: Unix."

msgstr ":ref:`可用性 <availability>`: Unix。"

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

msgid "The *path* parameter can now be a :term:`path-like object`."

msgstr "*path* 形参现在可以是 :term:`path-like object` 对象。"

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

msgid "Creating network servers"

msgstr "创建网络服务"

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

msgid ""

"Create a TCP server (socket type :data:`~socket.SOCK_STREAM`) listening on "

"*port* of the *host* address."

msgstr ""

"创建TCP服务 (socket 类型 :data:`~socket.SOCK_STREAM` ) 监听 *host* 地址的 *port* 端口。"

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

msgid "Returns a :class:`Server` object."

msgstr "返回一个 :class:`Server` 对象。"

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

msgid "Arguments:"

msgstr "参数："

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

msgid ""

"The *host* parameter can be set to several types which determine where the "

"server would be listening:"

msgstr "*host* 形参可被设为几种类型，它确定了服务器所应监听的位置:"

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

msgid ""

"If *host* is a string, the TCP server is bound to a single network interface"

" specified by *host*."

msgstr "如果 *host* 是一个字符串，则 TCP 服务器会被绑定到 *host* 所指明的单一网络接口。"

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

msgid ""

"If *host* is a sequence of strings, the TCP server is bound to all network "

"interfaces specified by the sequence."

msgstr "如果 *host* 是一个字符串序列，则 TCP 服务器会被绑定到序列所指明的所有网络接口。"

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

msgid ""

"If *host* is an empty string or ``None``, all interfaces are assumed and a "

"list of multiple sockets will be returned (most likely one for IPv4 and "

"another one for IPv6)."

msgstr ""

"如果 *host* 是一个空字符串或 ``None``，则会应用所有接口并将返回包含多个套接字的列表（通常是一个 IPv4 的加一个 IPv6 的）。"

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

msgid ""

"The *port* parameter can be set to specify which port the server should "

"listen on. If ``0`` or ``None`` (the default), a random unused port will be "

"selected (note that if *host* resolves to multiple network interfaces, a "

"different random port will be selected for each interface)."

msgstr ""

"可以设置 *port* 参数来指定服务器应该监听哪个端口。如果为 ``0`` 或者 ``None`` （默认），将选择一个随机的未使用的端口（注意，如果"

" *host* 解析到多个网络接口，将为每个接口选择一个不同的随机端口）。"

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

msgid ""

"*family* can be set to either :data:`socket.AF_INET` or "

":data:`~socket.AF_INET6` to force the socket to use IPv4 or IPv6. If not "

"set, the *family* will be determined from host name (defaults to "

":data:`~socket.AF_UNSPEC`)."

msgstr ""

"*family* 可被设为 :data:`socket.AF_INET` 或 :data:`~socket.AF_INET6` 以强制此套接字使用 "

"IPv4 或 IPv6。 如果未设定，则 *family* 将通过主机名称来确定 (默认为 :data:`~socket.AF_UNSPEC`)。"

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

msgid "*flags* is a bitmask for :meth:`getaddrinfo`."

msgstr "*flags* 是用于 :meth:`getaddrinfo` 的位掩码。"

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

msgid ""

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

"object. If specified, *host* and *port* must not be specified."

msgstr "可以选择指定 *sock* 以便使用预先存在的套接字对象。 如果指定了此参数，则不可再指定 *host* 和 *port*。"

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

msgid ""

"*backlog* is the maximum number of queued connections passed to "

":meth:`~socket.socket.listen` (defaults to 100)."

msgstr "*backlog* 是传递给 :meth:`~socket.socket.listen` 的最大排队连接的数量（默认为100）。"

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

msgid ""

"*ssl* can be set to an :class:`~ssl.SSLContext` instance to enable TLS over "

"the accepted connections."

msgstr "*ssl* 可被设置为一个 :class:`~ssl.SSLContext` 实例以在所接受的连接上启用 TLS。"

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

msgid ""

"*reuse_address* tells the kernel to reuse a local socket in ``TIME_WAIT`` "

"state, without waiting for its natural timeout to expire. If not specified "

"will automatically be set to ``True`` on Unix."

msgstr ""

"*reuse_address* 告知内核要重用一个处于 ``TIME_WAIT`` 状态的本地套接字，而不是等待其自然超时失效。 如果未指定此参数则在 "

"Unix 上将自动设置为 ``True``。"

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

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."

msgstr ""

"*reuse_port* 告知内核，只要在创建的时候都设置了这个标志，就允许此端点绑定到其它端点列表所绑定的同样的端口上。这个选项在 Windows "

"上是不支持的。"