configparser.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# ww song <sww4718168@gmail.com>, 2020
# eric R <trencyclopedia@gmail.com>, 2020
# Freesand Leo <yuqinju@163.com>, 2020
# walkinrain <walkinrain2008@outlook.com>, 2020
# Rafael Fontenelle <rffontenelle@gmail.com>, 2024
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-01-13 00:12+0000\n"
"PO-Revision-Date: 2020-05-30 11:58+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2024\n"
"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/configparser.rst:2
msgid ":mod:`configparser` --- Configuration file parser"
msgstr ":mod:`configparser` --- 配置文件解析器"

#: ../../library/configparser.rst:14
msgid "**Source code:** :source:`Lib/configparser.py`"
msgstr "**源代码:** :source:`Lib/configparser.py`"

#: ../../library/configparser.rst:24
msgid ""
"This module provides the :class:`ConfigParser` class which implements a "
"basic configuration language which provides a structure similar to what's "
"found in Microsoft Windows INI files.  You can use this to write Python "
"programs which can be customized by end users easily."
msgstr ""
"此模块提供了它实现一种基本配置语言 :class:`ConfigParser` 类，这种语言所提供的结构与 Microsoft Windows INI "
"文件的类似。 你可以使用这种语言来编写能够由最终用户来自定义的 Python 程序。"

#: ../../library/configparser.rst:31
msgid ""
"This library does *not* interpret or write the value-type prefixes used in "
"the Windows Registry extended version of INI syntax."
msgstr "这个库 *并不* 能够解析或写入在 Windows Registry 扩展版本 INI 语法中所使用的值-类型前缀。"

#: ../../library/configparser.rst:38
msgid "Module :mod:`shlex`"
msgstr "模块 :mod:`shlex`"

#: ../../library/configparser.rst:37
msgid ""
"Support for creating Unix shell-like mini-languages which can be used as an "
"alternate format for application configuration files."
msgstr "支持创建可被用作应用配置文件的替代的 Unix 终端式微语言。"

#: ../../library/configparser.rst:41
msgid "Module :mod:`json`"
msgstr "模块 :mod:`json`"

#: ../../library/configparser.rst:41
msgid ""
"The json module implements a subset of JavaScript syntax which can also be "
"used for this purpose."
msgstr "json 模块实现了一个 JavaScript 语法的子集，它也可被用于这种目的。"

#: ../../library/configparser.rst:51
msgid "Quick Start"
msgstr "快速起步"

#: ../../library/configparser.rst:53
msgid "Let's take a very basic configuration file that looks like this:"
msgstr "让我们准备一个非常基本的配置文件，它看起来是这样的:"

#: ../../library/configparser.rst:70
msgid ""
"The structure of INI files is described `in the following section "
"<#supported-ini-file-structure>`_.  Essentially, the file consists of "
"sections, each of which contains keys with values. :mod:`configparser` "
"classes can read and write such files.  Let's start by creating the above "
"configuration file programmatically."
msgstr ""
"INI 文件的结构描述见 `以下章节 <#supported-ini-file-structure>`_。 "
"总的来说，这种文件由多个节组成，每个节包含多个带有值的键。 :mod:`configparser` 类可以读取和写入这种文件。 "
"让我们先通过程序方式来创建上述的配置文件。"

#: ../../library/configparser.rst:94
msgid ""
"As you can see, we can treat a config parser much like a dictionary. There "
"are differences, `outlined later <#mapping-protocol-access>`_, but the "
"behavior is very close to what you would expect from a dictionary."
msgstr ""
"如你所见，我们可以把配置解析器当作一个字典来处理。 两者确实存在差异，`将在后文说明 <#mapping-protocol-"
"access>`_，但是其行为非常接近于字典所具有一般行为。"

#: ../../library/configparser.rst:98
msgid ""
"Now that we have created and saved a configuration file, let's read it back "
"and explore the data it holds."
msgstr "现在我们已经创建并保存了一个配置文件，让我们再将它读取出来并探究其中包含的数据。"

#: ../../library/configparser.rst:133
msgid ""
"As we can see above, the API is pretty straightforward.  The only bit of "
"magic involves the ``DEFAULT`` section which provides default values for all"
" other sections [1]_.  Note also that keys in sections are case-insensitive "
"and stored in lowercase [1]_."
msgstr ""
"正如我们在上面所看到的，相关的 API 相当直观。 唯一有些神奇的地方是 ``DEFAULT`` 小节，它为所有其他小节提供了默认值 [1]_。 "
"还要注意小节中的键大小写不敏感并且会存储为小写形式 [1]_。"

#: ../../library/configparser.rst:140
msgid "Supported Datatypes"
msgstr "支持的数据类型"

#: ../../library/configparser.rst:142
msgid ""
"Config parsers do not guess datatypes of values in configuration files, "
"always storing them internally as strings.  This means that if you need "
"other datatypes, you should convert on your own:"
msgstr "配置解析器并不会猜测配置文件中值的类型，而总是将它们在内部存储为字符串。 这意味着如果你需要其他数据类型，你应当自己来转换:"

#: ../../library/configparser.rst:153
msgid ""
"Since this task is so common, config parsers provide a range of handy getter"
" methods to handle integers, floats and booleans.  The last one is the most "
"interesting because simply passing the value to ``bool()`` would do no good "
"since ``bool('False')`` is still ``True``.  This is why config parsers also "
"provide :meth:`~ConfigParser.getboolean`.  This method is case-insensitive "
"and recognizes Boolean values from ``'yes'``/``'no'``, ``'on'``/``'off'``, "
"``'true'``/``'false'`` and ``'1'``/``'0'`` [1]_.  For example:"
msgstr ""
"由于这种任务十分常用，配置解析器提供了一系列便捷的获取方法来处理整数、浮点数和布尔值。 最后一个类型的处理最为有趣，因为简单地将值传给 "
"``bool()`` 是没有用的，``bool('False')`` 仍然会是 ``True``。 为解决这个问题配置解析器还提供了 "
":meth:`~ConfigParser.getboolean`。 这个方法对大小写不敏感并可识别 ``'yes'``/``'no'``, "
"``'on'``/``'off'``, ``'true'``/``'false'`` 和 ``'1'``/``'0'`` [1]_ 等布尔值。 例如:"

#: ../../library/configparser.rst:170
msgid ""
"Apart from :meth:`~ConfigParser.getboolean`, config parsers also provide "
"equivalent :meth:`~ConfigParser.getint` and :meth:`~ConfigParser.getfloat` "
"methods.  You can register your own converters and customize the provided "
"ones. [1]_"
msgstr ""
"除了 :meth:`~ConfigParser.getboolean`，配置解析器还提供了同类的 "
":meth:`~ConfigParser.getint` 和 :meth:`~ConfigParser.getfloat` 方法。 "
"你可以注册你自己的转换器并或是定制已提供的转换器。 [1]_"

#: ../../library/configparser.rst:176
msgid "Fallback Values"
msgstr "回退值"

#: ../../library/configparser.rst:178
msgid ""
"As with a dictionary, you can use a section's :meth:`get` method to provide "
"fallback values:"
msgstr "与字典类似，你可以使用某个小节的 :meth:`get` 方法来提供回退值:"

#: ../../library/configparser.rst:191
msgid ""
"Please note that default values have precedence over fallback values. For "
"instance, in our example the ``'CompressionLevel'`` key was specified only "
"in the ``'DEFAULT'`` section.  If we try to get it from the section "
"``'topsecret.server.com'``, we will always get the default, even if we "
"specify a fallback:"
msgstr ""
"请注意默认值会优先于回退值。 例如，在我们的示例中 ``'CompressionLevel'`` 键仅在 ``'DEFAULT'`` 小节被指定。 "
"如果你尝试在 ``'topsecret.server.com'`` 小节获取它，我们将总是获取到默认值，即使我们指定了一个回退值:"

#: ../../library/configparser.rst:202
msgid ""
"One more thing to be aware of is that the parser-level :meth:`get` method "
"provides a custom, more complex interface, maintained for backwards "
"compatibility.  When using this method, a fallback value can be provided via"
" the ``fallback`` keyword-only argument:"
msgstr ""
"还需要注意的一点是解析器层级的 :meth:`get` 方法提供了自定义的更复杂接口，它被维护用于向下兼容。 当使用此方法时，回退值可以通过 "
"``fallback`` 仅限关键字参数来提供:"

#: ../../library/configparser.rst:213
msgid ""
"The same ``fallback`` argument can be used with the "
":meth:`~ConfigParser.getint`, :meth:`~ConfigParser.getfloat` and "
":meth:`~ConfigParser.getboolean` methods, for example:"
msgstr ""
"同样的 ``fallback`` 参数也可在 :meth:`~ConfigParser.getint`, "
":meth:`~ConfigParser.getfloat` 和 :meth:`~ConfigParser.getboolean` 方法中使用，例如:"

#: ../../library/configparser.rst:229
msgid "Supported INI File Structure"
msgstr "受支持的 INI 文件结构"

#: ../../library/configparser.rst:231
msgid ""
"A configuration file consists of sections, each led by a ``[section]`` "
"header, followed by key/value entries separated by a specific string (``=`` "
"or ``:`` by default [1]_).  By default, section names are case sensitive but"
" keys are not [1]_.  Leading and trailing whitespace is removed from keys "
"and values. Values can be omitted, in which case the key/value delimiter may"
" also be left out.  Values can also span multiple lines, as long as they are"
" indented deeper than the first line of the value.  Depending on the "
"parser's mode, blank lines may be treated as parts of multiline values or "
"ignored."
msgstr ""
"配置文件是由小节组成的，每个小节都有一个 ``[section]`` 标头，加上多个由特定字符串 (默认为 ``=`` 或 ``:`` [1]_) "
"分隔的键/值条目。 默认情况下小节名对大小写敏感而键对大小写不敏感 [1]_。 键和值开头和末尾的空格会被移除。 "
"值可以被省略，在此情况下键/值分隔符也可以被省略。 值还可以跨越多行，只要其他行带有比值的第一行更深的缩进。 "
"依据解析器的具体模式，空白行可能被视为多行值的组成部分也可能被忽略。"

#: ../../library/configparser.rst:240
msgid ""
"Configuration files may include comments, prefixed by specific characters "
"(``#`` and ``;`` by default [1]_).  Comments may appear on their own on an "
"otherwise empty line, possibly indented. [1]_"
msgstr ""
"配置文件可以包含注释，要带有指定字符前缀 (默认为 ``#`` 和 ``;`` [1]_)。 注释可以单独出现于原本的空白行，并可使用缩进。 [1]_"

#: ../../library/configparser.rst:244 ../../library/configparser.rst:307
msgid "For example:"
msgstr "例如:"

#: ../../library/configparser.rst:292
msgid "Interpolation of values"
msgstr "值的插值"

#: ../../library/configparser.rst:294
msgid ""
"On top of the core functionality, :class:`ConfigParser` supports "
"interpolation.  This means values can be preprocessed before returning them "
"from ``get()`` calls."
msgstr "在核心功能之上，:class:`ConfigParser` 还支持插值。 这意味着值可以在被 ``get()`` 调用返回之前进行预处理。"

#: ../../library/configparser.rst:302
msgid ""
"The default implementation used by :class:`ConfigParser`.  It enables values"
" to contain format strings which refer to other values in the same section, "
"or values in the special default section [1]_.  Additional default values "
"can be provided on initialization."
msgstr ""
"默认实现由 :class:`ConfigParser` 来使用。 它允许值包含引用了相同小节中其他值或者特殊的默认小节中的值的格式字符串 [1]_。 "
"额外的默认值可以在初始化时提供。"

#: ../../library/configparser.rst:319
msgid ""
"In the example above, :class:`ConfigParser` with *interpolation* set to "
"``BasicInterpolation()`` would resolve ``%(home_dir)s`` to the value of "
"``home_dir`` (``/Users`` in this case).  ``%(my_dir)s`` in effect would "
"resolve to ``/Users/lumberjack``.  All interpolations are done on demand so "
"keys used in the chain of references do not have to be specified in any "
"specific order in the configuration file."
msgstr ""
"在上面的例子里，:class:`ConfigParser` 的 *interpolation* 设为 "
"``BasicInterpolation()``，这会将 ``%(home_dir)s`` 求解为 ``home_dir`` 的值 (在这里是 "
"``/Users``)。 ``%(my_dir)s`` 的将被实际求解为 ``/Users/lumberjack``。 "
"所有插值都是按需进行的，这样引用链中使用的键不必以任何特定顺序在配置文件中指明。"

#: ../../library/configparser.rst:326
msgid ""
"With ``interpolation`` set to ``None``, the parser would simply return "
"``%(my_dir)s/Pictures`` as the value of ``my_pictures`` and "
"``%(home_dir)s/lumberjack`` as the value of ``my_dir``."
msgstr ""
"当 ``interpolation`` 设为 ``None`` 时，解析器会简单地返回 ``%(my_dir)s/Pictures`` 作为 "
"``my_pictures`` 的值，并返回 ``%(home_dir)s/lumberjack`` 作为 ``my_dir`` 的值。"

#: ../../library/configparser.rst:334
msgid ""
"An alternative handler for interpolation which implements a more advanced "
"syntax, used for instance in ``zc.buildout``.  Extended interpolation is "
"using ``${section:option}`` to denote a value from a foreign section. "
"Interpolation can span multiple levels.  For convenience, if the "
"``section:`` part is omitted, interpolation defaults to the current section "
"(and possibly the default values from the special section)."
msgstr ""
"一个用于插值的替代处理程序实现了更高级的语法，它被用于 ``zc.buildout`` 中的实例。 扩展插值使用 "
"``${section:option}`` 来表示来自外部小节的值。 插值可以跨越多个层级。 为了方便使用，``section:`` "
"部分可被省略，插值会默认作用于当前小节（可能会从特殊小节获取默认值）。"

#: ../../library/configparser.rst:341
msgid ""
"For example, the configuration specified above with basic interpolation, "
"would look like this with extended interpolation:"
msgstr "例如，上面使用基本插值描述的配置，使用扩展插值将是这个样子:"

#: ../../library/configparser.rst:354
msgid "Values from other sections can be fetched as well:"
msgstr "来自其他小节的值也可以被获取:"

#: ../../library/configparser.rst:376
msgid "Mapping Protocol Access"
msgstr "映射协议访问"

#: ../../library/configparser.rst:380
msgid ""
"Mapping protocol access is a generic name for functionality that enables "
"using custom objects as if they were dictionaries.  In case of "
":mod:`configparser`, the mapping interface implementation is using the "
"``parser['section']['option']`` notation."
msgstr ""
"映射协议访问这个通用名称是指允许以字典的方式来使用自定义对象的功能。 在 :mod:`configparser` 中，映射接口的实现使用了 "
"``parser['section']['option']`` 标记法。"

#: ../../library/configparser.rst:385
msgid ""
"``parser['section']`` in particular returns a proxy for the section's data "
"in the parser.  This means that the values are not copied but they are taken"
" from the original parser on demand.  What's even more important is that "
"when values are changed on a section proxy, they are actually mutated in the"
" original parser."
msgstr ""
"``parser['section']`` 专门为解析器中的小节数据返回一个代理。 这意味着其中的值不会被拷贝，而是在需要时从原始解析器中获取。 "
"更为重要的是，当值在小节代理上被修改时，它们其实是在原始解析器中发生了改变。"

#: ../../library/configparser.rst:391
msgid ""
":mod:`configparser` objects behave as close to actual dictionaries as "
"possible. The mapping interface is complete and adheres to the "
":class:`~collections.abc.MutableMapping` ABC. However, there are a few "
"differences that should be taken into account:"
msgstr ""
":mod:`configparser` 对象的行为会尽可能地接近真正的字典。 映射接口是完整而且遵循 "
":class:`~collections.abc.MutableMapping` ABC 规范的。 但是，还是有一些差异应当被纳入考虑:"

#: ../../library/configparser.rst:396
msgid ""
"By default, all keys in sections are accessible in a case-insensitive manner"
" [1]_.  E.g. ``for option in parser[\"section\"]`` yields only "
"``optionxform``'ed option key names.  This means lowercased keys by default."
"  At the same time, for a section that holds the key ``'a'``, both "
"expressions return ``True``::"
msgstr ""
"默认情况下，小节中的所有键是以大小写不敏感的方式来访问的 [1]_。 例如 ``for option in parser[\"section\"]`` "
"只会产生 ``optionxform`` 形式的选项键名称。 也就是说默认使用小写字母键名。 与此同时，对于一个包含键 ``'a'`` "
"的小节，以下两个表达式均将返回 ``True``::"

#: ../../library/configparser.rst:404
msgid ""
"All sections include ``DEFAULTSECT`` values as well which means that "
"``.clear()`` on a section may not leave the section visibly empty.  This is "
"because default values cannot be deleted from the section (because "
"technically they are not there).  If they are overridden in the section, "
"deleting causes the default value to be visible again.  Trying to delete a "
"default value causes a :exc:`KeyError`."
msgstr ""
"所有小节也包括 ``DEFAULTSECT``，这意味着对一个小节执行 ``.clear()`` 可能无法使得该小节显示为空。 "
"这是因为默认值是无法从小节中被删除的（因为从技术上说它们并不在那里）。 如果它们在小节中被覆盖，删除将导致默认值重新变为可见。 尝试删除默认值将会引发 "
":exc:`KeyError`。"

#: ../../library/configparser.rst:411
msgid "``DEFAULTSECT`` cannot be removed from the parser:"
msgstr "``DEFAULTSECT`` 无法从解析器中被移除:"

#: ../../library/configparser.rst:413
msgid "trying to delete it raises :exc:`ValueError`,"
msgstr "尝试删除将引发 :exc:`ValueError`，"

#: ../../library/configparser.rst:415
msgid "``parser.clear()`` leaves it intact,"
msgstr "``parser.clear()`` 会保留其原状，"

#: ../../library/configparser.rst:417
msgid "``parser.popitem()`` never returns it."
msgstr "``parser.popitem()`` 绝不会将其返回。"

#: ../../library/configparser.rst:419
msgid ""
"``parser.get(section, option, **kwargs)`` - the second argument is **not** a"
" fallback value.  Note however that the section-level ``get()`` methods are "
"compatible both with the mapping protocol and the classic configparser API."
msgstr ""
"``parser.get(section, option, **kwargs)`` - 第二个参数 **并非** 回退值。 但是请注意小节层级的 "
"``get()`` 方法可同时兼容映射协议和经典配置解析器 API。"

#: ../../library/configparser.rst:423
msgid ""
"``parser.items()`` is compatible with the mapping protocol (returns a list "
"of *section_name*, *section_proxy* pairs including the DEFAULTSECT).  "
"However, this method can also be invoked with arguments: "
"``parser.items(section, raw, vars)``.  The latter call returns a list of "
"*option*, *value* pairs for a specified ``section``, with all interpolations"
" expanded (unless ``raw=True`` is provided)."
msgstr ""
"``parser.items()`` 兼容映射协议（返回 *section_name*, *section_proxy* 对的列表，包括 "
"DEFAULTSECT）。 但是，此方法也可以带参数发起调用: ``parser.items(section, raw, vars)``。 "
"这种调用形式返回指定 ``section`` 的 *option*, *value* 对的列表，将展开所有插值（除非提供了 ``raw=True`` "
"选项）。"

#: ../../library/configparser.rst:430
msgid ""
"The mapping protocol is implemented on top of the existing legacy API so "
"that subclasses overriding the original interface still should have mappings"
" working as expected."
msgstr "映射协议是在现有的传统 API 之上实现的，以便重写原始接口的子类仍然具有符合预期的有效映射。"

#: ../../library/configparser.rst:436
msgid "Customizing Parser Behaviour"
msgstr "定制解析器行为"

#: ../../library/configparser.rst:438
msgid ""
"There are nearly as many INI format variants as there are applications using"
" it. :mod:`configparser` goes a long way to provide support for the largest "
"sensible set of INI styles available.  The default functionality is mainly "
"dictated by historical background and it's very likely that you will want to"
" customize some of the features."
msgstr ""
"INI 格式的变种数量几乎和使用此格式的应用一样多。 :mod:`configparser` 花费了很大力气来为尽量大范围的可用 INI 样式提供支持。"
" 默认的可用功能主要由历史状况来确定，你很可能会想要定制某些特性。"

#: ../../library/configparser.rst:444
msgid ""
"The most common way to change the way a specific config parser works is to "
"use the :meth:`__init__` options:"
msgstr "改变特定配置解析器行为的最常见方式是使用 :meth:`__init__` 选项:"

#: ../../library/configparser.rst:447
msgid "*defaults*, default value: ``None``"
msgstr "*defaults*，默认值: ``None``"

#: ../../library/configparser.rst:449
msgid ""
"This option accepts a dictionary of key-value pairs which will be initially "
"put in the ``DEFAULT`` section.  This makes for an elegant way to support "
"concise configuration files that don't specify values which are the same as "
"the documented default."
msgstr ""
"此选项接受一个键值对的字典，它将被首先放入 ``DEFAULT`` 小节。 "
"这实现了一种优雅的方式来支持简洁的配置文件，它不必指定与已记录的默认值相同的值。"

#: ../../library/configparser.rst:454
msgid ""
"Hint: if you want to specify default values for a specific section, use "
":meth:`read_dict` before you read the actual file."
msgstr "提示：如果你想要为特定的小节指定默认的值，请在读取实际文件之前使用 :meth:`read_dict`。"

#: ../../library/configparser.rst:457
msgid "*dict_type*, default value: :class:`dict`"
msgstr "*dict_type*，默认值: :class:`dict`"

#: ../../library/configparser.rst:459
msgid ""
"This option has a major impact on how the mapping protocol will behave and "
"how the written configuration files look.  With the standard dictionary, "
"every section is stored in the order they were added to the parser.  Same "
"goes for options within sections."
msgstr "此选项主要影响映射协议的行为和写入配置文件的外观。 使用标准字典时，每个小节是按照它们被加入解析器的顺序保存的。 在小节内的选项也是如此。"

#: ../../library/configparser.rst:464
msgid ""
"An alternative dictionary type can be used for example to sort sections and "
"options on write-back."
msgstr "还有其他替换的字典类型可以使用，例如在写回数据时对小节和选项进行排序。"

#: ../../library/configparser.rst:467
msgid ""
"Please note: there are ways to add a set of key-value pairs in a single "
"operation.  When you use a regular dictionary in those operations, the order"
" of the keys will be ordered.  For example:"
msgstr "请注意：存在其他方式只用一次操作来添加键值对的集合。 当你在这些操作中使用一个常规字典时，键将按顺序进行排列。 例如:"

#: ../../library/configparser.rst:489
msgid "*allow_no_value*, default value: ``False``"
msgstr "*allow_no_value*，默认值: ``False``"

#: ../../library/configparser.rst:491
msgid ""
"Some configuration files are known to include settings without values, but "
"which otherwise conform to the syntax supported by :mod:`configparser`.  The"
" *allow_no_value* parameter to the constructor can be used to indicate that "
"such values should be accepted:"
msgstr ""
"已知某些配置文件会包括不带值的设置，但其在其他方面均符合 :mod:`configparser` 所支持的语法。 构造器的 "
"*allow_no_value* 形参可用于指明应当接受这样的值:"

#: ../../library/configparser.rst:526
msgid "*delimiters*, default value: ``('=', ':')``"
msgstr "*delimiters*，默认值: ``('=', ':')``"

#: ../../library/configparser.rst:528
msgid ""
"Delimiters are substrings that delimit keys from values within a section. "
"The first occurrence of a delimiting substring on a line is considered a "
"delimiter.  This means values (but not keys) can contain the delimiters."
msgstr "分隔符是用于在小节内分隔键和值的子字符串。 在一行中首次出现的分隔子字符串会被视为一个分隔符。 这意味着值可以包含分隔符（但键不可以）。"

#: ../../library/configparser.rst:532
msgid ""
"See also the *space_around_delimiters* argument to "
":meth:`ConfigParser.write`."
msgstr "另请参见 :meth:`ConfigParser.write` 的 *space_around_delimiters* 参数。"

#: ../../library/configparser.rst:535
msgid "*comment_prefixes*, default value: ``('#', ';')``"
msgstr "*comment_prefixes*，默认值: ``('#', ';')``"

#: ../../library/configparser.rst:537
msgid "*inline_comment_prefixes*, default value: ``None``"
msgstr "*inline_comment_prefixes*，默认值: ``None``"

#: ../../library/configparser.rst:539
msgid ""
"Comment prefixes are strings that indicate the start of a valid comment "
"within a config file. *comment_prefixes* are used only on otherwise empty "
"lines (optionally indented) whereas *inline_comment_prefixes* can be used "
"after every valid value (e.g. section names, options and empty lines as "
"well).  By default inline comments are disabled and ``'#'`` and ``';'`` are "
"used as prefixes for whole line comments."
msgstr ""
"注释前缀是配置文件中用于标示一条有效注释的开头的字符串。 *comment_prefixes* 仅用在被视为空白的行（可以缩进）之前而 "
"*inline_comment_prefixes* 可用在每个有效值之后（例如小节名称、选项以及空白的行）。 默认情况下禁用行内注释，并且 "
"``'#'`` 和 ``';'`` 都被用作完整行注释的前缀。"

#: ../../library/configparser.rst:546
msgid ""
"In previous versions of :mod:`configparser` behaviour matched "
"``comment_prefixes=('#',';')`` and ``inline_comment_prefixes=(';',)``."
msgstr ""
"在之前的 :mod:`configparser` 版本中行为匹配 ``comment_prefixes=('#',';')`` 和 "
"``inline_comment_prefixes=(';',)``。"

#: ../../library/configparser.rst:550
msgid ""
"Please note that config parsers don't support escaping of comment prefixes "
"so using *inline_comment_prefixes* may prevent users from specifying option "
"values with characters used as comment prefixes.  When in doubt, avoid "
"setting *inline_comment_prefixes*.  In any circumstances, the only way of "
"storing comment prefix characters at the beginning of a line in multiline "
"values is to interpolate the prefix, for example::"
msgstr ""
"请注意配置解析器不支持对注释前缀的转义，因此使用 *inline_comment_prefixes* 可能妨碍用户将被用作注释前缀的字符指定为可选值。 "
"当有疑问时，请避免设置 *inline_comment_prefixes*。 "
"在许多情况下，在多行值的一行开头存储注释前缀字符的唯一方式是进行前缀插值，例如::"

#: ../../library/configparser.rst:596
msgid "*strict*, default value: ``True``"
msgstr "*strict*，默认值: ``True``"

#: ../../library/configparser.rst:598
msgid ""
"When set to ``True``, the parser will not allow for any section or option "
"duplicates while reading from a single source (using :meth:`read_file`, "
":meth:`read_string` or :meth:`read_dict`).  It is recommended to use strict "
"parsers in new applications."
msgstr ""
"当设为 ``True`` 时，解析器在从单一源读取 (使用 :meth:`read_file`, :meth:`read_string` 或 "
":meth:`read_dict`) 期间将不允许任何小节或选项出现重复。 推荐在新的应用中使用严格解析器。"

#: ../../library/configparser.rst:603
msgid ""
"In previous versions of :mod:`configparser` behaviour matched "
"``strict=False``."
msgstr "在之前的 :mod:`configparser` 版本中行为匹配 ``strict=False``。"

#: ../../library/configparser.rst:607
msgid "*empty_lines_in_values*, default value: ``True``"
msgstr "*empty_lines_in_values*，默认值: ``True``"

#: ../../library/configparser.rst:609
msgid ""
"In config parsers, values can span multiple lines as long as they are "
"indented more than the key that holds them.  By default parsers also let "
"empty lines to be parts of values.  At the same time, keys can be "
"arbitrarily indented themselves to improve readability.  In consequence, "
"when configuration files get big and complex, it is easy for the user to "
"lose track of the file structure.  Take for instance:"
msgstr ""
"在配置解析器中，值可以包含多行，只要它们的缩进级别低于它们所对应的键。 默认情况下解析器还会将空行视为值的一部分。 "
"于此同时，键本身也可以任意缩进以提升可读性。 因此，当配置文件变得非常庞大而复杂时，用户很容易失去对文件结构的掌控。 例如:"

#: ../../library/configparser.rst:624
msgid ""
"This can be especially problematic for the user to see if she's using a "
"proportional font to edit the file.  That is why when your application does "
"not need values with empty lines, you should consider disallowing them.  "
"This will make empty lines split keys every time.  In the example above, it "
"would produce two keys, ``key`` and ``this``."
msgstr ""
"在用户查看时这可能会特别有问题，如果她是使用比例字体来编辑文件的话。 这就是为什么当你的应用不需要带有空行的值时，你应该考虑禁用它们。 "
"这将使得空行每次都会作为键之间的分隔。 在上面的示例中，空行产生了两个键，``key`` 和 ``this``。"

#: ../../library/configparser.rst:630
msgid ""
"*default_section*, default value: ``configparser.DEFAULTSECT`` (that is: "
"``\"DEFAULT\"``)"
msgstr "*default_section*，默认值: ``configparser.DEFAULTSECT`` (即: ``\"DEFAULT\"``)"

#: ../../library/configparser.rst:633
msgid ""
"The convention of allowing a special section of default values for other "
"sections or interpolation purposes is a powerful concept of this library, "
"letting users create complex declarative configurations.  This section is "
"normally called ``\"DEFAULT\"`` but this can be customized to point to any "
"other valid section name.  Some typical values include: ``\"general\"`` or "
"``\"common\"``.  The name provided is used for recognizing default sections "
"when reading from any source and is used when writing configuration back to "
"a file.  Its current value can be retrieved using the "
"``parser_instance.default_section`` attribute and may be modified at runtime"
" (i.e. to convert files from one format to another)."
msgstr ""
"允许设置一个保存默认值的特殊节在其他节或插值等目的中使用的惯例是这个库所拥有的一个强大概念，使得用户能够创建复杂的声明性配置。 这种特殊节通常称为 "
"``\"DEFAULT\"`` 但也可以被定制为指向任何其他有效的节名称。 一些典型的值包括: ``\"general\"`` 或 "
"``\"common\"``。 所提供的名称在从任意节读取的时候被用于识别默认的节，而且也会在将配置写回文件时被使用。 它的当前值可以使用 "
"``parser_instance.default_section`` 属性来获取，并且可以在运行时被修改（即将文件从一种格式转换为另一种格式）。"

#: ../../library/configparser.rst:644
msgid "*interpolation*, default value: ``configparser.BasicInterpolation``"
msgstr "*interpolation*，默认值: ``configparser.BasicInterpolation``"

#: ../../library/configparser.rst:646
msgid ""
"Interpolation behaviour may be customized by providing a custom handler "
"through the *interpolation* argument. ``None`` can be used to turn off "
"interpolation completely, ``ExtendedInterpolation()`` provides a more "
"advanced variant inspired by ``zc.buildout``.  More on the subject in the "
"`dedicated documentation section <#interpolation-of-values>`_. "
":class:`RawConfigParser` has a default value of ``None``."
msgstr ""
"插值行为可以用通过提供 *interpolation* 参数提供自定义处理程序的方式来定制。 ``None`` "
"可用来完全禁用插值，``ExtendedInterpolation()`` 提供了一种更高级的变体形式，它的设计受到了 ``zc.buildout`` "
"的启发。 有关该主题的更多信息请参见 `专门的文档章节 <#interpolation-of-values>`_。 "
":class:`RawConfigParser` 具有默认的值 ``None``。"

#: ../../library/configparser.rst:653
msgid "*converters*, default value: not set"
msgstr "*converters*，默认值: 不设置"

#: ../../library/configparser.rst:655
msgid ""
"Config parsers provide option value getters that perform type conversion.  "
"By default :meth:`~ConfigParser.getint`, :meth:`~ConfigParser.getfloat`, and"
" :meth:`~ConfigParser.getboolean` are implemented.  Should other getters be "
"desirable, users may define them in a subclass or pass a dictionary where "
"each key is a name of the converter and each value is a callable "
"implementing said conversion.  For instance, passing ``{'decimal': "
"decimal.Decimal}`` would add :meth:`getdecimal` on both the parser object "
"and all section proxies.  In other words, it will be possible to write both "
"``parser_instance.getdecimal('section', 'key', fallback=0)`` and "
"``parser_instance['section'].getdecimal('key', 0)``."
msgstr ""
"配置解析器提供了可选的值获取方法用来执行类型转换。 默认实现包括 :meth:`~ConfigParser.getint`, "
":meth:`~ConfigParser.getfloat` 以及 :meth:`~ConfigParser.getboolean`。 "
"如果还需要其他获取方法，用户可以在子类中定义它们，或者传入一个字典，其中每个键都是一个转换器的名称而每个值都是一个实现了特定转换的可调用对象。 "
"例如，传入 ``{'decimal': decimal.Decimal}`` 将对解释器对象和所有节代理添加 :meth:`getdecimal`。 "
"换句话说，可以同时编写 ``parser_instance.getdecimal('section', 'key', fallback=0)`` 和 "
"``parser_instance['section'].getdecimal('key', 0)``。"

#: ../../library/configparser.rst:666
msgid ""
"If the converter needs to access the state of the parser, it can be "
"implemented as a method on a config parser subclass.  If the name of this "
"method starts with ``get``, it will be available on all section proxies, in "
"the dict-compatible form (see the ``getdecimal()`` example above)."
msgstr ""
"如果转换器需要访问解析器的状态，可以在配置解析器子类上作为一个方法来实现。 如果该方法的名称是以 ``get`` "
"打头的，它将在所有节代理上以兼容字典的形式提供（参见上面的 ``getdecimal()`` 示例）。"

#: ../../library/configparser.rst:671
msgid ""
"More advanced customization may be achieved by overriding default values of "
"these parser attributes.  The defaults are defined on the classes, so they "
"may be overridden by subclasses or by attribute assignment."
msgstr "更多高级定制选项可通过重写这些解析器属性的默认值来达成。 默认值是在类中定义的，因此它们可以通过子类或属性赋值来重写。"

#: ../../library/configparser.rst:677
msgid ""
"By default when using :meth:`~ConfigParser.getboolean`, config parsers "
"consider the following values ``True``: ``'1'``, ``'yes'``, ``'true'``, "
"``'on'`` and the following values ``False``: ``'0'``, ``'no'``, ``'false'``,"
" ``'off'``.  You can override this by specifying a custom dictionary of "
"strings and their Boolean outcomes. For example:"
msgstr ""
"默认情况下当使用 :meth:`~ConfigParser.getboolean` 时，配置解析器会将下列值视为 ``True``: ``'1'``, "
"``'yes'``, ``'true'``, ``'on'`` 而将下列值视为 ``False``: ``'0'``, ``'no'``, "
"``'false'``, ``'off'``。 你可以通过指定一个自定义的字符串键及其对应的布尔值字典来覆盖此行为。 例如:"

#: ../../library/configparser.rst:695
msgid ""
"Other typical Boolean pairs include ``accept``/``reject`` or "
"``enabled``/``disabled``."
msgstr "其他典型的布尔值对包括 ``accept``/``reject`` 或 ``enabled``/``disabled``。"

#: ../../library/configparser.rst:701
msgid ""
"This method transforms option names on every read, get, or set operation.  "
"The default converts the name to lowercase.  This also means that when a "
"configuration file gets written, all keys will be lowercase.  Override this "
"method if that's unsuitable. For example:"
msgstr ""
"这个方法会转换每次 read, get, 或 set 操作的选项名称。 默认会将名称转换为小写形式。 "
"这也意味着当一个配置文件被写入时，所有键都将为小写形式。 如果此行为不合适则要重写此方法。 例如:"

#: ../../library/configparser.rst:731
msgid ""
"The optionxform function transforms option names to a canonical form. This "
"should be an idempotent function: if the name is already in canonical form, "
"it should be returned unchanged."
msgstr "optionxform 函数会将选项名称转换为规范形式。 这应该是一个幂等函数：如果名称已经为规范形式，则应不加修改地将其返回。"

#: ../../library/configparser.rst:738
msgid ""
"A compiled regular expression used to parse section headers.  The default "
"matches ``[section]`` to the name ``\"section\"``.  Whitespace is considered"
" part of the section name, thus ``[  larch  ]`` will be read as a section of"
" name ``\"  larch  \"``.  Override this attribute if that's unsuitable.  For"
" example:"
msgstr ""
"一个已编译正则表达式会被用来解析节标头。 默认将 ``[section]`` 匹配到名称 ``\"section\"``。 "
"空格会被视为节名称的一部分，因此 ``[  larch  ]`` 将被读取为一个名称为 ``\"  larch  \"`` 的节。 "
"如果此行为不合适则要覆盖此属性。 例如:"

#: ../../library/configparser.rst:766
msgid ""
"While ConfigParser objects also use an ``OPTCRE`` attribute for recognizing "
"option lines, it's not recommended to override it because that would "
"interfere with constructor options *allow_no_value* and *delimiters*."
msgstr ""
"虽然 ConfigParser 对象也使用 ``OPTCRE`` 属性来识别选项行，但并不推荐重写它，因为这会与构造器选项 "
"*allow_no_value* 和 *delimiters* 产生冲突。"

#: ../../library/configparser.rst:772
msgid "Legacy API Examples"
msgstr "旧式 API 示例"

#: ../../library/configparser.rst:774
msgid ""
"Mainly because of backwards compatibility concerns, :mod:`configparser` "
"provides also a legacy API with explicit ``get``/``set`` methods.  While "
"there are valid use cases for the methods outlined below, mapping protocol "
"access is preferred for new projects.  The legacy API is at times more "
"advanced, low-level and downright counterintuitive."
msgstr ""
"主要出于向下兼容性的考虑，:mod:`configparser` 还提供了一种采用显式 ``get``/``set`` 方法的旧式 API。 "
"虽然以下介绍的方法存在有效的用例，但对于新项目仍建议采用映射协议访问。 旧式 API 在多数时候都更复杂、更底层并且完全违反直觉。"

#: ../../library/configparser.rst:780
msgid "An example of writing to a configuration file::"
msgstr "一个写入配置文件的示例::"

#: ../../library/configparser.rst:803
msgid "An example of reading the configuration file again::"
msgstr "一个再次读取配置文件的示例::"

#: ../../library/configparser.rst:821
msgid "To get interpolation, use :class:`ConfigParser`::"
msgstr "要获取插值，请使用 :class:`ConfigParser`::"

#: ../../library/configparser.rst:854
msgid ""
"Default values are available in both types of ConfigParsers.  They are used "
"in interpolation if an option used is not defined elsewhere. ::"
msgstr "默认值在两种类型的 ConfigParser 中均可用。 它们将在当某个选项未在别处定义时被用于插值。 ::"

#: ../../library/configparser.rst:872
msgid "ConfigParser Objects"
msgstr "ConfigParser 对象"

#: ../../library/configparser.rst:876
msgid ""
"The main configuration parser.  When *defaults* is given, it is initialized "
"into the dictionary of intrinsic defaults.  When *dict_type* is given, it "
"will be used to create the dictionary objects for the list of sections, for "
"the options within a section, and for the default values."
msgstr ""
"主配置解析器。 当给定 *defaults* 时，它会被初始化为包含固有默认值的字典。 当给定 *dict_type* "
"时，它将被用来创建包含节、节中的选项以及默认值的字典。"

#: ../../library/configparser.rst:881
msgid ""
"When *delimiters* is given, it is used as the set of substrings that divide "
"keys from values.  When *comment_prefixes* is given, it will be used as the "
"set of substrings that prefix comments in otherwise empty lines. Comments "
"can be indented.  When *inline_comment_prefixes* is given, it will be used "
"as the set of substrings that prefix comments in non-empty lines."
msgstr ""
"当给定 *delimiters* 时，它会被用作分隔键与值的子字符串的集合。 当给定 *comment_prefixes* "
"时，它将被用作在否则为空行的注释的前缀子字符串的集合。 注释可以被缩进。 当给定 *inline_comment_prefixes* "
"时，它将被用作非空行的注释的前缀子字符串的集合。"

#: ../../library/configparser.rst:887
msgid ""
"When *strict* is ``True`` (the default), the parser won't allow for any "
"section or option duplicates while reading from a single source (file, "
"string or dictionary), raising :exc:`DuplicateSectionError` or "
":exc:`DuplicateOptionError`.  When *empty_lines_in_values* is ``False`` "
"(default: ``True``), each empty line marks the end of an option.  Otherwise,"
" internal empty lines of a multiline option are kept as part of the value. "
"When *allow_no_value* is ``True`` (default: ``False``), options without "
"values are accepted; the value held for these is ``None`` and they are "
"serialized without the trailing delimiter."
msgstr ""
"当 *strict* 为 ``True`` (默认值) 时，解析器在从单个源（文件、字符串或字典）读取时将不允许任何节或选项出现重复，否则会引发 "
":exc:`DuplicateSectionError` 或 :exc:`DuplicateOptionError`。 当 "
"*empty_lines_in_values* 为 ``False`` (默认值: ``True``) 时，每个空行均表示一个选项的结束。 "
"在其他情况下，一个多行选项内部的空行会被保留为值的一部分。 当 *allow_no_value* 为 ``True`` (默认值: ``False``)"
" 时，将接受没有值的选项；此种选项的值将为 ``None`` 并且它们会以不带末尾分隔符的形式被序列化。"

#: ../../library/configparser.rst:897
msgid ""
"When *default_section* is given, it specifies the name for the special "
"section holding default values for other sections and interpolation purposes"
" (normally named ``\"DEFAULT\"``).  This value can be retrieved and changed "
"on runtime using the ``default_section`` instance attribute."
msgstr ""
"当给定 *default_section* 时，它将指定存放其他节的默认值和用于插值的特殊节的名称 (通常命名为 ``\"DEFAULT\"``)。 "
"该值可通过使用 ``default_section`` 实例属性在运行时被读取或修改。"

#: ../../library/configparser.rst:902
msgid ""
"Interpolation behaviour may be customized by providing a custom handler "
"through the *interpolation* argument. ``None`` can be used to turn off "
"interpolation completely, ``ExtendedInterpolation()`` provides a more "
"advanced variant inspired by ``zc.buildout``.  More on the subject in the "
"`dedicated documentation section <#interpolation-of-values>`_."
msgstr ""
"插值行为可通过给出 *interpolation* 参数提供自定义处理程序的方式来定制。 ``None`` "
"可用来完全禁用插值，``ExtendedInterpolation()`` 提供了一种更高级的变体形式，它的设计受到了 ``zc.buildout`` "
"的启发。 有关该主题的更多信息请参见 `专门的文档章节 <#interpolation-of-values>`_。"

#: ../../library/configparser.rst:908
msgid ""
"All option names used in interpolation will be passed through the "
":meth:`optionxform` method just like any other option name reference.  For "
"example, using the default implementation of :meth:`optionxform` (which "
"converts option names to lower case), the values ``foo %(bar)s`` and ``foo "
"%(BAR)s`` are equivalent."
msgstr ""
"插值中使用的所有选项名称将像任何其他选项名称引用一样通过 :meth:`optionxform` 方法来传递。 例如，使用 "
":meth:`optionxform` 的默认实现（它会将选项名称转换为小写形式）时，值 ``foo %(bar)s`` 和 ``foo "
"%(BAR)s`` 是等价的。"

#: ../../library/configparser.rst:914
msgid ""
"When *converters* is given, it should be a dictionary where each key "
"represents the name of a type converter and each value is a callable "
"implementing the conversion from string to the desired datatype.  Every "
"converter gets its own corresponding :meth:`get*()` method on the parser "
"object and section proxies."
msgstr ""
"当给定 *converters* 时，它应当为一个字典，其中每个键代表一个类型转换器的名称而每个值则为实现从字符串到目标数据类型的转换的可调用对象。 "
"每个转换器会获得其在解析器对象和节代理上对应的 :meth:`get*()` 方法。"

#: ../../library/configparser.rst:920
msgid "The default *dict_type* is :class:`collections.OrderedDict`."
msgstr "默认的 *dict_type* 为 :class:`collections.OrderedDict`。"

#: ../../library/configparser.rst:923
msgid ""
"*allow_no_value*, *delimiters*, *comment_prefixes*, *strict*, "
"*empty_lines_in_values*, *default_section* and *interpolation* were added."
msgstr ""
"添加了 *allow_no_value*, *delimiters*, *comment_prefixes*, *strict*, "
"*empty_lines_in_values*, *default_section* 以及 *interpolation*。"

#: ../../library/configparser.rst:928
msgid "The *converters* argument was added."
msgstr "添加了 *converters* 参数。"

#: ../../library/configparser.rst:931
msgid ""
"The *defaults* argument is read with :meth:`read_dict()`, providing "
"consistent behavior across the parser: non-string keys and values are "
"implicitly converted to strings."
msgstr ""
"*defaults* 参数会通过 :meth:`read_dict()` "
"来读取，提供全解析器范围内一致的行为：非字符串类型的键和值会被隐式地转换为字符串。"

#: ../../library/configparser.rst:936 ../../library/configparser.rst:1214
msgid ""
"The default *dict_type* is :class:`dict`, since it now preserves insertion "
"order."
msgstr "默认的 *dict_type* 为 :class:`dict`，因为它现在会保留插入顺序。"

#: ../../library/configparser.rst:942
msgid "Return a dictionary containing the instance-wide defaults."
msgstr "返回包含实例范围内默认值的字典。"

#: ../../library/configparser.rst:947
msgid ""
"Return a list of the sections available; the *default section* is not "
"included in the list."
msgstr "返回可用节的列表；*default section* 不包括在该列表中。"

#: ../../library/configparser.rst:953
msgid ""
"Add a section named *section* to the instance.  If a section by the given "
"name already exists, :exc:`DuplicateSectionError` is raised.  If the "
"*default section* name is passed, :exc:`ValueError` is raised.  The name of "
"the section must be a string; if not, :exc:`TypeError` is raised."
msgstr ""
"向实例添加一个名为 *section* 的节。 如果给定名称的节已存在，将会引发 :exc:`DuplicateSectionError`。 如果传入了"
" *default section* 名称，则会引发 :exc:`ValueError`。 节名称必须为字符串；如果不是则会引发 "
":exc:`TypeError`。"

#: ../../library/configparser.rst:958
msgid "Non-string section names raise :exc:`TypeError`."
msgstr "非字符串的节名称将引发 :exc:`TypeError`。"

#: ../../library/configparser.rst:964
msgid ""
"Indicates whether the named *section* is present in the configuration. The "
"*default section* is not acknowledged."
msgstr "指明相应名称的 *section* 是否存在于配置中。 *default section* 不包含在内。"

#: ../../library/configparser.rst:970
msgid "Return a list of options available in the specified *section*."
msgstr "返回指定 *section* 中可用选项的列表。"

#: ../../library/configparser.rst:975
msgid ""
"If the given *section* exists, and contains the given *option*, return "
":const:`True`; otherwise return :const:`False`.  If the specified *section* "
"is :const:`None` or an empty string, DEFAULT is assumed."
msgstr ""
"如果给定的 *section* 存在并且包含给定的 *option* 则返回 :const:`True`；否则返回 :const:`False`。 "
"如果指定的 *section* 为 :const:`None` 或空字符串，则会使用 DEFAULT。"

#: ../../library/configparser.rst:982
msgid ""
"Attempt to read and parse an iterable of filenames, returning a list of "
"filenames which were successfully parsed."
msgstr "尝试读取并解析一个包含文件名的可迭代对象，返回一个被成功解析的文件名列表。"

#: ../../library/configparser.rst:985
msgid ""
"If *filenames* is a string, a :class:`bytes` object or a :term:`path-like "
"object`, it is treated as a single filename.  If a file named in *filenames*"
" cannot be opened, that file will be ignored.  This is designed so that you "
"can specify an iterable of potential configuration file locations (for "
"example, the current directory, the user's home directory, and some system-"
"wide directory), and all existing configuration files in the iterable will "
"be read."
msgstr ""
"如果 *filenames* 为字符串、:class:`bytes` 对象或 :term:`path-like "
"object`，它会被当作单个文件来处理。 如果 *filenames* 中名称对应的某个文件无法被打开，该文件将被忽略。 "
"这样的设计使得你可以指定包含多个潜在配置文件位置的可迭代对象（例如当前目录、用户家目录以及某个系统级目录），存在于该可迭代对象中的所有配置文件都将被读取。"

#: ../../library/configparser.rst:994
msgid ""
"If none of the named files exist, the :class:`ConfigParser` instance will "
"contain an empty dataset.  An application which requires initial values to "
"be loaded from a file should load the required file or files using "
":meth:`read_file` before calling :meth:`read` for any optional files::"
msgstr ""
"如果名称对应的文件全都不存在，则 :class:`ConfigParser` 实例将包含一个空数据集。 一个要求从文件加载初始值的应用应当在调用 "
":meth:`read` 来获取任何可选文件之前使用 :meth:`read_file` 来加载所要求的一个或多个文件::"

#: ../../library/configparser.rst:1007
msgid ""
"The *encoding* parameter.  Previously, all files were read using the default"
" encoding for :func:`open`."
msgstr "*encoding* 形参。 在之前的版本中，所有文件都将使用 :func:`open` 的默认编码格式来读取。"

#: ../../library/configparser.rst:1011
msgid "The *filenames* parameter accepts a :term:`path-like object`."
msgstr "*filenames* 形参接受一个 :term:`path-like object`。"

#: ../../library/configparser.rst:1014
msgid "The *filenames* parameter accepts a :class:`bytes` object."
msgstr "*filenames* 形参接受一个 :class:`bytes` 对象。"

#: ../../library/configparser.rst:1020
msgid ""
"Read and parse configuration data from *f* which must be an iterable "
"yielding Unicode strings (for example files opened in text mode)."
msgstr "从 *f* 读取并解析配置数据，它必须是一个产生 Unicode 字符串的可迭代对象（例如以文本模式打开的文件）。"

#: ../../library/configparser.rst:1023
msgid ""
"Optional argument *source* specifies the name of the file being read.  If "
"not given and *f* has a :attr:`name` attribute, that is used for *source*; "
"the default is ``'<???>'``."
msgstr ""
"可选参数 *source* 指定要读取的文件名称。 如果未给出并且 *f* 具有 :attr:`name` 属性，则该属性会被用作 "
"*source*；默认值为 ``'<???>'``。"

#: ../../library/configparser.rst:1027
msgid "Replaces :meth:`readfp`."
msgstr "替代 :meth:`readfp`。"

#: ../../library/configparser.rst:1032
msgid "Parse configuration data from a string."
msgstr "从字符串中解析配置数据。"

#: ../../library/configparser.rst:1034
msgid ""
"Optional argument *source* specifies a context-specific name of the string "
"passed.  If not given, ``'<string>'`` is used.  This should commonly be a "
"filesystem path or a URL."
msgstr ""
"可选参数 *source* 指定一个所传入字符串的上下文专属名称。 如果未给出，则会使用 ``'<string>'``。 这通常应为一个文件系统路径或 "
"URL。"

#: ../../library/configparser.rst:1043
msgid ""
"Load configuration from any object that provides a dict-like ``items()`` "
"method.  Keys are section names, values are dictionaries with keys and "
"values that should be present in the section.  If the used dictionary type "
"preserves order, sections and their keys will be added in order. Values are "
"automatically converted to strings."
msgstr ""
"从任意一个提供了类似于字典的 ``items()`` 方法的对象加载配置。 键为节名称，值为包含节中所出现的键和值的字典。 "
"如果所用的字典类型会保留顺序，则节和其中的键将按顺序加入。 值会被自动转换为字符串。"

#: ../../library/configparser.rst:1049
msgid ""
"Optional argument *source* specifies a context-specific name of the "
"dictionary passed.  If not given, ``<dict>`` is used."
msgstr "可选参数 *source* 指定一个所传入字典的上下文专属名称。 如果未给出，则会使用 ``<dict>``。"

#: ../../library/configparser.rst:1052
msgid "This method can be used to copy state between parsers."
msgstr "此方法可被用于在解析器之间拷贝状态。"

#: ../../library/configparser.rst:1059
msgid ""
"Get an *option* value for the named *section*.  If *vars* is provided, it "
"must be a dictionary.  The *option* is looked up in *vars* (if provided), "
"*section*, and in *DEFAULTSECT* in that order.  If the key is not found and "
"*fallback* is provided, it is used as a fallback value.  ``None`` can be "
"provided as a *fallback* value."
msgstr ""
"获取指定名称的 *section* 的一个 *option* 的值。 如果提供了 *vars*，则它必须为一个字典。 *option* 的查找顺序为 "
"*vars*（如果有提供）、*section* 以及 *DEFAULTSECT*。 如果未找到该键并且提供了 *fallback*，则它会被用作回退值。"
" 可以提供 ``None`` 作为 *fallback* 值。"

#: ../../library/configparser.rst:1065
msgid ""
"All the ``'%'`` interpolations are expanded in the return values, unless the"
" *raw* argument is true.  Values for interpolation keys are looked up in the"
" same manner as the option."
msgstr "所有 ``'%'`` 插值会在返回值中被展开，除非 *raw* 参数为真值。 插值键所使用的值会按与选项相同的方式来查找。"

#: ../../library/configparser.rst:1069
msgid ""
"Arguments *raw*, *vars* and *fallback* are keyword only to protect users "
"from trying to use the third argument as the *fallback* fallback (especially"
" when using the mapping protocol)."
msgstr ""
"*raw*, *vars* 和 *fallback* 都是仅限关键字参数，以防止用户试图使用第三个参数作业为 *fallback* "
"回退值（特别是在使用映射 协议的时候）。"

#: ../../library/configparser.rst:1077
msgid ""
"A convenience method which coerces the *option* in the specified *section* "
"to an integer.  See :meth:`get` for explanation of *raw*, *vars* and "
"*fallback*."
msgstr ""
"将在指定 *section* 中的 *option* 强制转换为整数的便捷方法。 参见 :meth:`get` 获取对于 *raw*, *vars* 和"
" *fallback* 的解释。"

#: ../../library/configparser.rst:1084
msgid ""
"A convenience method which coerces the *option* in the specified *section* "
"to a floating point number.  See :meth:`get` for explanation of *raw*, "
"*vars* and *fallback*."
msgstr ""
"将在指定 *section* 中的 *option* 强制转换为浮点数的便捷方法。 参见 :meth:`get` 获取对于 *raw*, *vars* "
"和 *fallback* 的解释。"

#: ../../library/configparser.rst:1091
msgid ""
"A convenience method which coerces the *option* in the specified *section* "
"to a Boolean value.  Note that the accepted values for the option are "
"``'1'``, ``'yes'``, ``'true'``, and ``'on'``, which cause this method to "
"return ``True``, and ``'0'``, ``'no'``, ``'false'``, and ``'off'``, which "
"cause it to return ``False``.  These string values are checked in a case-"
"insensitive manner.  Any other value will cause it to raise "
":exc:`ValueError`.  See :meth:`get` for explanation of *raw*, *vars* and "
"*fallback*."
msgstr ""
"将在指定 *section* 中的 *option* 强制转换为布尔值的便捷方法。 请注意选项所接受的值为 ``'1'``, ``'yes'``, "
"``'true'`` 和 ``'on'``，它们会使得此方法返回 ``True``，以及 ``'0'``, ``'no'``, ``'false'`` "
"和 ``'off'``，它们会使得此方法返回 ``False``。 这些字符串值会以对大小写不敏感的方式被检测。 任何其他值都将导致引发 "
":exc:`ValueError`。 参见 :meth:`get` 获取对于 *raw*, *vars* 和 *fallback* 的解释。"

#: ../../library/configparser.rst:1104
msgid ""
"When *section* is not given, return a list of *section_name*, "
"*section_proxy* pairs, including DEFAULTSECT."
msgstr ""
"当未给出 *section* 时，将返回由 *section_name*, *section_proxy* 对组成的列表，包括 DEFAULTSECT。"

#: ../../library/configparser.rst:1107
msgid ""
"Otherwise, return a list of *name*, *value* pairs for the options in the "
"given *section*.  Optional arguments have the same meaning as for the "
":meth:`get` method."
msgstr ""
"在其他情况下，将返回给定的 *section* 中的 option 的 *name*, *value* 对组成的列表。 可选参数具有与 "
":meth:`get` 方法的参数相同的含义。"

#: ../../library/configparser.rst:1111
msgid ""
"Items present in *vars* no longer appear in the result.  The previous "
"behaviour mixed actual parser options with variables provided for "
"interpolation."
msgstr "*vars* 中的条目将不在结果中出现。 之前的行为混淆了实际的解析器选项和为插值提供的变量。"

#: ../../library/configparser.rst:1119
msgid ""
"If the given section exists, set the given option to the specified value; "
"otherwise raise :exc:`NoSectionError`.  *option* and *value* must be "
"strings; if not, :exc:`TypeError` is raised."
msgstr ""
"如果给定的节存在，则将所给出的选项设为指定的值；在其他情况下将引发 :exc:`NoSectionError`。 *option* 和 *value* "
"必须为字符串；如果不是则将引发 :exc:`TypeError`。"

#: ../../library/configparser.rst:1126
msgid ""
"Write a representation of the configuration to the specified :term:`file "
"object`, which must be opened in text mode (accepting strings).  This "
"representation can be parsed by a future :meth:`read` call.  If "
"*space_around_delimiters* is true, delimiters between keys and values are "
"surrounded by spaces."
msgstr ""
"将配置的表示形式写入指定的 :term:`file object`，该对象必须以文本模式打开（接受字符串）。 此表示形式可由将来的 "
":meth:`read` 调用进行解析。 如果 *space_around_delimiters* 为真值，键和值之前的分隔符两边将加上空格。"

#: ../../library/configparser.rst:1135
msgid ""
"Remove the specified *option* from the specified *section*.  If the section "
"does not exist, raise :exc:`NoSectionError`.  If the option existed to be "
"removed, return :const:`True`; otherwise return :const:`False`."
msgstr ""
"将指定的 *option* 从指定的 *section* 中移除。 如果指定的节不存在则会引发 :exc:`NoSectionError`。 "
"如果要移除的选项存在则返回 :const:`True`；在其他情况下将返回 :const:`False`。"

#: ../../library/configparser.rst:1143
msgid ""
"Remove the specified *section* from the configuration.  If the section in "
"fact existed, return ``True``.  Otherwise return ``False``."
msgstr "从配置中移除指定的 *section*。 如果指定的节确实存在则返回 ``True``。 在其他情况下将返回 ``False``。"

#: ../../library/configparser.rst:1149
msgid ""
"Transforms the option name *option* as found in an input file or as passed "
"in by client code to the form that should be used in the internal "
"structures.  The default implementation returns a lower-case version of "
"*option*; subclasses may override this or client code can set an attribute "
"of this name on instances to affect this behavior."
msgstr ""
"将选项名 *option* 转换为输入文件中的形式或客户端代码所传入的应当在内部结构中使用的形式。 默认实现将返回 *option* "
"的小写形式版本；子类可以重写此行为，或者客户端代码也可以在实例上设置一个具有此名称的属性来影响此行为。"

#: ../../library/configparser.rst:1155
msgid ""
"You don't need to subclass the parser to use this method, you can also set "
"it on an instance, to a function that takes a string argument and returns a "
"string.  Setting it to ``str``, for example, would make option names case "
"sensitive::"
msgstr ""
"你不需要子类化解析器来使用此方法，你也可以在一个实例上设置它，或使用一个接受字符串参数并返回字符串的函数。 例如将它设为 ``str`` "
"将使得选项名称变得大小写敏感::"

#: ../../library/configparser.rst:1163
msgid ""
"Note that when reading configuration files, whitespace around the option "
"names is stripped before :meth:`optionxform` is called."
msgstr "请注意当读取配置文件时，选项名称两边的空格将在调用 :meth:`optionxform` 之前被去除。"

#: ../../library/configparser.rst:1169
msgid "Use :meth:`read_file` instead."
msgstr "使用 :meth:`read_file` 来代替。"

#: ../../library/configparser.rst:1172
msgid ""
":meth:`readfp` now iterates on *fp* instead of calling ``fp.readline()``."
msgstr ":meth:`readfp` 现在将在 *fp* 上执行迭代而不是调用 ``fp.readline()``。"

#: ../../library/configparser.rst:1175
msgid ""
"For existing code calling :meth:`readfp` with arguments which don't support "
"iteration, the following generator may be used as a wrapper around the file-"
"like object::"
msgstr "对于调用 :meth:`readfp` 时传入不支持迭代的参数的现有代码，可以在文件类对象外使用以下生成器作为包装器::"

#: ../../library/configparser.rst:1185
msgid ""
"Instead of ``parser.readfp(fp)`` use "
"``parser.read_file(readline_generator(fp))``."
msgstr ""
"不再使用 ``parser.readfp(fp)`` 而是改用 "
"``parser.read_file(readline_generator(fp))``。"

#: ../../library/configparser.rst:1191
msgid ""
"The maximum depth for recursive interpolation for :meth:`get` when the *raw*"
" parameter is false.  This is relevant only when the default *interpolation*"
" is used."
msgstr ""
"当 *raw* 形参为假值时 :meth:`get` 所采用的递归插值的最大深度。 这只在使用默认的 *interpolation* 时会起作用。"

#: ../../library/configparser.rst:1199
msgid "RawConfigParser Objects"
msgstr "RawConfigParser 对象"

#: ../../library/configparser.rst:1209
msgid ""
"Legacy variant of the :class:`ConfigParser`.  It has interpolation disabled "
"by default and allows for non-string section names, option names, and values"
" via its unsafe ``add_section`` and ``set`` methods, as well as the legacy "
"``defaults=`` keyword argument handling."
msgstr ""
"旧式 :class:`ConfigParser`。 它默认禁用插值并且允许通过不安全的 ``add_section`` 和 ``set`` 方法以及旧式"
" ``defaults=`` 关键字参数处理来设置非字符串的节名、选项名和值。"

#: ../../library/configparser.rst:1219
msgid ""
"Consider using :class:`ConfigParser` instead which checks types of the "
"values to be stored internally.  If you don't want interpolation, you can "
"use ``ConfigParser(interpolation=None)``."
msgstr ""
"考虑改用 :class:`ConfigParser`，它会检查内部保存的值的类型。 如果你不想要插值，你可以使用 "
"``ConfigParser(interpolation=None)``。"

#: ../../library/configparser.rst:1226
msgid ""
"Add a section named *section* to the instance.  If a section by the given "
"name already exists, :exc:`DuplicateSectionError` is raised.  If the "
"*default section* name is passed, :exc:`ValueError` is raised."
msgstr ""
"向实例添加一个名为 *section* 的节。 如果给定名称的节已存在，将会引发 :exc:`DuplicateSectionError`。 如果传入了"
" *default section* 名称，则会引发 :exc:`ValueError`。"

#: ../../library/configparser.rst:1230
msgid ""
"Type of *section* is not checked which lets users create non-string named "
"sections.  This behaviour is unsupported and may cause internal errors."
msgstr "不检查 *section* 以允许用户创建以非字符串命名的节。 此行为已不受支持并可能导致内部错误。"

#: ../../library/configparser.rst:1236
msgid ""
"If the given section exists, set the given option to the specified value; "
"otherwise raise :exc:`NoSectionError`.  While it is possible to use "
":class:`RawConfigParser` (or :class:`ConfigParser` with *raw* parameters set"
" to true) for *internal* storage of non-string values, full functionality "
"(including interpolation and output to files) can only be achieved using "
"string values."
msgstr ""
"如果给定的节存在，则将给定的选项设为指定的值；在其他情况下将引发 :exc:`NoSectionError`。 虽然可能使用 "
":class:`RawConfigParser` (或使用 :class:`ConfigParser` 并将 *raw* 形参设为真值) "
"以便实现非字符串值的 *internal* 存储，但是完整功能（包括插值和输出到文件）只能使用字符串值来实现。"

#: ../../library/configparser.rst:1243
msgid ""
"This method lets users assign non-string values to keys internally.  This "
"behaviour is unsupported and will cause errors when attempting to write to a"
" file or get it in non-raw mode.  **Use the mapping protocol API** which "
"does not allow such assignments to take place."
msgstr ""
"此方法允许用户在内部将非字符串值赋给键。 此行为已不受支持并会在尝试写入到文件或在非原始模式下获取数据时导致错误。 **请使用映射协议 "
"API**，它不允许出现这样的赋值。"

#: ../../library/configparser.rst:1250
msgid "Exceptions"
msgstr "异常"

#: ../../library/configparser.rst:1254
msgid "Base class for all other :mod:`configparser` exceptions."
msgstr "所有其他 :mod:`configparser` 异常的基类。"

#: ../../library/configparser.rst:1259
msgid "Exception raised when a specified section is not found."
msgstr "当找不到指定节时引发的异常。"

#: ../../library/configparser.rst:1264
msgid ""
"Exception raised if :meth:`add_section` is called with the name of a section"
" that is already present or in strict parsers when a section if found more "
"than once in a single input file, string or dictionary."
msgstr ""
"当调用 :meth:`add_section` 时传入已存在的节名称，或者在严格解析器中当单个输入文件、字符串或字典内出现重复的节时引发的异常。"

#: ../../library/configparser.rst:1268
msgid ""
"Optional ``source`` and ``lineno`` attributes and arguments to "
":meth:`__init__` were added."
msgstr "将可选的 ``source`` 和 ``lineno`` 属性和参数添加到 :meth:`__init__`。"

#: ../../library/configparser.rst:1275
msgid ""
"Exception raised by strict parsers if a single option appears twice during "
"reading from a single file, string or dictionary. This catches misspellings "
"and case sensitivity-related errors, e.g. a dictionary may have two keys "
"representing the same case-insensitive configuration key."
msgstr ""
"当单个选项在从单个文件、字符串或字典读取时出现两次时引发的异常。 "
"这会捕获拼写错误和大小写敏感相关的错误，例如一个字典可能包含两个键分别代表同一个大小写不敏感的配置键。"

#: ../../library/configparser.rst:1283
msgid ""
"Exception raised when a specified option is not found in the specified "
"section."
msgstr "当指定的选项未在指定的节中被找到时引发的异常。"

#: ../../library/configparser.rst:1289
msgid ""
"Base class for exceptions raised when problems occur performing string "
"interpolation."
msgstr "当执行字符串插值发生问题时所引发的异常的基类。"

#: ../../library/configparser.rst:1295
msgid ""
"Exception raised when string interpolation cannot be completed because the "
"number of iterations exceeds :const:`MAX_INTERPOLATION_DEPTH`.  Subclass of "
":exc:`InterpolationError`."
msgstr ""
"当字符串插值由于迭代次数超出 :const:`MAX_INTERPOLATION_DEPTH` 而无法完成所引发的异常。 为 "
":exc:`InterpolationError` 的子类。"

#: ../../library/configparser.rst:1302
msgid ""
"Exception raised when an option referenced from a value does not exist. "
"Subclass of :exc:`InterpolationError`."
msgstr "当从某个值引用的选项并不存在时引发的异常。 为 :exc:`InterpolationError` 的子类。"

#: ../../library/configparser.rst:1308
msgid ""
"Exception raised when the source text into which substitutions are made does"
" not conform to the required syntax.  Subclass of :exc:`InterpolationError`."
msgstr "当将要执行替换的源文本不符合要求的语法时引发的异常。 为 :exc:`InterpolationError` 的子类。"

#: ../../library/configparser.rst:1314
msgid ""
"Exception raised when attempting to parse a file which has no section "
"headers."
msgstr "当尝试解析一个不带节标头的文件时引发的异常。"

#: ../../library/configparser.rst:1320
msgid "Exception raised when errors occur attempting to parse a file."
msgstr "当尝试解析一个文件而发生错误时引发的异常。"

#: ../../library/configparser.rst:1322
msgid ""
"The ``filename`` attribute and :meth:`__init__` argument were renamed to "
"``source`` for consistency."
msgstr "``filename`` 属性和 :meth:`__init__` 参数被重命名为 ``source`` 以保持一致性。"

#: ../../library/configparser.rst:1328
msgid "Footnotes"
msgstr "备注"

#: ../../library/configparser.rst:1329
msgid ""
"Config parsers allow for heavy customization.  If you are interested in "
"changing the behaviour outlined by the footnote reference, consult the "
"`Customizing Parser Behaviour`_ section."
msgstr ""
"配置解析器允许重度定制。 如果你有兴趣改变脚注说明中所介绍的行为，请参阅 `Customizing Parser Behaviour`_ 一节。"