# 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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-07-25 16:03+0000\n"

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

"Last-Translator: Rafael Fontenelle <[email protected]>, 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/contextlib.rst:2

msgid ""

":mod:`!contextlib` --- Utilities for :keyword:`!with`\\ -statement contexts"

msgstr ":mod:`!contextlib` --- 为 :keyword:`!with`\\ 语句上下文提供的工具"

#: ../../library/contextlib.rst:7

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

msgstr "**源代码** :source:`Lib/contextlib.py`"

#: ../../library/contextlib.rst:11

msgid ""

"This module provides utilities for common tasks involving the "

":keyword:`with` statement. For more information see also "

":ref:`typecontextmanager` and :ref:`context-managers`."

msgstr ""

"此模块为涉及 :keyword:`with` 语句的常见任务提供了实用的工具。更多信息请参见 :ref:`typecontextmanager` 和 "

":ref:`context-managers`。"

#: ../../library/contextlib.rst:17

msgid "Utilities"

msgstr "工具"

#: ../../library/contextlib.rst:19

msgid "Functions and classes provided:"

msgstr "提供的函数和类："

#: ../../library/contextlib.rst:23

msgid ""

"An :term:`abstract base class` for classes that implement "

":meth:`object.__enter__` and :meth:`object.__exit__`. A default "

"implementation for :meth:`object.__enter__` is provided which returns "

"``self`` while :meth:`object.__exit__` is an abstract method which by "

"default returns ``None``. See also the definition of "

":ref:`typecontextmanager`."

msgstr ""

"一个为实现了 :meth:`object.__enter__` 与 :meth:`object.__exit__` 的类提供的 "

":term:`abstract base class`。为 :meth:`object.__enter__` 提供的一个默认实现是返回 ``self``"

" 而 :meth:`object.__exit__` 是一个默认返回 ``None`` 的抽象方法。 参见 "

":ref:`typecontextmanager` 的定义。"

#: ../../library/contextlib.rst:34

msgid ""

"An :term:`abstract base class` for classes that implement "

":meth:`object.__aenter__` and :meth:`object.__aexit__`. A default "

"implementation for :meth:`object.__aenter__` is provided which returns "

"``self`` while :meth:`object.__aexit__` is an abstract method which by "

"default returns ``None``. See also the definition of :ref:`async-context-"

"managers`."

msgstr ""

"一个为实现了 :meth:`object.__aenter__` 与 :meth:`object.__aexit__` 的类提供的 "

":term:`abstract base class`。 为 :meth:`object.__aenter__` 提供的一个默认实现是返回 "

"``self`` 而 :meth:`object.__aexit__` 是一个默认返回 ``None`` 的抽象方法。 参见 :ref:`async-"

"context-managers` 的定义。"

#: ../../library/contextlib.rst:46

msgid ""

"This function is a :term:`decorator` that can be used to define a factory "

"function for :keyword:`with` statement context managers, without needing to "

"create a class or separate :meth:`~object.__enter__` and "

":meth:`~object.__exit__` methods."

msgstr ""

"此函数是一个 :term:`decorator`，它可被用来定义一个支持 :keyword:`with` "

"语句上下文管理器的工厂函数，而无需创建一个类或单独的 :meth:`~object.__enter__` 和 "

":meth:`~object.__exit__` 方法。"

#: ../../library/contextlib.rst:50

msgid ""

"While many objects natively support use in with statements, sometimes a "

"resource needs to be managed that isn't a context manager in its own right, "

"and doesn't implement a ``close()`` method for use with "

"``contextlib.closing``"

msgstr ""

"尽管许多对象原生支持使用 with 语句，但有些需要被管理的资源并不是上下文管理器，并且没有实现 ``close()`` 方法而不能使用 "

"``contextlib.closing`` 。"

#: ../../library/contextlib.rst:54

msgid ""

"An abstract example would be the following to ensure correct resource "

"management::"

msgstr "下面是一个抽象的示例，展示如何确保正确的资源管理::"

#: ../../library/contextlib.rst:57

msgid ""

"from contextlib import contextmanager\n"

"\n"

"@contextmanager\n"

"def managed_resource(*args, **kwds):\n"

" # Code to acquire resource, e.g.:\n"

" resource = acquire_resource(*args, **kwds)\n"

" try:\n"

" yield resource\n"

" finally:\n"

" # Code to release resource, e.g.:\n"

" release_resource(resource)"

msgstr ""

"from contextlib import contextmanager\n"

"\n"

"@contextmanager\n"

"def managed_resource(*args, **kwds):\n"

" # 获取资源的代码，例如：\n"

" resource = acquire_resource(*args, **kwds)\n"

" try:\n"

" yield resource\n"

" finally:\n"

" # 释放资源的代码，例如：\n"

" release_resource(resource)"

#: ../../library/contextlib.rst:69

msgid "The function can then be used like this::"

msgstr "随后可以这样使用此函数::"

#: ../../library/contextlib.rst:71

msgid ""

">>> with managed_resource(timeout=3600) as resource:\n"

"... # Resource is released at the end of this block,\n"

"... # even if code in the block raises an exception"

msgstr ""

">>> with managed_resource(timeout=3600) as resource:\n"

"... # 资源将在此代码块的末尾被释放，\n"

"... # 即使代码块中的代码引发了异常"

#: ../../library/contextlib.rst:75

msgid ""

"The function being decorated must return a :term:`generator`-iterator when "

"called. This iterator must yield exactly one value, which will be bound to "

"the targets in the :keyword:`with` statement's :keyword:`!as` clause, if "

"any."

msgstr ""

"被装饰的函数在被调用时，必须返回一个 :term:`generator` 迭代器。 这个迭代器必须只 yield 一个值出来，这个值会被用在 "

":keyword:`with` 语句中，绑定到 :keyword:`!as` 后面的变量，如果给定了的话。"

#: ../../library/contextlib.rst:79

msgid ""

"At the point where the generator yields, the block nested in the "

":keyword:`with` statement is executed. The generator is then resumed after "

"the block is exited. If an unhandled exception occurs in the block, it is "

"reraised inside the generator at the point where the yield occurred. Thus, "

"you can use a :keyword:`try`...\\ :keyword:`except`...\\ :keyword:`finally` "

"statement to trap the error (if any), or ensure that some cleanup takes "

"place. If an exception is trapped merely in order to log it or to perform "

"some action (rather than to suppress it entirely), the generator must "

"reraise that exception. Otherwise the generator context manager will "

"indicate to the :keyword:`!with` statement that the exception has been "

"handled, and execution will resume with the statement immediately following "

"the :keyword:`!with` statement."

msgstr ""

"当生成器发生 yield 时，嵌套在 :keyword:`with` 语句中的语句体会被执行。 语句体执行完毕离开之后，该生成器将被恢复执行。 "

"如果在该语句体中发生了未处理的异常，则该异常会在生成器发生 yield 时重新被引发。 因此，你可以使用 :keyword:`try`...\\ "

":keyword:`except`...\\ :keyword:`finally` 语句来捕获该异常（如果有的话），或确保进行了一些清理。 "

"如果仅出于记录日志或执行某些操作（而非完全抑制异常）的目的捕获了异常，生成器必须重新引发该异常。 否则生成器的上下文管理器将向 "

":keyword:`!with` 语句指示该异常已经被处理，程序将立即在 :keyword:`!with` 语句之后恢复并继续执行。"

#: ../../library/contextlib.rst:91

msgid ""

":func:`contextmanager` uses :class:`ContextDecorator` so the context "

"managers it creates can be used as decorators as well as in :keyword:`with` "

"statements. When used as a decorator, a new generator instance is implicitly"

" created on each function call (this allows the otherwise \"one-shot\" "

"context managers created by :func:`contextmanager` to meet the requirement "

"that context managers support multiple invocations in order to be used as "

"decorators)."

msgstr ""

":func:`contextmanager` 使用 :class:`ContextDecorator` 因此它创建的上下文管理器不仅可以用在 "

":keyword:`with` 语句中，还可以用作一个装饰器。当它用作一个装饰器时，每一次函数调用时都会隐式创建一个新的生成器实例（这使得 "

":func:`contextmanager` 创建的上下文管理器满足了支持多次调用以用作装饰器的需求，而非“一次性”的上下文管理器）。"

#: ../../library/contextlib.rst:98

msgid "Use of :class:`ContextDecorator`."

msgstr ":class:`ContextDecorator` 的使用。"

#: ../../library/contextlib.rst:104

msgid ""

"Similar to :func:`~contextlib.contextmanager`, but creates an "

":ref:`asynchronous context manager <async-context-managers>`."

msgstr ""

"与 :func:`~contextlib.contextmanager` 类似，但创建的是 :ref:`asynchronous context "

"manager <async-context-managers>` 。"

#: ../../library/contextlib.rst:107

msgid ""

"This function is a :term:`decorator` that can be used to define a factory "

"function for :keyword:`async with` statement asynchronous context managers, "

"without needing to create a class or separate :meth:`~object.__aenter__` and"

" :meth:`~object.__aexit__` methods. It must be applied to an "

":term:`asynchronous generator` function."

msgstr ""

"该函数是一个 :term:`decorator`，它可被用来定义一个使用 :keyword:`async with` "

"语句的异步上下文管理器的工厂函数，而不需要创建一个类或单独的 :meth:`~object.__aenter__` 和 "

":meth:`~object.__aexit__` 方法。 它必须应用在 :term:`asynchronous generator` 函数上。"

#: ../../library/contextlib.rst:113

msgid "A simple example::"

msgstr "一个简单的示例："

#: ../../library/contextlib.rst:115

msgid ""

"from contextlib import asynccontextmanager\n"

"\n"

"@asynccontextmanager\n"

"async def get_connection():\n"

" conn = await acquire_db_connection()\n"

" try:\n"

" yield conn\n"

" finally:\n"

" await release_db_connection(conn)\n"

"\n"

"async def get_all_users():\n"

" async with get_connection() as conn:\n"

" return conn.query('SELECT ...')"

msgstr ""

"from contextlib import asynccontextmanager\n"

"\n"

"@asynccontextmanager\n"

"async def get_connection():\n"

" conn = await acquire_db_connection()\n"

" try:\n"

" yield conn\n"

" finally:\n"

" await release_db_connection(conn)\n"

"\n"

"async def get_all_users():\n"

" async with get_connection() as conn:\n"

" return conn.query('SELECT ...')"

#: ../../library/contextlib.rst:131

msgid ""

"Context managers defined with :func:`asynccontextmanager` can be used either"

" as decorators or with :keyword:`async with` statements::"

msgstr ""

"使用 :func:`asynccontextmanager` 定义的上下文管理器可以用作装饰器，也可以在 :keyword:`async with` "

"语句中使用。"

#: ../../library/contextlib.rst:134

msgid ""

"import time\n"

"from contextlib import asynccontextmanager\n"

"\n"

"@asynccontextmanager\n"

"async def timeit():\n"

" now = time.monotonic()\n"

" try:\n"

" yield\n"

" finally:\n"

" print(f'it took {time.monotonic() - now}s to run')\n"

"\n"

"@timeit()\n"

"async def main():\n"

" # ... async code ..."

msgstr ""

"import time\n"

"from contextlib import asynccontextmanager\n"

"\n"

"@asynccontextmanager\n"

"async def timeit():\n"

" now = time.monotonic()\n"

" try:\n"

" yield\n"

" finally:\n"

" print(f'it took {time.monotonic() - now}s to run')\n"

"\n"

"@timeit()\n"

"async def main():\n"

" # ... 异步代码 ..."

#: ../../library/contextlib.rst:149

msgid ""

"When used as a decorator, a new generator instance is implicitly created on "

"each function call. This allows the otherwise \"one-shot\" context managers "

"created by :func:`asynccontextmanager` to meet the requirement that context "

"managers support multiple invocations in order to be used as decorators."

msgstr ""

"用作装饰器时，每次函数调用都会隐式创建一个新的生成器实例。这使得由 :func:`asynccontextmanager` 创建的 “一次性” "

"上下文管理器能够满足作为装饰器所需要的支持多次调用的要求。"

#: ../../library/contextlib.rst:154

msgid ""

"Async context managers created with :func:`asynccontextmanager` can be used "

"as decorators."

msgstr "使用 :func:`asynccontextmanager` 创建的异步上下文管理器可以用作装饰器。"

#: ../../library/contextlib.rst:161

msgid ""

"Return a context manager that closes *thing* upon completion of the block. "

"This is basically equivalent to::"

msgstr "返回一个在语句块执行完成时关闭 *things* 的上下文管理器。这基本上等价于："

#: ../../library/contextlib.rst:164

msgid ""

"from contextlib import contextmanager\n"

"\n"

"@contextmanager\n"

"def closing(thing):\n"

" try:\n"

" yield thing\n"

" finally:\n"

" thing.close()"

msgstr ""

"from contextlib import contextmanager\n"

"\n"

"@contextmanager\n"

"def closing(thing):\n"

" try:\n"

" yield thing\n"

" finally:\n"

" thing.close()"

#: ../../library/contextlib.rst:173

msgid "And lets you write code like this::"

msgstr "并允许你编写这样的代码："

#: ../../library/contextlib.rst:175

msgid ""

"from contextlib import closing\n"

"from urllib.request import urlopen\n"

"\n"

"with closing(urlopen('https://www.python.org')) as page:\n"

" for line in page:\n"

" print(line)"

msgstr ""

"from contextlib import closing\n"

"from urllib.request import urlopen\n"

"\n"

"with closing(urlopen('https://www.python.org')) as page:\n"

" for line in page:\n"

" print(line)"

#: ../../library/contextlib.rst:182

msgid ""

"without needing to explicitly close ``page``. Even if an error occurs, "

"``page.close()`` will be called when the :keyword:`with` block is exited."

msgstr ""

"而无需显式地关闭 ``page`` 。 即使发生错误，在退出 :keyword:`with` 语句块时， ``page.close()`` "

"也同样会被调用。"

#: ../../library/contextlib.rst:187

msgid ""

"Most types managing resources support the :term:`context manager` protocol, "

"which closes *thing* on leaving the :keyword:`with` statement. As such, "

":func:`!closing` is most useful for third party types that don't support "

"context managers. This example is purely for illustration purposes, as "

":func:`~urllib.request.urlopen` would normally be used in a context manager."

msgstr ""

"大多数管理资源的类型都支持 :term:`context manager` 协议，它在离开 :keyword:`with` 语句时将关闭 "

"*thing*。 因此，:func:`!closing` 对不支持上下文管理器的第三方类型是最有用的。 这个例子纯粹是为了说明问题，因为 "

":func:`~urllib.request.urlopen` 通常都会在上下文管理器中使用。"

#: ../../library/contextlib.rst:196

msgid ""

"Return an async context manager that calls the ``aclose()`` method of "

"*thing* upon completion of the block. This is basically equivalent to::"

msgstr "返回一个在语句块执行完成时调用 ``aclose()`` 方法来关闭 *things* 的异步上下文管理器。这基本上等价于："

#: ../../library/contextlib.rst:199

msgid ""

"from contextlib import asynccontextmanager\n"

"\n"

"@asynccontextmanager\n"

"async def aclosing(thing):\n"

" try:\n"

" yield thing\n"

" finally:\n"

" await thing.aclose()"

msgstr ""

"from contextlib import asynccontextmanager\n"

"\n"

"@asynccontextmanager\n"

"async def aclosing(thing):\n"

" try:\n"

" yield thing\n"

" finally:\n"

" await thing.aclose()"

#: ../../library/contextlib.rst:208

msgid ""

"Significantly, ``aclosing()`` supports deterministic cleanup of async "

"generators when they happen to exit early by :keyword:`break` or an "

"exception. For example::"

msgstr ""

"重要的是，``aclosing()`` 支持在异步生成器因遭遇 :keyword:`break` 或异常而提前退出时对其执行确定性的清理。 例如::"

#: ../../library/contextlib.rst:212

msgid ""

"from contextlib import aclosing\n"

"\n"

"async with aclosing(my_generator()) as values:\n"

" async for value in values:\n"

" if value == 42:\n"

" break"

msgstr ""

"from contextlib import aclosing\n"

"\n"

"async with aclosing(my_generator()) as values:\n"

" async for value in values:\n"

" if value == 42:\n"

" break"

#: ../../library/contextlib.rst:219

msgid ""

"This pattern ensures that the generator's async exit code is executed in the"

" same context as its iterations (so that exceptions and context variables "

"work as expected, and the exit code isn't run after the lifetime of some "

"task it depends on)."

msgstr ""

"此模块将确保生成器的异步退出代码在与其迭代相同的上下文中执行（这样异常和上下文变量将能按预期工作，并且退出代码不会在其所依赖的某些任务的生命期结束后继续运行）。"

#: ../../library/contextlib.rst:231

msgid ""

"Return a context manager that returns *enter_result* from ``__enter__``, but"

" otherwise does nothing. It is intended to be used as a stand-in for an "

"optional context manager, for example::"

msgstr ""

"返回一个从 ``__enter__`` 返回 *enter_result* "

"的上下文管理器，除此之外不执行任何操作。它旨在用于可选上下文管理器的一种替代，例如："

#: ../../library/contextlib.rst:235

msgid ""

"def myfunction(arg, ignore_exceptions=False):\n"

" if ignore_exceptions:\n"

" # Use suppress to ignore all exceptions.\n"

" cm = contextlib.suppress(Exception)\n"

" else:\n"

" # Do not ignore any exceptions, cm has no effect.\n"

" cm = contextlib.nullcontext()\n"

" with cm:\n"

" # Do something"

msgstr ""

"def myfunction(arg, ignore_exceptions=False):\n"

" if ignore_exceptions:\n"

" # 使用 suppress 来忽略所有异常。\n"

" cm = contextlib.suppress(Exception)\n"

" else:\n"

" # 不忽略任何异常，cm 将没有影响。\n"

" cm = contextlib.nullcontext()\n"

" with cm:\n"

" # 执行某些操作"

#: ../../library/contextlib.rst:245

msgid "An example using *enter_result*::"

msgstr "一个使用 *enter_result* 的例子："

#: ../../library/contextlib.rst:247

msgid ""

"def process_file(file_or_path):\n"

" if isinstance(file_or_path, str):\n"

" # If string, open file\n"

" cm = open(file_or_path)\n"

" else:\n"

" # Caller is responsible for closing file\n"

" cm = nullcontext(file_or_path)\n"

"\n"

" with cm as file:\n"

" # Perform processing on the file"

msgstr ""

"def process_file(file_or_path):\n"

" if isinstance(file_or_path, str):\n"

" # If string, open file\n"

" cm = open(file_or_path)\n"

" else:\n"

" # 调用方要负责关闭文件\n"

" cm = nullcontext(file_or_path)\n"

"\n"

" with cm as file:\n"

" # 在文件上执行处理"

#: ../../library/contextlib.rst:258

msgid ""

"It can also be used as a stand-in for :ref:`asynchronous context managers "

"<async-context-managers>`::"

msgstr ""

"它也可以替代 :ref:`asynchronous context managers <async-context-managers>` ："

#: ../../library/contextlib.rst:261

msgid ""

"async def send_http(session=None):\n"

" if not session:\n"

" # If no http session, create it with aiohttp\n"

" cm = aiohttp.ClientSession()\n"

" else:\n"

" # Caller is responsible for closing the session\n"

" cm = nullcontext(session)\n"

"\n"

" async with cm as session:\n"

" # Send http requests with session"

msgstr ""

"async def send_http(session=None):\n"

" if not session:\n"

" # 如果没有 http 会话，则使用 aiohttp 创建它\n"

" cm = aiohttp.ClientSession()\n"

" else:\n"

" # 调用方要负责关闭会话\n"

" cm = nullcontext(session)\n"

"\n"

" async with cm as session:\n"

" # 使用会话发送 http 请求"

#: ../../library/contextlib.rst:274

msgid ":term:`asynchronous context manager` support was added."

msgstr "增加了对 :term:`asynchronous context manager` 的支持。"

#: ../../library/contextlib.rst:281

msgid ""

"Return a context manager that suppresses any of the specified exceptions if "

"they occur in the body of a :keyword:`!with` statement and then resumes "

"execution with the first statement following the end of the :keyword:`!with`"

" statement."

msgstr ""

"返回一个当指定的异常在 :keyword:`!with` 语句体中发生时会屏蔽它们然后从 :keyword:`!with` "

"语句结束后的第一条语言开始恢复执行的上下文管理器。"

#: ../../library/contextlib.rst:286

msgid ""

"As with any other mechanism that completely suppresses exceptions, this "

"context manager should be used only to cover very specific errors where "

"silently continuing with program execution is known to be the right thing to"

" do."

msgstr "与完全抑制异常的任何其他机制一样，该上下文管理器应当只用来抑制非常具体的错误，并确保该场景下静默地继续执行程序是通用的正确做法。"

#: ../../library/contextlib.rst:291

msgid "For example::"

msgstr "例如："

#: ../../library/contextlib.rst:293

msgid ""

"from contextlib import suppress\n"

"\n"

"with suppress(FileNotFoundError):\n"

" os.remove('somefile.tmp')\n"

"\n"

"with suppress(FileNotFoundError):\n"

" os.remove('someotherfile.tmp')"

msgstr ""

"from contextlib import suppress\n"

"\n"

"with suppress(FileNotFoundError):\n"

" os.remove('somefile.tmp')\n"

"\n"

"with suppress(FileNotFoundError):\n"

" os.remove('someotherfile.tmp')"

#: ../../library/contextlib.rst:301

msgid "This code is equivalent to::"

msgstr "这段代码等价于："

#: ../../library/contextlib.rst:303

msgid ""

"try:\n"

" os.remove('somefile.tmp')\n"

"except FileNotFoundError:\n"

" pass\n"

"\n"

"try:\n"

" os.remove('someotherfile.tmp')\n"

"except FileNotFoundError:\n"

" pass"

msgstr ""

"try:\n"

" os.remove('somefile.tmp')\n"

"except FileNotFoundError:\n"

" pass\n"

"\n"

"try:\n"

" os.remove('someotherfile.tmp')\n"

"except FileNotFoundError:\n"

" pass"

#: ../../library/contextlib.rst:313 ../../library/contextlib.rst:362

#: ../../library/contextlib.rst:372 ../../library/contextlib.rst:389

msgid "This context manager is :ref:`reentrant <reentrant-cms>`."

msgstr "该上下文管理器是 :ref:`reentrant <reentrant-cms>` 。"

#: ../../library/contextlib.rst:315

msgid ""

"If the code within the :keyword:`!with` block raises a "

":exc:`BaseExceptionGroup`, suppressed exceptions are removed from the group."

" Any exceptions of the group which are not suppressed are re-raised in a "

"new group which is created using the original group's "

":meth:`~BaseExceptionGroup.derive` method."

msgstr ""

"如果 :keyword:`!with` 语句块内的代码引发了 :exc:`BaseExceptionGroup`，将从分组中移除被抑制的异常。 "

"该分组中任何未被抑制的异常会在一个使用原分组的 :meth:`~BaseExceptionGroup.derive` 方法创建的新分组中被重新引发。"

#: ../../library/contextlib.rst:323

msgid ""

"``suppress`` now supports suppressing exceptions raised as part of a "

":exc:`BaseExceptionGroup`."

msgstr "``suppress`` 现在支持抑制作为 :exc:`BaseExceptionGroup` 的组成部分被引发的异常。"

#: ../../library/contextlib.rst:329

msgid ""

"Context manager for temporarily redirecting :data:`sys.stdout` to another "

"file or file-like object."

msgstr "用于将 :data:`sys.stdout` 临时重定向到一个文件或类文件对象的上下文管理器。"

#: ../../library/contextlib.rst:332

msgid ""

"This tool adds flexibility to existing functions or classes whose output is "

"hardwired to stdout."

msgstr "该工具给已有的将输出硬编码写到 stdout 的函数或类提供了额外的灵活性。"

#: ../../library/contextlib.rst:335

msgid ""

"For example, the output of :func:`help` normally is sent to *sys.stdout*. "

"You can capture that output in a string by redirecting the output to an "

":class:`io.StringIO` object. The replacement stream is returned from the "

"``__enter__`` method and so is available as the target of the "

":keyword:`with` statement::"

msgstr ""

"例如， :func:`help` 的输出通常会被发送到 *sys.stdout*。 你可以通过将输出重定向到一个 "

":class:`io.StringIO` 对象来将该输出捕获到字符串。 替换的流是由 ``__enter__`` 返回的因此可以被用作 "

":keyword:`with` 语句的目标::"

#: ../../library/contextlib.rst:341

msgid ""

"with redirect_stdout(io.StringIO()) as f:\n"

" help(pow)\n"

"s = f.getvalue()"

msgstr ""

"with redirect_stdout(io.StringIO()) as f:\n"

" help(pow)\n"

"s = f.getvalue()"

#: ../../library/contextlib.rst:345

msgid ""

"To send the output of :func:`help` to a file on disk, redirect the output to"

" a regular file::"

msgstr "如果要把 :func:`help` 的输出写到磁盘上的一个文件，重定向该输出到一个常规文件："

#: ../../library/contextlib.rst:348

msgid ""

"with open('help.txt', 'w') as f:\n"

" with redirect_stdout(f):\n"

" help(pow)"

msgstr ""

"with open('help.txt', 'w') as f:\n"

" with redirect_stdout(f):\n"

" help(pow)"

#: ../../library/contextlib.rst:352

msgid "To send the output of :func:`help` to *sys.stderr*::"

msgstr "如果要把 :func:`help` 的输出写到 *sys.stderr* ："

#: ../../library/contextlib.rst:354

msgid ""

"with redirect_stdout(sys.stderr):\n"

" help(pow)"

msgstr ""

"with redirect_stdout(sys.stderr):\n"

" help(pow)"

#: ../../library/contextlib.rst:357

msgid ""

"Note that the global side effect on :data:`sys.stdout` means that this "

"context manager is not suitable for use in library code and most threaded "

"applications. It also has no effect on the output of subprocesses. However, "

"it is still a useful approach for many utility scripts."

msgstr ""

"需要注意的点在于， :data:`sys.stdout` "

"的全局副作用意味着此上下文管理器不适合在库代码和大多数多线程应用程序中使用。它对子进程的输出没有影响。不过对于许多工具脚本而言，它仍然是一个有用的方法。"

#: ../../library/contextlib.rst:369

msgid ""

"Similar to :func:`~contextlib.redirect_stdout` but redirecting "

":data:`sys.stderr` to another file or file-like object."

msgstr ""

"与 :func:`~contextlib.redirect_stdout` 类似，不过是将 :data:`sys.stderr` "

"重定向到一个文件或类文件对象。"

#: ../../library/contextlib.rst:379

msgid ""

"Non parallel-safe context manager to change the current working directory. "

"As this changes a global state, the working directory, it is not suitable "

"for use in most threaded or async contexts. It is also not suitable for most"

" non-linear code execution, like generators, where the program execution is "

"temporarily relinquished -- unless explicitly desired, you should not yield "

"when this context manager is active."

msgstr ""

"用于改变当前工作目录的非并行安全的上下文管理器。 由于这会改变一个全局状态，即工作目录，因此它不适合在大多数线程或异步上下文中使用。 "

"它也不适合大多数非线性的代码执行，比如生成器，在此类代码中程序的执行会被临时性挂起 -- 除非明确希望如此，当该上下文管理器被激活时你不应执行 "

"yield 语句。"

#: ../../library/contextlib.rst:386

msgid ""

"This is a simple wrapper around :func:`~os.chdir`, it changes the current "

"working directory upon entering and restores the old one on exit."

msgstr "这是一个对 :func:`~os.chdir` 的简单包装器，它会在进入时改变当前工作目录并在退出时恢复。"

#: ../../library/contextlib.rst:396

msgid ""

"A base class that enables a context manager to also be used as a decorator."

msgstr "一个使上下文管理器能用作装饰器的基类。"

#: ../../library/contextlib.rst:398

msgid ""

"Context managers inheriting from ``ContextDecorator`` have to implement "

"``__enter__`` and ``__exit__`` as normal. ``__exit__`` retains its optional "

"exception handling even when used as a decorator."

msgstr ""

"与往常一样，继承自 ``ContextDecorator``  的上下文管理器必须实现 ``__enter__`` 与 ``__exit__`` "

"。即使用作装饰器， ``__exit__`` 依旧会保持可能的异常处理。"

#: ../../library/contextlib.rst:402

msgid ""

"``ContextDecorator`` is used by :func:`contextmanager`, so you get this "

"functionality automatically."

msgstr "``ContextDecorator`` 被用在 :func:`contextmanager` 中，因此你自然获得了这项功能。"

#: ../../library/contextlib.rst:405

msgid "Example of ``ContextDecorator``::"

msgstr "``ContextDecorator`` 的示例::"

#: ../../library/contextlib.rst:407

msgid ""

"from contextlib import ContextDecorator\n"

"\n"

"class mycontext(ContextDecorator):\n"

" def __enter__(self):\n"

" print('Starting')\n"

" return self\n"

"\n"

" def __exit__(self, *exc):\n"

" print('Finishing')\n"

" return False"

msgstr ""

"from contextlib import ContextDecorator\n"

"\n"

"class mycontext(ContextDecorator):\n"

" def __enter__(self):\n"

" print('Starting')\n"

" return self\n"

"\n"

" def __exit__(self, *exc):\n"

" print('Finishing')\n"

" return False"

#: ../../library/contextlib.rst:418 ../../library/contextlib.rst:490

msgid "The class can then be used like this::"

msgstr "随后可以这样使用该类::"

#: ../../library/contextlib.rst:420

msgid ""

">>> @mycontext()\n"

"... def function():\n"

"... print('The bit in the middle')\n"

"...\n"

">>> function()\n"

"Starting\n"

"The bit in the middle\n"

"Finishing\n"

"\n"

">>> with mycontext():\n"

"... print('The bit in the middle')\n"

"...\n"

"Starting\n"

"The bit in the middle\n"

"Finishing"

msgstr ""

">>> @mycontext()\n"

"... def function():\n"

"... print('The bit in the middle')\n"

"...\n"

">>> function()\n"

"Starting\n"

"The bit in the middle\n"

"Finishing\n"

"\n"

">>> with mycontext():\n"

"... print('The bit in the middle')\n"

"...\n"

"Starting\n"

"The bit in the middle\n"

"Finishing"

#: ../../library/contextlib.rst:436

msgid ""

"This change is just syntactic sugar for any construct of the following "

"form::"

msgstr "这个改动只是针对如下形式的一个语法糖："

#: ../../library/contextlib.rst:438

msgid ""

"def f():\n"

" with cm():\n"

" # Do stuff"

msgstr ""

"def f():\n"

" with cm():\n"

" # 执行操作"

#: ../../library/contextlib.rst:442

msgid "``ContextDecorator`` lets you instead write::"

msgstr "``ContextDecorator`` 使得你可以这样改写："

#: ../../library/contextlib.rst:444

msgid ""

"@cm()\n"

"def f():\n"

" # Do stuff"

msgstr ""

"@cm()\n"

"def f():\n"

" # 执行操作"

#: ../../library/contextlib.rst:448

msgid ""

"It makes it clear that the ``cm`` applies to the whole function, rather than"

" just a piece of it (and saving an indentation level is nice, too)."

msgstr "这能清楚地表明， ``cm`` 作用于整个函数，而不仅仅是函数的一部分（同时也能保持不错的缩进层级）。"

#: ../../library/contextlib.rst:451

msgid ""

"Existing context managers that already have a base class can be extended by "

"using ``ContextDecorator`` as a mixin class::"

msgstr "现有的上下文管理器即使已经有基类，也可以使用 ``ContextDecorator`` 作为混合类进行扩展："

#: ../../library/contextlib.rst:454

msgid ""

"from contextlib import ContextDecorator\n"

"\n"

"class mycontext(ContextBaseClass, ContextDecorator):\n"

" def __enter__(self):\n"

" return self\n"

"\n"

" def __exit__(self, *exc):\n"

" return False"

msgstr ""

"from contextlib import ContextDecorator\n"

"\n"

"class mycontext(ContextBaseClass, ContextDecorator):\n"

" def __enter__(self):\n"

" return self\n"

"\n"

" def __exit__(self, *exc):\n"

" return False"

#: ../../library/contextlib.rst:464

msgid ""

"As the decorated function must be able to be called multiple times, the "

"underlying context manager must support use in multiple :keyword:`with` "

"statements. If this is not the case, then the original construct with the "

"explicit :keyword:`!with` statement inside the function should be used."

msgstr ""

"由于被装饰的函数必须能够被多次调用，因此对应的上下文管理器必须支持在多个 :keyword:`with` "

"语句中使用。如果不是这样，则应当使用原来的具有显式 :keyword:`!with` 语句的形式使用该上下文管理器。"

#: ../../library/contextlib.rst:474

msgid ""

"Similar to :class:`ContextDecorator` but only for asynchronous functions."

msgstr "和 :class:`ContextDecorator` 类似，但是用于异步函数。"

#: ../../library/contextlib.rst:476

msgid "Example of ``AsyncContextDecorator``::"

msgstr "``AsyncContextDecorator`` 的示例::"

#: ../../library/contextlib.rst:478

msgid ""

"from asyncio import run\n"

"from contextlib import AsyncContextDecorator\n"

"\n"

"class mycontext(AsyncContextDecorator):\n"

" async def __aenter__(self):\n"

" print('Starting')\n"

" return self\n"

"\n"

" async def __aexit__(self, *exc):\n"

" print('Finishing')\n"

" return False"

msgstr ""

"from asyncio import run\n"

"from contextlib import AsyncContextDecorator\n"

"\n"

"class mycontext(AsyncContextDecorator):\n"

" async def __aenter__(self):\n"

" print('Starting')\n"

" return self\n"

"\n"

" async def __aexit__(self, *exc):\n"

" print('Finishing')\n"

" return False"

#: ../../library/contextlib.rst:492

msgid ""

">>> @mycontext()\n"

"... async def function():\n"

"... print('The bit in the middle')\n"

"...\n"

">>> run(function())\n"

"Starting\n"

"The bit in the middle\n"

"Finishing\n"

"\n"

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

"... async with mycontext():\n"

"... print('The bit in the middle')\n"

"...\n"

">>> run(function())\n"

"Starting\n"

"The bit in the middle\n"

"Finishing"

msgstr ""

">>> @mycontext()\n"

"... async def function():\n"

"... print('The bit in the middle')\n"

"...\n"

">>> run(function())\n"

"Starting\n"

"The bit in the middle\n"

"Finishing\n"

"\n"

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

"... async with mycontext():\n"

"... print('The bit in the middle')\n"

"...\n"

">>> run(function())\n"

"Starting\n"

"The bit in the middle\n"

"Finishing"

#: ../../library/contextlib.rst:515

msgid ""

"A context manager that is designed to make it easy to programmatically "

"combine other context managers and cleanup functions, especially those that "

"are optional or otherwise driven by input data."

msgstr "该上下文管理器的设计目标是使得在编码中组合其他上下文管理器和清理函数更加容易，尤其是那些可选的或由输入数据驱动的上下文管理器。"

#: ../../library/contextlib.rst:519

msgid ""

"For example, a set of files may easily be handled in a single with statement"

" as follows::"

msgstr "例如，通过一个如下的 with 语句可以很容易处理一组文件："

#: ../../library/contextlib.rst:522

msgid ""

"with ExitStack() as stack:\n"

" files = [stack.enter_context(open(fname)) for fname in filenames]\n"

" # All opened files will automatically be closed at the end of\n"

" # the with statement, even if attempts to open files later\n"

" # in the list raise an exception"

msgstr ""

"with ExitStack() as stack:\n"

" files = [stack.enter_context(open(fname)) for fname in filenames]\n"

" # 所有已打开的文件都将在 with 语句结束时\n"

" # 自动被关闭，即使此后打开列表中文件的\n"

" # 尝试引发了异常"

#: ../../library/contextlib.rst:528

msgid ""

"The :meth:`~object.__enter__` method returns the :class:`ExitStack` "

"instance, and performs no additional operations."

msgstr ":meth:`~object.__enter__` 方法返回 :class:`ExitStack` 的实例，并且不会执行额外的操作。"

#: ../../library/contextlib.rst:531

msgid ""

"Each instance maintains a stack of registered callbacks that are called in "

"reverse order when the instance is closed (either explicitly or implicitly "

"at the end of a :keyword:`with` statement). Note that callbacks are *not* "

"invoked implicitly when the context stack instance is garbage collected."

msgstr ""

"每个实例维护一个注册了一组回调的栈，这些回调在实例关闭时以相反的顺序被调用（显式或隐式地在 :keyword:`with` "

"语句的末尾）。请注意，当一个栈实例被垃圾回收时，这些回调将 *不会* 被隐式调用。"

#: ../../library/contextlib.rst:536

msgid ""

"This stack model is used so that context managers that acquire their "

"resources in their ``__init__`` method (such as file objects) can be handled"

" correctly."

msgstr "通过使用这个基于栈的模型，那些通过 ``__init__`` 方法获取资源的上下文管理器（如文件对象）能够被正确处理。"

#: ../../library/contextlib.rst:540

msgid ""

"Since registered callbacks are invoked in the reverse order of registration,"

" this ends up behaving as if multiple nested :keyword:`with` statements had "

"been used with the registered set of callbacks. This even extends to "

"exception handling - if an inner callback suppresses or replaces an "

"exception, then outer callbacks will be passed arguments based on that "

"updated state."

msgstr ""

"由于注册的回调函数是按照与注册相反的顺序调用的，因此最终的行为就像多个嵌套的 :keyword:`with` "