# Copyright (C) 2001 Python Software Foundation

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

#

# Translators:

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-03-22 00:20+0000\n"

"PO-Revision-Date: 2018-05-23 14:39+0000\n"

"Last-Translator: Adrian Liaw <[email protected]>\n"

"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"

"tw)\n"

"Language: zh_TW\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

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

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

#: ../../library/asyncio-task.rst:6

msgid "Coroutines and tasks"

msgstr "協程與任務"

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

msgid ""

"This section outlines high-level asyncio APIs to work with coroutines and "

"Tasks."

msgstr ""

#: ../../library/asyncio-task.rst:19 ../../library/asyncio-task.rst:148

msgid "Coroutines"

msgstr "協程"

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

msgid "**Source code:** :source:`Lib/asyncio/coroutines.py`"

msgstr "**原始碼：**\\ :source:`Lib/asyncio/coroutines.py`"

#: ../../library/asyncio-task.rst:25

msgid ""

":term:`Coroutines <coroutine>` declared with the async/await syntax is the "

"preferred way of writing asyncio applications. For example, the following "

"snippet of code prints \"hello\", waits 1 second, and then prints \"world\"::"

msgstr ""

#: ../../library/asyncio-task.rst:30

msgid ""

">>> import asyncio\n"

"\n"

">>> async def main():\n"

"... print('hello')\n"

"... await asyncio.sleep(1)\n"

"... print('world')\n"

"\n"

">>> asyncio.run(main())\n"

"hello\n"

"world"

msgstr ""

">>> import asyncio\n"

"\n"

">>> async def main():\n"

"... print('hello')\n"

"... await asyncio.sleep(1)\n"

"... print('world')\n"

"\n"

">>> asyncio.run(main())\n"

"hello\n"

"world"

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

msgid ""

"Note that simply calling a coroutine will not schedule it to be executed::"

msgstr ""

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

msgid ""

">>> main()\n"

"<coroutine object main at 0x1053bb7c8>"

msgstr ""

">>> main()\n"

"<coroutine object main at 0x1053bb7c8>"

#: ../../library/asyncio-task.rst:47

msgid "To actually run a coroutine, asyncio provides the following mechanisms:"

msgstr ""

#: ../../library/asyncio-task.rst:49

msgid ""

"The :func:`asyncio.run` function to run the top-level entry point \"main()\" "

"function (see the above example.)"

msgstr ""

#: ../../library/asyncio-task.rst:52

msgid ""

"Awaiting on a coroutine. The following snippet of code will print \"hello\" "

"after waiting for 1 second, and then print \"world\" after waiting for "

"*another* 2 seconds::"

msgstr ""

#: ../../library/asyncio-task.rst:56

msgid ""

"import asyncio\n"

"import time\n"

"\n"

"async def say_after(delay, what):\n"

" await asyncio.sleep(delay)\n"

" print(what)\n"

"\n"

"async def main():\n"

" print(f\"started at {time.strftime('%X')}\")\n"

"\n"

" await say_after(1, 'hello')\n"

" await say_after(2, 'world')\n"

"\n"

" print(f\"finished at {time.strftime('%X')}\")\n"

"\n"

"asyncio.run(main())"

msgstr ""

"import asyncio\n"

"import time\n"

"\n"

"async def say_after(delay, what):\n"

" await asyncio.sleep(delay)\n"

" print(what)\n"

"\n"

"async def main():\n"

" print(f\"started at {time.strftime('%X')}\")\n"

"\n"

" await say_after(1, 'hello')\n"

" await say_after(2, 'world')\n"

"\n"

" print(f\"finished at {time.strftime('%X')}\")\n"

"\n"

"asyncio.run(main())"

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

msgid "Expected output::"

msgstr "預期的輸出： ::"

#: ../../library/asyncio-task.rst:75

msgid ""

"started at 17:13:52\n"

"hello\n"

"world\n"

"finished at 17:13:55"

msgstr ""

"started at 17:13:52\n"

"hello\n"

"world\n"

"finished at 17:13:55"

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

msgid ""

"The :func:`asyncio.create_task` function to run coroutines concurrently as "

"asyncio :class:`Tasks <Task>`."

msgstr ""

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

msgid ""

"Let's modify the above example and run two ``say_after`` coroutines "

"*concurrently*::"

msgstr ""

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

msgid ""

"async def main():\n"

" task1 = asyncio.create_task(\n"

" say_after(1, 'hello'))\n"

"\n"

" task2 = asyncio.create_task(\n"

" say_after(2, 'world'))\n"

"\n"

" print(f\"started at {time.strftime('%X')}\")\n"

"\n"

" # Wait until both tasks are completed (should take\n"

" # around 2 seconds.)\n"

" await task1\n"

" await task2\n"

"\n"

" print(f\"finished at {time.strftime('%X')}\")"

msgstr ""

#: ../../library/asyncio-task.rst:102

msgid ""

"Note that expected output now shows that the snippet runs 1 second faster "

"than before::"

msgstr ""

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

msgid ""

"started at 17:14:32\n"

"hello\n"

"world\n"

"finished at 17:14:34"

msgstr ""

"started at 17:14:32\n"

"hello\n"

"world\n"

"finished at 17:14:34"

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

msgid ""

"The :class:`asyncio.TaskGroup` class provides a more modern alternative to :"

"func:`create_task`. Using this API, the last example becomes::"

msgstr ""

#: ../../library/asyncio-task.rst:114

msgid ""

"async def main():\n"

" async with asyncio.TaskGroup() as tg:\n"

" task1 = tg.create_task(\n"

" say_after(1, 'hello'))\n"

"\n"

" task2 = tg.create_task(\n"

" say_after(2, 'world'))\n"

"\n"

" print(f\"started at {time.strftime('%X')}\")\n"

"\n"

" # The await is implicit when the context manager exits.\n"

"\n"

" print(f\"finished at {time.strftime('%X')}\")"

msgstr ""

#: ../../library/asyncio-task.rst:128

msgid "The timing and output should be the same as for the previous version."

msgstr ""

#: ../../library/asyncio-task.rst:130

msgid ":class:`asyncio.TaskGroup`."

msgstr ":class:`asyncio.TaskGroup`。"

#: ../../library/asyncio-task.rst:137

msgid "Awaitables"

msgstr ""

#: ../../library/asyncio-task.rst:139

msgid ""

"We say that an object is an **awaitable** object if it can be used in an :"

"keyword:`await` expression. Many asyncio APIs are designed to accept "

"awaitables."

msgstr ""

#: ../../library/asyncio-task.rst:143

msgid ""

"There are three main types of *awaitable* objects: **coroutines**, "

"**Tasks**, and **Futures**."

msgstr ""

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

msgid ""

"Python coroutines are *awaitables* and therefore can be awaited from other "

"coroutines::"

msgstr ""

#: ../../library/asyncio-task.rst:152

msgid ""

"import asyncio\n"

"\n"

"async def nested():\n"

" return 42\n"

"\n"

"async def main():\n"

" # Nothing happens if we just call \"nested()\".\n"

" # A coroutine object is created but not awaited,\n"

" # so it *won't run at all*.\n"

" nested() # will raise a \"RuntimeWarning\".\n"

"\n"

" # Let's do it differently now and await it:\n"

" print(await nested()) # will print \"42\".\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-task.rst:170

msgid ""

"In this documentation the term \"coroutine\" can be used for two closely "

"related concepts:"

msgstr ""

#: ../../library/asyncio-task.rst:173

msgid "a *coroutine function*: an :keyword:`async def` function;"

msgstr ""

#: ../../library/asyncio-task.rst:175

msgid ""

"a *coroutine object*: an object returned by calling a *coroutine function*."

msgstr ""

#: ../../library/asyncio-task.rst:180

msgid "Tasks"

msgstr ""

#: ../../library/asyncio-task.rst:181

msgid "*Tasks* are used to schedule coroutines *concurrently*."

msgstr ""

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

msgid ""

"When a coroutine is wrapped into a *Task* with functions like :func:`asyncio."

"create_task` the coroutine is automatically scheduled to run soon::"

msgstr ""

#: ../../library/asyncio-task.rst:187

msgid ""

"import asyncio\n"

"\n"

"async def nested():\n"

" return 42\n"

"\n"

"async def main():\n"

" # Schedule nested() to run soon concurrently\n"

" # with \"main()\".\n"

" task = asyncio.create_task(nested())\n"

"\n"

" # \"task\" can now be used to cancel \"nested()\", or\n"

" # can simply be awaited to wait until it is complete:\n"

" await task\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-task.rst:205

msgid "Futures"

msgstr ""

#: ../../library/asyncio-task.rst:206

msgid ""

"A :class:`Future` is a special **low-level** awaitable object that "

"represents an **eventual result** of an asynchronous operation."

msgstr ""

#: ../../library/asyncio-task.rst:209

msgid ""

"When a Future object is *awaited* it means that the coroutine will wait "

"until the Future is resolved in some other place."

msgstr ""

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

msgid ""

"Future objects in asyncio are needed to allow callback-based code to be used "

"with async/await."

msgstr ""

#: ../../library/asyncio-task.rst:215

msgid ""

"Normally **there is no need** to create Future objects at the application "

"level code."

msgstr ""

#: ../../library/asyncio-task.rst:218

msgid ""

"Future objects, sometimes exposed by libraries and some asyncio APIs, can be "

"awaited::"

msgstr ""

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

msgid ""

"async def main():\n"

" await function_that_returns_a_future_object()\n"

"\n"

" # this is also valid:\n"

" await asyncio.gather(\n"

" function_that_returns_a_future_object(),\n"

" some_python_coroutine()\n"

" )"

msgstr ""

#: ../../library/asyncio-task.rst:230

msgid ""

"A good example of a low-level function that returns a Future object is :meth:"

"`loop.run_in_executor`."

msgstr ""

#: ../../library/asyncio-task.rst:235

msgid "Creating tasks"

msgstr ""

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

msgid "**Source code:** :source:`Lib/asyncio/tasks.py`"

msgstr "**原始碼：**\\ :source:`Lib/asyncio/tasks.py`"

#: ../../library/asyncio-task.rst:243

msgid ""

"Wrap the *coro* :ref:`coroutine <coroutine>` into a :class:`Task` and "

"schedule its execution. Return the Task object."

msgstr ""

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

msgid ""

"The full function signature is largely the same as that of the :class:`Task` "

"constructor (or factory) - all of the keyword arguments to this function are "

"passed through to that interface."

msgstr ""

#: ../../library/asyncio-task.rst:250

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

#: ../../library/asyncio-task.rst:254

msgid ""

"An optional keyword-only *eager_start* argument allows specifying if the "

"task should execute eagerly during the call to create_task, or be scheduled "

"later. If *eager_start* is not passed the mode set by :meth:`loop."

"set_task_factory` will be used."

msgstr ""

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

msgid ""

"The task is executed in the loop returned by :func:`get_running_loop`, :exc:"

"`RuntimeError` is raised if there is no running loop in current thread."

msgstr ""

#: ../../library/asyncio-task.rst:265

msgid ""

":meth:`asyncio.TaskGroup.create_task` is a new alternative leveraging "

"structural concurrency; it allows for waiting for a group of related tasks "

"with strong safety guarantees."

msgstr ""

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

msgid ""

"Save a reference to the result of this function, to avoid a task "

"disappearing mid-execution. The event loop only keeps weak references to "

"tasks. A task that isn't referenced elsewhere may get garbage collected at "

"any time, even before it's done. For reliable \"fire-and-forget\" background "

"tasks, gather them in a collection::"

msgstr ""

#: ../../library/asyncio-task.rst:278

msgid ""

"background_tasks = set()\n"

"\n"

"for i in range(10):\n"

" task = asyncio.create_task(some_coro(param=i))\n"

"\n"

" # Add task to the set. This creates a strong reference.\n"

" background_tasks.add(task)\n"

"\n"

" # To prevent keeping references to finished tasks forever,\n"

" # make each task remove its own reference from the set after\n"

" # completion:\n"

" task.add_done_callback(background_tasks.discard)"

msgstr ""

#: ../../library/asyncio-task.rst:293 ../../library/asyncio-task.rst:1254

msgid "Added the *name* parameter."

msgstr "新增 *name* 參數。"

#: ../../library/asyncio-task.rst:296 ../../library/asyncio-task.rst:1261

msgid "Added the *context* parameter."

msgstr "新增 *context* 參數。"

#: ../../library/asyncio-task.rst:299

msgid "Added the *eager_start* parameter by passing on all *kwargs*."

msgstr ""

#: ../../library/asyncio-task.rst:304

msgid "Task cancellation"

msgstr ""

#: ../../library/asyncio-task.rst:306

msgid ""

"Tasks can easily and safely be cancelled. When a task is cancelled, :exc:"

"`asyncio.CancelledError` will be raised in the task at the next opportunity."

msgstr ""

#: ../../library/asyncio-task.rst:310

msgid ""

"It is recommended that coroutines use ``try/finally`` blocks to robustly "

"perform clean-up logic. In case :exc:`asyncio.CancelledError` is explicitly "

"caught, it should generally be propagated when clean-up is complete. :exc:"

"`asyncio.CancelledError` directly subclasses :exc:`BaseException` so most "

"code will not need to be aware of it."

msgstr ""

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

msgid ""

"The asyncio components that enable structured concurrency, like :class:"

"`asyncio.TaskGroup` and :func:`asyncio.timeout`, are implemented using "

"cancellation internally and might misbehave if a coroutine swallows :exc:"

"`asyncio.CancelledError`. Similarly, user code should not generally call :"

"meth:`uncancel <asyncio.Task.uncancel>`. However, in cases when suppressing :"

"exc:`asyncio.CancelledError` is truly desired, it is necessary to also call "

"``uncancel()`` to completely remove the cancellation state."

msgstr ""

#: ../../library/asyncio-task.rst:328

msgid "Task groups"

msgstr ""

#: ../../library/asyncio-task.rst:330

msgid ""

"Task groups combine a task creation API with a convenient and reliable way "

"to wait for all tasks in the group to finish."

msgstr ""

#: ../../library/asyncio-task.rst:335

msgid ""

"An :ref:`asynchronous context manager <async-context-managers>` holding a "

"group of tasks. Tasks can be added to the group using :meth:`create_task`. "

"All tasks are awaited when the context manager exits."

msgstr ""

#: ../../library/asyncio-task.rst:344

msgid ""

"Create a task in this task group. The signature matches that of :func:"

"`asyncio.create_task`. If the task group is inactive (e.g. not yet entered, "

"already finished, or in the process of shutting down), we will close the "

"given ``coro``."

msgstr ""

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

msgid "Close the given coroutine if the task group is not active."

msgstr ""

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

msgid "Passes on all *kwargs* to :meth:`loop.create_task`"

msgstr ""

#: ../../library/asyncio-task.rst:358 ../../library/asyncio-task.rst:564

#: ../../library/asyncio-task.rst:737 ../../library/asyncio-task.rst:798

#: ../../library/asyncio-task.rst:824 ../../library/asyncio-task.rst:865

msgid "Example::"

msgstr "範例： ::"

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

msgid ""

"async def main():\n"

" async with asyncio.TaskGroup() as tg:\n"

" task1 = tg.create_task(some_coro(...))\n"

" task2 = tg.create_task(another_coro(...))\n"

" print(f\"Both tasks have completed now: {task1.result()}, {task2."

"result()}\")"

msgstr ""

"async def main():\n"

" async with asyncio.TaskGroup() as tg:\n"

" task1 = tg.create_task(some_coro(...))\n"

" task2 = tg.create_task(another_coro(...))\n"

" print(f\"Both tasks have completed now: {task1.result()}, {task2."

"result()}\")"

#: ../../library/asyncio-task.rst:366

msgid ""

"The ``async with`` statement will wait for all tasks in the group to finish. "

"While waiting, new tasks may still be added to the group (for example, by "

"passing ``tg`` into one of the coroutines and calling ``tg.create_task()`` "

"in that coroutine). Once the last task has finished and the ``async with`` "

"block is exited, no new tasks may be added to the group."

msgstr ""

#: ../../library/asyncio-task.rst:373

msgid ""

"The first time any of the tasks belonging to the group fails with an "

"exception other than :exc:`asyncio.CancelledError`, the remaining tasks in "

"the group are cancelled. No further tasks can then be added to the group. At "

"this point, if the body of the ``async with`` statement is still active (i."

"e., :meth:`~object.__aexit__` hasn't been called yet), the task directly "

"containing the ``async with`` statement is also cancelled. The resulting :"

"exc:`asyncio.CancelledError` will interrupt an ``await``, but it will not "

"bubble out of the containing ``async with`` statement."

msgstr ""

#: ../../library/asyncio-task.rst:383

msgid ""

"Once all tasks have finished, if any tasks have failed with an exception "

"other than :exc:`asyncio.CancelledError`, those exceptions are combined in "

"an :exc:`ExceptionGroup` or :exc:`BaseExceptionGroup` (as appropriate; see "

"their documentation) which is then raised."

msgstr ""

#: ../../library/asyncio-task.rst:390

msgid ""

"Two base exceptions are treated specially: If any task fails with :exc:"

"`KeyboardInterrupt` or :exc:`SystemExit`, the task group still cancels the "

"remaining tasks and waits for them, but then the initial :exc:"

"`KeyboardInterrupt` or :exc:`SystemExit` is re-raised instead of :exc:"

"`ExceptionGroup` or :exc:`BaseExceptionGroup`."

msgstr ""

#: ../../library/asyncio-task.rst:396

msgid ""

"If the body of the ``async with`` statement exits with an exception (so :"

"meth:`~object.__aexit__` is called with an exception set), this is treated "

"the same as if one of the tasks failed: the remaining tasks are cancelled "

"and then waited for, and non-cancellation exceptions are grouped into an "

"exception group and raised. The exception passed into :meth:`~object."

"__aexit__`, unless it is :exc:`asyncio.CancelledError`, is also included in "

"the exception group. The same special case is made for :exc:"

"`KeyboardInterrupt` and :exc:`SystemExit` as in the previous paragraph."

msgstr ""

#: ../../library/asyncio-task.rst:408

msgid ""

"Task groups are careful not to mix up the internal cancellation used to "

"\"wake up\" their :meth:`~object.__aexit__` with cancellation requests for "

"the task in which they are running made by other parties. In particular, "

"when one task group is syntactically nested in another, and both experience "

"an exception in one of their child tasks simultaneously, the inner task "

"group will process its exceptions, and then the outer task group will "

"receive another cancellation and process its own exceptions."

msgstr ""

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

msgid ""

"In the case where a task group is cancelled externally and also must raise "

"an :exc:`ExceptionGroup`, it will call the parent task's :meth:`~asyncio."

"Task.cancel` method. This ensures that a :exc:`asyncio.CancelledError` will "

"be raised at the next :keyword:`await`, so the cancellation is not lost."

msgstr ""

#: ../../library/asyncio-task.rst:422

msgid ""

"Task groups preserve the cancellation count reported by :meth:`asyncio.Task."

"cancelling`."

msgstr ""

#: ../../library/asyncio-task.rst:427

msgid ""

"Improved handling of simultaneous internal and external cancellations and "

"correct preservation of cancellation counts."

msgstr ""

#: ../../library/asyncio-task.rst:431

msgid "Terminating a task group"

msgstr ""

#: ../../library/asyncio-task.rst:433

msgid ""

"While terminating a task group is not natively supported by the standard "

"library, termination can be achieved by adding an exception-raising task to "

"the task group and ignoring the raised exception:"

msgstr ""

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

msgid ""

"import asyncio\n"

"from asyncio import TaskGroup\n"

"\n"

"class TerminateTaskGroup(Exception):\n"

" \"\"\"Exception raised to terminate a task group.\"\"\"\n"

"\n"

"async def force_terminate_task_group():\n"

" \"\"\"Used to force termination of a task group.\"\"\"\n"

" raise TerminateTaskGroup()\n"

"\n"

"async def job(task_id, sleep_time):\n"

" print(f'Task {task_id}: start')\n"

" await asyncio.sleep(sleep_time)\n"

" print(f'Task {task_id}: done')\n"

"\n"

"async def main():\n"

" try:\n"

" async with TaskGroup() as group:\n"

" # spawn some tasks\n"

" group.create_task(job(1, 0.5))\n"

" group.create_task(job(2, 1.5))\n"

" # sleep for 1 second\n"

" await asyncio.sleep(1)\n"

" # add an exception-raising task to force the group to terminate\n"

" group.create_task(force_terminate_task_group())\n"

" except* TerminateTaskGroup:\n"

" pass\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-task.rst:469

msgid "Expected output:"

msgstr "預期的輸出： ::"

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

msgid ""

"Task 1: start\n"

"Task 2: start\n"

"Task 1: done"

msgstr ""

"Task 1: start\n"

"Task 2: start\n"

"Task 1: done"

#: ../../library/asyncio-task.rst:478

msgid "Sleeping"

msgstr ""

#: ../../library/asyncio-task.rst:483

msgid "Block for *delay* seconds."

msgstr ""

#: ../../library/asyncio-task.rst:485

msgid ""

"If *result* is provided, it is returned to the caller when the coroutine "

"completes."

msgstr ""

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

msgid ""

"``sleep()`` always suspends the current task, allowing other tasks to run."

msgstr ""

#: ../../library/asyncio-task.rst:491

msgid ""

"Setting the delay to 0 provides an optimized path to allow other tasks to "

"run. This can be used by long-running functions to avoid blocking the event "

"loop for the full duration of the function call."

msgstr ""

#: ../../library/asyncio-task.rst:497

msgid ""

"Example of coroutine displaying the current date every second for 5 seconds::"

msgstr ""

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

msgid ""

"import asyncio\n"

"import datetime as dt\n"

"\n"

"async def display_date():\n"

" loop = asyncio.get_running_loop()\n"

" end_time = loop.time() + 5.0\n"

" while True:\n"

" print(dt.datetime.now())\n"

" if (loop.time() + 1.0) >= end_time:\n"

" break\n"

" await asyncio.sleep(1)\n"

"\n"

"asyncio.run(display_date())"

msgstr ""

"import asyncio\n"

"import datetime as dt\n"

"\n"

"async def display_date():\n"

" loop = asyncio.get_running_loop()\n"

" end_time = loop.time() + 5.0\n"

" while True:\n"

" print(dt.datetime.now())\n"

" if (loop.time() + 1.0) >= end_time:\n"

" break\n"

" await asyncio.sleep(1)\n"

"\n"

"asyncio.run(display_date())"

#: ../../library/asyncio-task.rst:515 ../../library/asyncio-task.rst:613

#: ../../library/asyncio-task.rst:712 ../../library/asyncio-task.rst:890

#: ../../library/asyncio-task.rst:945 ../../library/asyncio-task.rst:1002

msgid "Removed the *loop* parameter."

msgstr "移除 *loop* 參數。"

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

msgid "Raises :exc:`ValueError` if *delay* is :data:`~math.nan`."

msgstr "如果 *delay* 是 :data:`~math.nan`，則引發 :exc:`ValueError`。"

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

msgid "Running tasks concurrently"

msgstr ""

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

msgid ""

"Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws* sequence "

"*concurrently*."

msgstr ""

#: ../../library/asyncio-task.rst:530

msgid ""

"If any awaitable in *aws* is a coroutine, it is automatically scheduled as a "

"Task."

msgstr ""

#: ../../library/asyncio-task.rst:533

msgid ""

"If all awaitables are completed successfully, the result is an aggregate "

"list of returned values. The order of result values corresponds to the "

"order of awaitables in *aws*."

msgstr ""

#: ../../library/asyncio-task.rst:537

msgid ""

"If *return_exceptions* is ``False`` (default), the first raised exception is "

"immediately propagated to the task that awaits on ``gather()``. Other "

"awaitables in the *aws* sequence **won't be cancelled** and will continue to "

"run."

msgstr ""

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

msgid ""

"If *return_exceptions* is ``True``, exceptions are treated the same as "

"successful results, and aggregated in the result list."

msgstr ""

#: ../../library/asyncio-task.rst:545

msgid ""

"If ``gather()`` is *cancelled*, all submitted awaitables (that have not "

"completed yet) are also *cancelled*."

msgstr ""

#: ../../library/asyncio-task.rst:548

msgid ""

"If any Task or Future from the *aws* sequence is *cancelled*, it is treated "

"as if it raised :exc:`CancelledError` -- the ``gather()`` call is **not** "

"cancelled in this case. This is to prevent the cancellation of one "

"submitted Task/Future to cause other Tasks/Futures to be cancelled."

msgstr ""

#: ../../library/asyncio-task.rst:555

msgid ""

"A new alternative to create and run tasks concurrently and wait for their "

"completion is :class:`asyncio.TaskGroup`. *TaskGroup* provides stronger "

"safety guarantees than *gather* for scheduling a nesting of subtasks: if a "

"task (or a subtask, a task scheduled by a task) raises an exception, "

"*TaskGroup* will, while *gather* will not, cancel the remaining scheduled "

"tasks."

msgstr ""

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

msgid ""

"import asyncio\n"

"\n"

"async def factorial(name, number):\n"

" f = 1\n"

" for i in range(2, number + 1):\n"

" print(f\"Task {name}: Compute factorial({number}), currently i={i}..."

"\")\n"

" await asyncio.sleep(1)\n"

" f *= i\n"

" print(f\"Task {name}: factorial({number}) = {f}\")\n"

" return f\n"

"\n"

"async def main():\n"

" # Schedule three calls *concurrently*:\n"

" L = await asyncio.gather(\n"

" factorial(\"A\", 2),\n"

" factorial(\"B\", 3),\n"

" factorial(\"C\", 4),\n"

" )\n"

" print(L)\n"

"\n"

"asyncio.run(main())\n"

"\n"

"# Expected output:\n"

"#\n"

"# Task A: Compute factorial(2), currently i=2...\n"

"# Task B: Compute factorial(3), currently i=2...\n"

"# Task C: Compute factorial(4), currently i=2...\n"

"# Task A: factorial(2) = 2\n"

"# Task B: Compute factorial(3), currently i=3...\n"

"# Task C: Compute factorial(4), currently i=3...\n"

"# Task B: factorial(3) = 6\n"

"# Task C: Compute factorial(4), currently i=4...\n"

"# Task C: factorial(4) = 24\n"

"# [2, 6, 24]"

msgstr ""

#: ../../library/asyncio-task.rst:602

msgid ""

"If *return_exceptions* is false, cancelling gather() after it has been "

"marked done won't cancel any submitted awaitables. For instance, gather can "

"be marked done after propagating an exception to the caller, therefore, "

"calling ``gather.cancel()`` after catching an exception (raised by one of "

"the awaitables) from gather won't cancel any other awaitables."

msgstr ""

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

msgid ""

"If the *gather* itself is cancelled, the cancellation is propagated "

"regardless of *return_exceptions*."

msgstr ""

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

msgid ""

"Deprecation warning is emitted if no positional arguments are provided or "

"not all positional arguments are Future-like objects and there is no running "

"event loop."

msgstr ""

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

msgid "Eager task factory"

msgstr ""

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

msgid "A task factory for eager task execution."

msgstr ""

#: ../../library/asyncio-task.rst:631

msgid ""

"When using this factory (via :meth:`loop.set_task_factory(asyncio."

"eager_task_factory) <loop.set_task_factory>`), coroutines begin execution "

"synchronously during :class:`Task` construction. Tasks are only scheduled on "

"the event loop if they block. This can be a performance improvement as the "

"overhead of loop scheduling is avoided for coroutines that complete "

"synchronously."

msgstr ""

#: ../../library/asyncio-task.rst:637

msgid ""

"A common example where this is beneficial is coroutines which employ caching "

"or memoization to avoid actual I/O when possible."

msgstr ""

#: ../../library/asyncio-task.rst:642

msgid ""

"Immediate execution of the coroutine is a semantic change. If the coroutine "

"returns or raises, the task is never scheduled to the event loop. If the "

"coroutine execution blocks, the task is scheduled to the event loop. This "

"change may introduce behavior changes to existing applications. For example, "

"the application's task execution order is likely to change."

msgstr ""

#: ../../library/asyncio-task.rst:653

msgid ""

"Create an eager task factory, similar to :func:`eager_task_factory`, using "

"the provided *custom_task_constructor* when creating a new task instead of "

"the default :class:`Task`."

msgstr ""

#: ../../library/asyncio-task.rst:657

msgid ""

"*custom_task_constructor* must be a *callable* with the signature matching "

"the signature of :class:`Task.__init__ <Task>`. The callable must return a :"

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

msgstr ""

#: ../../library/asyncio-task.rst:661

msgid ""

"This function returns a *callable* intended to be used as a task factory of "

"an event loop via :meth:`loop.set_task_factory(factory) <loop."

"set_task_factory>`)."

msgstr ""

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

msgid "Shielding from cancellation"

msgstr ""

#: ../../library/asyncio-task.rst:672

msgid ""

"Protect an :ref:`awaitable object <asyncio-awaitables>` from being :meth:"

"`cancelled <Task.cancel>`."

msgstr ""

#: ../../library/asyncio-task.rst:675 ../../library/asyncio-task.rst:845

msgid "If *aw* is a coroutine it is automatically scheduled as a Task."

msgstr ""

#: ../../library/asyncio-task.rst:677

msgid "The statement::"

msgstr ""

#: ../../library/asyncio-task.rst:679

msgid ""

"task = asyncio.create_task(something())\n"

"res = await shield(task)"

msgstr ""

"task = asyncio.create_task(something())\n"

"res = await shield(task)"

#: ../../library/asyncio-task.rst:682

msgid "is equivalent to::"

msgstr ""

#: ../../library/asyncio-task.rst:684

msgid "res = await something()"

msgstr "res = await something()"

#: ../../library/asyncio-task.rst:686

msgid ""

"*except* that if the coroutine containing it is cancelled, the Task running "

"in ``something()`` is not cancelled. From the point of view of "

"``something()``, the cancellation did not happen. Although its caller is "

"still cancelled, so the \"await\" expression still raises a :exc:"

"`CancelledError`."

msgstr ""

#: ../../library/asyncio-task.rst:692

msgid ""

"If ``something()`` is cancelled by other means (i.e. from within itself) "

"that would also cancel ``shield()``."

msgstr ""

#: ../../library/asyncio-task.rst:695

msgid ""

"If it is desired to completely ignore cancellation (not recommended) the "

"``shield()`` function should be combined with a try/except clause, as "

"follows::"

msgstr ""

#: ../../library/asyncio-task.rst:699

msgid ""

"task = asyncio.create_task(something())\n"

"try:\n"

" res = await shield(task)\n"

"except CancelledError:\n"

" res = None"

msgstr ""

"task = asyncio.create_task(something())\n"

"try:\n"

" res = await shield(task)\n"

"except CancelledError:\n"

" res = None"

#: ../../library/asyncio-task.rst:707