string.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-01-16 00:13+0000\n"
"PO-Revision-Date: 2024-03-10 15:57+0800\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\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"
"X-Generator: Poedit 3.4.2\n"

#: ../../library/string.rst:2
msgid ":mod:`!string` --- Common string operations"
msgstr ":mod:`!string` --- 常見的字串操作"

#: ../../library/string.rst:7
msgid "**Source code:** :source:`Lib/string.py`"
msgstr "**原始碼：**\\ :source:`Lib/string.py`"

#: ../../library/string.rst:14
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"

#: ../../library/string.rst:16
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"

#: ../../library/string.rst:19
msgid "String constants"
msgstr "字串常數"

#: ../../library/string.rst:21
msgid "The constants defined in this module are:"
msgstr "此模組中定義的常數為："

#: ../../library/string.rst:26
msgid ""
"The concatenation of the :const:`ascii_lowercase` "
"and :const:`ascii_uppercase` constants described below.  This value is not "
"locale-dependent."
msgstr ""
"下文描述的 :const:`ascii_lowercase` 和 :const:`ascii_uppercase` 常數的串接，"
"該值不依賴於區域設定。"

#: ../../library/string.rst:32
msgid ""
"The lowercase letters ``'abcdefghijklmnopqrstuvwxyz'``.  This value is not "
"locale-dependent and will not change."
msgstr ""
"小寫字母 ``'abcdefghijklmnopqrstuvwxyz'``。該值與地區設定無關且不會改變。"

#: ../../library/string.rst:38
msgid ""
"The uppercase letters ``'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``.  This value is not "
"locale-dependent and will not change."
msgstr ""
"大寫字母 ``'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``。此值與地區設定無關且不會改變。"

#: ../../library/string.rst:44
msgid "The string ``'0123456789'``."
msgstr "字串 ``'0123456789'``。"

#: ../../library/string.rst:49
msgid "The string ``'0123456789abcdefABCDEF'``."
msgstr "字串 ``'0123456789abcdefABCDEF'``。"

#: ../../library/string.rst:54
msgid "The string ``'01234567'``."
msgstr "字串 ``'01234567'``。"

#: ../../library/string.rst:59
msgid ""
"String of ASCII characters which are considered punctuation characters in "
"the ``C`` locale: ``!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~``."
msgstr ""
"在 ``C`` 語言中被視為標點符號的 ASCII 字元的字串：``!\"#$%&'()*+,-./:;<=>?"
"@[\\]^_`{|}~``。"

#: ../../library/string.rst:65
msgid ""
"String of ASCII characters which are considered printable by Python. This is "
"a combination "
"of :const:`digits`, :const:`ascii_letters`, :const:`punctuation`, "
"and :const:`whitespace`."
msgstr ""
"ASCII 字元的字串被 Python 是為可被列印輸出的。這"
"是 :const:`digits`、:const:`ascii_letters`、:const:`punctuation` "
"和 :const:`whitespace` 的組合。"

#: ../../library/string.rst:71
msgid ""
"By design, :meth:`string.printable.isprintable() <str.isprintable>` "
"returns :const:`False`. In particular, ``string.printable`` is not printable "
"in the POSIX sense (see :manpage:`LC_CTYPE <locale(5)>`)."
msgstr ""

#: ../../library/string.rst:78
msgid ""
"A string containing all ASCII characters that are considered whitespace. "
"This includes the characters space, tab, linefeed, return, formfeed, and "
"vertical tab."
msgstr ""
"包含所有 ASCII 字元的字串都視為空白字元 (whitespace)。 包含空格 (space)、製表"
"符號 (tab)、換行符號 (linefeed)、return、換頁符號 (formfeed) 和垂直製表符號 "
"(vertical tab) 這些字元。"

#: ../../library/string.rst:86
msgid "Custom String Formatting"
msgstr "自訂字串格式"

#: ../../library/string.rst:88
msgid ""
"The built-in string class provides the ability to do complex variable "
"substitutions and value formatting via the :meth:`~str.format` method "
"described in :pep:`3101`.  The :class:`Formatter` class in the :mod:`string` "
"module allows you to create and customize your own string formatting "
"behaviors using the same implementation as the built-in :meth:`~str.format` "
"method."
msgstr ""
"透過 :pep:`3101` 中描述的 :meth:`~str.format` 方法，內建字串類別提供了進行複"
"雜變數替換和數值格式化的能力。:mod:`string` 模組中的 :class:`Formatter` 類別"
"模組可讓你使用與內建 :meth:`~str.format` 方法相同的實作來建立和自訂你自己的字"
"串格式化行為。"

#: ../../library/string.rst:97
msgid "The :class:`Formatter` class has the following public methods:"
msgstr ":class:`Formatter` 類別有以下的公開方法："

#: ../../library/string.rst:101
msgid ""
"The primary API method.  It takes a format string and an arbitrary set of "
"positional and keyword arguments. It is just a wrapper that "
"calls :meth:`vformat`."
msgstr ""
"主要的 API 方法。它接收一個格式字串及一組任意的位置引數與關鍵字引數，是呼"
"叫 :meth:`vformat` 的包裝器 (wrapper)。"

#: ../../library/string.rst:105
msgid ""
"A format string argument is now :ref:`positional-only <positional-"
"only_parameter>`."
msgstr "現在格式字串引數是\\ :ref:`僅限位置參數 <positional-only_parameter>`。"

#: ../../library/string.rst:111
msgid ""
"This function does the actual work of formatting.  It is exposed as a "
"separate function for cases where you want to pass in a predefined "
"dictionary of arguments, rather than unpacking and repacking the dictionary "
"as individual arguments using the ``*args`` and ``**kwargs`` "
"syntax.  :meth:`vformat` does the work of breaking up the format string into "
"character data and replacement fields.  It calls the various methods "
"described below."
msgstr ""

#: ../../library/string.rst:119
msgid ""
"In addition, the :class:`Formatter` defines a number of methods that are "
"intended to be replaced by subclasses:"
msgstr ""

#: ../../library/string.rst:124
msgid ""
"Loop over the format_string and return an iterable of tuples "
"(*literal_text*, *field_name*, *format_spec*, *conversion*).  This is used "
"by :meth:`vformat` to break the string into either literal text, or "
"replacement fields."
msgstr ""
"將 format_string 放入迴圈，並回傳一個可疊代物件，其元素為 (*literal_text*, "
"*field_name*, *format_spec*, *conversion*)。這會被 :meth:`vformat` 用於將字串"
"裁切為字面文本或替換欄位。"

#: ../../library/string.rst:129
msgid ""
"The values in the tuple conceptually represent a span of literal text "
"followed by a single replacement field.  If there is no literal text (which "
"can happen if two replacement fields occur consecutively), then "
"*literal_text* will be a zero-length string.  If there is no replacement "
"field, then the values of *field_name*, *format_spec* and *conversion* will "
"be ``None``."
msgstr ""

#: ../../library/string.rst:138
msgid ""
"Given *field_name* as returned by :meth:`parse` (see above), convert it to "
"an object to be formatted.  Returns a tuple (obj, used_key).  The default "
"version takes strings of the form defined in :pep:`3101`, such as \"0[name]"
"\" or \"label.title\".  *args* and *kwargs* are as passed in "
"to :meth:`vformat`.  The return value *used_key* has the same meaning as the "
"*key* parameter to :meth:`get_value`."
msgstr ""

#: ../../library/string.rst:147
msgid ""
"Retrieve a given field value.  The *key* argument will be either an integer "
"or a string.  If it is an integer, it represents the index of the positional "
"argument in *args*; if it is a string, then it represents a named argument "
"in *kwargs*."
msgstr ""

#: ../../library/string.rst:152
msgid ""
"The *args* parameter is set to the list of positional arguments "
"to :meth:`vformat`, and the *kwargs* parameter is set to the dictionary of "
"keyword arguments."
msgstr ""

#: ../../library/string.rst:156
msgid ""
"For compound field names, these functions are only called for the first "
"component of the field name; subsequent components are handled through "
"normal attribute and indexing operations."
msgstr ""

#: ../../library/string.rst:160
msgid ""
"So for example, the field expression '0.name' would cause :meth:`get_value` "
"to be called with a *key* argument of 0.  The ``name`` attribute will be "
"looked up after :meth:`get_value` returns by calling the built-"
"in :func:`getattr` function."
msgstr ""

#: ../../library/string.rst:165
msgid ""
"If the index or keyword refers to an item that does not exist, then "
"an :exc:`IndexError` or :exc:`KeyError` should be raised."
msgstr ""

#: ../../library/string.rst:170
msgid ""
"Implement checking for unused arguments if desired.  The arguments to this "
"function is the set of all argument keys that were actually referred to in "
"the format string (integers for positional arguments, and strings for named "
"arguments), and a reference to the *args* and *kwargs* that was passed to "
"vformat.  The set of unused args can be calculated from these "
"parameters.  :meth:`check_unused_args` is assumed to raise an exception if "
"the check fails."
msgstr ""

#: ../../library/string.rst:180
msgid ""
":meth:`format_field` simply calls the global :func:`format` built-in.  The "
"method is provided so that subclasses can override it."
msgstr ""

#: ../../library/string.rst:185
msgid ""
"Converts the value (returned by :meth:`get_field`) given a conversion type "
"(as in the tuple returned by the :meth:`parse` method).  The default version "
"understands 's' (str), 'r' (repr) and 'a' (ascii) conversion types."
msgstr ""

#: ../../library/string.rst:194
msgid "Format String Syntax"
msgstr "格式化文字語法"

#: ../../library/string.rst:196
msgid ""
"The :meth:`str.format` method and the :class:`Formatter` class share the "
"same syntax for format strings (although in the case of :class:`Formatter`, "
"subclasses can define their own format string syntax).  The syntax is "
"related to that of :ref:`formatted string literals <f-strings>`, but it is "
"less sophisticated and, in particular, does not support arbitrary "
"expressions."
msgstr ""

#: ../../library/string.rst:209
msgid ""
"Format strings contain \"replacement fields\" surrounded by curly braces ``{}"
"``. Anything that is not contained in braces is considered literal text, "
"which is copied unchanged to the output.  If you need to include a brace "
"character in the literal text, it can be escaped by doubling: ``{{`` and ``}}"
"``."
msgstr ""

#: ../../library/string.rst:214
msgid "The grammar for a replacement field is as follows:"
msgstr ""

#: ../../library/string.rst:226
msgid ""
"In less formal terms, the replacement field can start with a *field_name* "
"that specifies the object whose value is to be formatted and inserted into "
"the output instead of the replacement field. The *field_name* is optionally "
"followed by a  *conversion* field, which is preceded by an exclamation point "
"``'!'``, and a *format_spec*, which is preceded by a colon ``':'``.  These "
"specify a non-default format for the replacement value."
msgstr ""

#: ../../library/string.rst:233
msgid "See also the :ref:`formatspec` section."
msgstr "另請參閱 :ref:`formatspec` 部份。"

#: ../../library/string.rst:235
msgid ""
"The *field_name* itself begins with an *arg_name* that is either a number or "
"a keyword.  If it's a number, it refers to a positional argument, and if "
"it's a keyword, it refers to a named keyword argument. An *arg_name* is "
"treated as a number if a call to :meth:`str.isdecimal` on the string would "
"return true. If the numerical arg_names in a format string are 0, 1, 2, ... "
"in sequence, they can all be omitted (not just some) and the numbers 0, 1, "
"2, ... will be automatically inserted in that order. Because *arg_name* is "
"not quote-delimited, it is not possible to specify arbitrary dictionary keys "
"(e.g., the strings ``'10'`` or ``':-]'``) within a format string. The "
"*arg_name* can be followed by any number of index or attribute expressions. "
"An expression of the form ``'.name'`` selects the named attribute "
"using :func:`getattr`, while an expression of the form ``'[index]'`` does an "
"index lookup using :meth:`~object.__getitem__`."
msgstr ""

#: ../../library/string.rst:249
msgid ""
"The positional argument specifiers can be omitted for :meth:`str.format`, so "
"``'{} {}'.format(a, b)`` is equivalent to ``'{0} {1}'.format(a, b)``."
msgstr ""

#: ../../library/string.rst:253
msgid ""
"The positional argument specifiers can be omitted for :class:`Formatter`."
msgstr ""

#: ../../library/string.rst:256
msgid "Some simple format string examples::"
msgstr ""

#: ../../library/string.rst:258
msgid ""
"\"First, thou shalt count to {0}\"  # References first positional argument\n"
"\"Bring me a {}\"                   # Implicitly references the first "
"positional argument\n"
"\"From {} to {}\"                   # Same as \"From {0} to {1}\"\n"
"\"My quest is {name}\"              # References keyword argument 'name'\n"
"\"Weight in tons {0.weight}\"       # 'weight' attribute of first positional "
"arg\n"
"\"Units destroyed: {players[0]}\"   # First element of keyword argument "
"'players'."
msgstr ""

#: ../../library/string.rst:265
msgid ""
"The *conversion* field causes a type coercion before formatting.  Normally, "
"the job of formatting a value is done by the :meth:`~object.__format__` "
"method of the value itself.  However, in some cases it is desirable to force "
"a type to be formatted as a string, overriding its own definition of "
"formatting.  By converting the value to a string before "
"calling :meth:`~object.__format__`, the normal formatting logic is bypassed."
msgstr ""

#: ../../library/string.rst:272
msgid ""
"Three conversion flags are currently supported: ``'!s'`` which "
"calls :func:`str` on the value, ``'!r'`` which calls :func:`repr` and ``'!"
"a'`` which calls :func:`ascii`."
msgstr ""
"目前支援三種轉換旗標：``'!s'`` 會對該值呼叫 :func:`str`，``'!r'`` 會對該值呼"
"叫 :func:`repr`，而 ``'!a'`` 則會對該值呼叫 :func:`ascii`。"

#: ../../library/string.rst:276
msgid "Some examples::"
msgstr "一些範例： ::"

#: ../../library/string.rst:278
msgid ""
"\"Harold's a clever {0!s}\"        # Calls str() on the argument first\n"
"\"Bring out the holy {name!r}\"    # Calls repr() on the argument first\n"
"\"More {!a}\"                      # Calls ascii() on the argument first"
msgstr ""

#: ../../library/string.rst:282
msgid ""
"The *format_spec* field contains a specification of how the value should be "
"presented, including such details as field width, alignment, padding, "
"decimal precision and so on.  Each value type can define its own "
"\"formatting mini-language\" or interpretation of the *format_spec*."
msgstr ""
"*format_spec* 欄位描述了值的呈現規格，例如欄位寬度、對齊、填充 (padding)、小"
"數精度等細節資訊。每種值類型都可以定義自己的「格式化迷你語言 (formatting "
"mini-language)」或對 *format_spec* 的解釋。"

#: ../../library/string.rst:287
msgid ""
"Most built-in types support a common formatting mini-language, which is "
"described in the next section."
msgstr "大多數內建型別都支援常見的格式化迷你語言，下一節將會詳細說明。"

#: ../../library/string.rst:290
msgid ""
"A *format_spec* field can also include nested replacement fields within it. "
"These nested replacement fields may contain a field name, conversion flag "
"and format specification, but deeper nesting is not allowed.  The "
"replacement fields within the format_spec are substituted before the "
"*format_spec* string is interpreted. This allows the formatting of a value "
"to be dynamically specified."
msgstr ""
"*format_spec* 欄位還可以在其內部包含巢狀的替換欄位。這些巢狀的替換欄位可能包"
"含欄位名稱、轉換旗標、格式規格描述，但是不允許再更深層的巢狀結構。"
"format_spec 內部的替換欄位會在 *format_spec* 字串被直譯前被替換。這讓數值的格"
"式能夠被動態地指定。"

#: ../../library/string.rst:297
msgid "See the :ref:`formatexamples` section for some examples."
msgstr "範例請見 :ref:`formatexamples`。"

#: ../../library/string.rst:303
msgid "Format Specification Mini-Language"
msgstr "格式規格 (Format Specification) 迷你語言"

#: ../../library/string.rst:305
msgid ""
"\"Format specifications\" are used within replacement fields contained "
"within a format string to define how individual values are presented "
"(see :ref:`formatstrings` and :ref:`f-strings`). They can also be passed "
"directly to the built-in :func:`format` function.  Each formattable type may "
"define how the format specification is to be interpreted."
msgstr ""
"「格式規格」在格式字串 (format string) 中包含的替換欄位中使用，以定義各個值如"
"何被呈現（請參考 :ref:`formatstrings` 和 :ref:`f-strings`\\ ）。它們也能夠直"
"接傳遞給內建的 :func:`format` 函式。每個可格式化型別 (formattable type) 可以"
"定義格式規格如何被直譯。"

#: ../../library/string.rst:312
msgid ""
"Most built-in types implement the following options for format "
"specifications, although some of the formatting options are only supported "
"by the numeric types."
msgstr ""
"大部分內建型別為了格式規格實作了下列選項，不過有些選項只被數值型別支援。"

#: ../../library/string.rst:315
msgid ""
"A general convention is that an empty format specification produces the same "
"result as if you had called :func:`str` on the value. A non-empty format "
"specification typically modifies the result."
msgstr ""
"一般來說，輸入空格式規格會產生和對值呼叫 :func:`str` 函式相同的結果，非空的格"
"式規格才會修改結果。"

#: ../../library/string.rst:319
msgid "The general form of a *standard format specifier* is:"
msgstr "*標準格式說明符號 (standard format specifier)* 的一般型式如下："

#: ../../library/string.rst:331
msgid ""
"If a valid *align* value is specified, it can be preceded by a *fill* "
"character that can be any character and defaults to a space if omitted. It "
"is not possible to use a literal curly brace (\"``{``\" or \"``}``\") as the "
"*fill* character in a :ref:`formatted string literal <f-strings>` or when "
"using the :meth:`str.format` method.  However, it is possible to insert a "
"curly brace with a nested replacement field.  This limitation doesn't affect "
"the :func:`format` function."
msgstr ""
"如果給定了一個有效的 *align* 值，則可以在它之前加一個 *fill* 字元，且該字元可"
"為任意字元，若不加的話預設為空格。使用\\ :ref:`格式字串 <f-strings>`\\ "
"或 :meth:`str.format` 時是無法在其中使用大括號（\"``{``\" 或 \"``}``\"）作為 "
"*fill* 字元的，但仍可透過巢狀替換欄位的方式插入大括號。此限制不影"
"響 :func:`format` 函式。"

#: ../../library/string.rst:340
msgid "The meaning of the various alignment options is as follows:"
msgstr ""

#: ../../library/string.rst:349 ../../library/string.rst:381
msgid "Option"
msgstr "選項"

#: ../../library/string.rst:349 ../../library/string.rst:381
#: ../../library/string.rst:466 ../../library/string.rst:477
#: ../../library/string.rst:512
msgid "Meaning"
msgstr "含義"

#: ../../library/string.rst:351
msgid "``'<'``"
msgstr "``'<'``"

#: ../../library/string.rst:351
msgid ""
"Forces the field to be left-aligned within the available space (this is the "
"default for most objects)."
msgstr "強制欄位在可用空間內靠左對齊（這是大多數物件的預設值）。"

#: ../../library/string.rst:354
msgid "``'>'``"
msgstr "``'>'``"

#: ../../library/string.rst:354
msgid ""
"Forces the field to be right-aligned within the available space (this is the "
"default for numbers)."
msgstr "強制欄位在可用空間內靠右對齊（這是數字的預設值）。"

#: ../../library/string.rst:357
msgid "``'='``"
msgstr "``'='``"

#: ../../library/string.rst:357
msgid ""
"Forces the padding to be placed after the sign (if any) but before the "
"digits.  This is used for printing fields in the form '+000000120'. This "
"alignment option is only valid for numeric types, "
"excluding :class:`complex`. It becomes the default for numbers when '0' "
"immediately precedes the field width."
msgstr ""

#: ../../library/string.rst:364
msgid "``'^'``"
msgstr "``'^'``"

#: ../../library/string.rst:364
msgid "Forces the field to be centered within the available space."
msgstr "強制欄位在可用空間內置中。"

#: ../../library/string.rst:368
msgid ""
"Note that unless a minimum field width is defined, the field width will "
"always be the same size as the data to fill it, so that the alignment option "
"has no meaning in this case."
msgstr ""
"請注意，除非有定義了最小欄位寬度，否則欄位寬度將始終與填充它的資料大小相同，"
"故在該情況下的對齊選項是沒有意義的。"

#: ../../library/string.rst:372
msgid ""
"The *sign* option is only valid for number types, and can be one of the "
"following:"
msgstr "*sign* 選項只適用於數字型別，並可為以下之一："

#: ../../library/string.rst:383
msgid "``'+'``"
msgstr "``'+'``"

#: ../../library/string.rst:383
msgid ""
"indicates that a sign should be used for both positive as well as negative "
"numbers."
msgstr "表示正數與負數均需使用符號。"

#: ../../library/string.rst:386
msgid "``'-'``"
msgstr "``'-'``"

#: ../../library/string.rst:386
msgid ""
"indicates that a sign should be used only for negative numbers (this is the "
"default behavior)."
msgstr ""

#: ../../library/string.rst:375 ../../library/string.rst:389
msgid "space"
msgstr "空格"

#: ../../library/string.rst:389
msgid ""
"indicates that a leading space should be used on positive numbers, and a "
"minus sign on negative numbers."
msgstr "表示正數應使用前導空格，負數應使用減號。"

#: ../../library/string.rst:396
msgid ""
"The ``'z'`` option coerces negative zero floating-point values to positive "
"zero after rounding to the format precision.  This option is only valid for "
"floating-point presentation types."
msgstr ""

#: ../../library/string.rst:400
msgid "Added the ``'z'`` option (see also :pep:`682`)."
msgstr "新增 ``'z'`` 選項（請見 :pep:`682`\\ ）。"

#: ../../library/string.rst:405
msgid ""
"The ``'#'`` option causes the \"alternate form\" to be used for the "
"conversion.  The alternate form is defined differently for different types.  "
"This option is only valid for integer, float and complex types. For "
"integers, when binary, octal, or hexadecimal output is used, this option "
"adds the respective prefix ``'0b'``, ``'0o'``, ``'0x'``, or ``'0X'`` to the "
"output value. For float and complex the alternate form causes the result of "
"the conversion to always contain a decimal-point character, even if no "
"digits follow it. Normally, a decimal-point character appears in the result "
"of these conversions only if a digit follows it. In addition, for ``'g'`` "
"and ``'G'`` conversions, trailing zeros are not removed from the result."
msgstr ""

#: ../../library/string.rst:419
msgid ""
"The ``','`` option signals the use of a comma for a thousands separator for "
"floating-point presentation types and for integer presentation type ``'d'``. "
"For other presentation types, this option is an error. For a locale aware "
"separator, use the ``'n'`` integer presentation type instead."
msgstr ""

#: ../../library/string.rst:425
msgid "Added the ``','`` option (see also :pep:`378`)."
msgstr "新增 ``','`` 選項（請見 :pep:`378`\\ ）。"

#: ../../library/string.rst:430
msgid ""
"The ``'_'`` option signals the use of an underscore for a thousands "
"separator for floating-point presentation types and for integer presentation "
"type ``'d'``.  For integer presentation types ``'b'``, ``'o'``, ``'x'``, and "
"``'X'``, underscores will be inserted every 4 digits.  For other "
"presentation types, specifying this option is an error."
msgstr ""
"``'_'`` 選項表示對於浮點表示型別和整數表示型別 ``'d'`` 使用底線作為千位分隔符"
"號。對於整數表示型別 ``'b'``，``'o'``，``'x'`` 和 ``'X'``，每 4 位數字會插入"
"底線。對於其他表示型別，指定此選項會出錯。"

#: ../../library/string.rst:437
msgid "Added the ``'_'`` option (see also :pep:`515`)."
msgstr "新增 ``'_'`` 選項（請見 :pep:`515`\\ ）。"

#: ../../library/string.rst:440
msgid ""
"*width* is a decimal integer defining the minimum total field width, "
"including any prefixes, separators, and other formatting characters. If not "
"specified, then the field width will be determined by the content."
msgstr ""
"*width* 是一個十進位整數，定義了最小總欄位寬度，包括任何前綴、分隔符號和其他"
"格式字元。如果未指定，則欄位寬度將由內容決定。"

#: ../../library/string.rst:444
msgid ""
"When no explicit alignment is given, preceding the *width* field by a zero "
"(``'0'``) character enables sign-aware zero-padding for numeric types, "
"excluding :class:`complex`.  This is equivalent to a *fill* character of "
"``'0'`` with an *alignment* type of ``'='``."
msgstr ""
"當未給予明確的對齊指示，在 *width* 欄位前面填入零 (``'0'``) 字元將會"
"為 :class:`complex` 以外的數值型別啟用有符號察覺的零填充 (sign-aware zero-"
"padding)。這相當於使用 ``'0'`` 為 *fill* 字元且對齊類型為 ``'='``。"

#: ../../library/string.rst:449
msgid ""
"Preceding the *width* field by ``'0'`` no longer affects the default "
"alignment for strings."
msgstr "在 *width* 欄位前面加上 ``'0'`` 不再影響字串的預設對齊方式。"

#: ../../library/string.rst:453
msgid ""
"The *precision* is a decimal integer indicating how many digits should be "
"displayed after the decimal point for presentation types ``'f'`` and "
"``'F'``, or before and after the decimal point for presentation types "
"``'g'`` or ``'G'``.  For string presentation types the field indicates the "
"maximum field size - in other words, how many characters will be used from "
"the field content.  The *precision* is not allowed for integer presentation "
"types."
msgstr ""
"*precision* 是一個十進位整數，指定表示類型 ``'f'`` 和 ``'F'`` 的小數點後應顯"
"示多少位，或表示類型 ``'g'`` 或 ``'G'`` 的小數點前後應顯示多少位。對於字串表"
"示類型，該欄位指定最大欄位大小 - 換言之，將使用欄位中的多少字元。整數表示類型"
"不允許使用 *precision*。"

#: ../../library/string.rst:461
msgid "Finally, the *type* determines how the data should be presented."
msgstr "最終，型別決定了資料將會如何呈現"

#: ../../library/string.rst:463
msgid "The available string presentation types are:"
msgstr "可用的字串表示型別有："

#: ../../library/string.rst:466 ../../library/string.rst:477
#: ../../library/string.rst:512
msgid "Type"
msgstr "型別"

#: ../../library/string.rst:468
msgid "``'s'``"
msgstr "``'s'``"

#: ../../library/string.rst:468
msgid "String format. This is the default type for strings and may be omitted."
msgstr ""

#: ../../library/string.rst:471 ../../library/string.rst:500
#: ../../library/string.rst:585
msgid "None"
msgstr "None"

#: ../../library/string.rst:471
msgid "The same as ``'s'``."
msgstr "與 ``'s'`` 相同。"

#: ../../library/string.rst:474
msgid "The available integer presentation types are:"
msgstr ""

#: ../../library/string.rst:479
msgid "``'b'``"
msgstr "``'b'``"

#: ../../library/string.rst:479
msgid "Binary format. Outputs the number in base 2."
msgstr ""

#: ../../library/string.rst:481
msgid "``'c'``"
msgstr "``'c'``"

#: ../../library/string.rst:481
msgid ""
"Character. Converts the integer to the corresponding unicode character "
"before printing."
msgstr ""

#: ../../library/string.rst:484
msgid "``'d'``"
msgstr "``'d'``"

#: ../../library/string.rst:484
msgid "Decimal Integer. Outputs the number in base 10."
msgstr ""

#: ../../library/string.rst:486
msgid "``'o'``"
msgstr "``'o'``"

#: ../../library/string.rst:486
msgid "Octal format. Outputs the number in base 8."
msgstr ""

#: ../../library/string.rst:488
msgid "``'x'``"
msgstr "``'x'``"

#: ../../library/string.rst:488
msgid ""
"Hex format. Outputs the number in base 16, using lower-case letters for the "
"digits above 9."
msgstr "十六進位格式。輸出以 16 為基數的數字，9 以上的數字使用小寫字母。"

#: ../../library/string.rst:491
msgid "``'X'``"
msgstr "``'X'``"

#: ../../library/string.rst:491
msgid ""
"Hex format. Outputs the number in base 16, using upper-case letters for the "
"digits above 9. In case ``'#'`` is specified, the prefix ``'0x'`` will be "
"upper-cased to ``'0X'`` as well."
msgstr ""
"十六進位格式。輸出以 16 為基數的數字，9 以上的數字使用大寫字母。如果指定了 "
"``'#'``，則前綴 ``'0x'`` 也會被轉成大寫的 ``'0X'``。"

#: ../../library/string.rst:496 ../../library/string.rst:578
msgid "``'n'``"
msgstr "``'n'``"

#: ../../library/string.rst:496
msgid ""
"Number. This is the same as ``'d'``, except that it uses the current locale "
"setting to insert the appropriate number separator characters."
msgstr ""

#: ../../library/string.rst:500
msgid "The same as ``'d'``."
msgstr "與 ``'d'`` 相同。"

#: ../../library/string.rst:503
msgid ""
"In addition to the above presentation types, integers can be formatted with "
"the floating-point presentation types listed below (except ``'n'`` and "
"``None``). When doing so, :func:`float` is used to convert the integer to a "
"floating-point number before formatting."
msgstr ""

#: ../../library/string.rst:508
msgid ""
"The available presentation types for :class:`float` "
"and :class:`~decimal.Decimal` values are:"
msgstr ""

#: ../../library/string.rst:514
msgid "``'e'``"
msgstr "``'e'``"

#: ../../library/string.rst:514
msgid ""
"Scientific notation. For a given precision ``p``, formats the number in "
"scientific notation with the letter 'e' separating the coefficient from the "
"exponent. The coefficient has one digit before and ``p`` digits after the "
"decimal point, for a total of ``p + 1`` significant digits. With no "
"precision given, uses a precision of ``6`` digits after the decimal point "
"for :class:`float`, and shows all coefficient digits "
"for :class:`~decimal.Decimal`.  If ``p=0``, the decimal point is omitted "
"unless the ``#`` option is used."
msgstr ""

#: ../../library/string.rst:525
msgid "``'E'``"
msgstr "``'E'``"

#: ../../library/string.rst:525
msgid ""
"Scientific notation. Same as ``'e'`` except it uses an upper case 'E' as the "
"separator character."
msgstr ""

#: ../../library/string.rst:528
msgid "``'f'``"
msgstr "``'f'``"

#: ../../library/string.rst:528
msgid ""
"Fixed-point notation. For a given precision ``p``, formats the number as a "
"decimal number with exactly ``p`` digits following the decimal point. With "
"no precision given, uses a precision of ``6`` digits after the decimal point "
"for :class:`float`, and uses a precision large enough to show all "
"coefficient digits for :class:`~decimal.Decimal`.  If ``p=0``, the decimal "
"point is omitted unless the ``#`` option is used."
msgstr ""

#: ../../library/string.rst:537
msgid "``'F'``"
msgstr "``'F'``"

#: ../../library/string.rst:537
msgid ""
"Fixed-point notation. Same as ``'f'``, but converts ``nan`` to  ``NAN`` and "
"``inf`` to ``INF``."
msgstr ""

#: ../../library/string.rst:540
msgid "``'g'``"
msgstr "``'g'``"

#: ../../library/string.rst:540
msgid ""
"General format.  For a given precision ``p >= 1``, this rounds the number to "
"``p`` significant digits and then formats the result in either fixed-point "
"format or in scientific notation, depending on its magnitude. A precision of "
"``0`` is treated as equivalent to a precision of ``1``."
msgstr ""

#: ../../library/string.rst:547
msgid ""
"The precise rules are as follows: suppose that the result formatted with "
"presentation type ``'e'`` and precision ``p-1`` would have exponent "
"``exp``.  Then, if ``m <= exp < p``, where ``m`` is -4 for floats and -6 "
"for :class:`Decimals <decimal.Decimal>`, the number is formatted with "
"presentation type ``'f'`` and precision ``p-1-exp``.  Otherwise, the number "
"is formatted with presentation type ``'e'`` and precision ``p-1``. In both "
"cases insignificant trailing zeros are removed from the significand, and the "
"decimal point is also removed if there are no remaining digits following it, "
"unless the ``'#'`` option is used."
msgstr ""

#: ../../library/string.rst:560
msgid ""
"With no precision given, uses a precision of ``6`` significant digits "
"for :class:`float`. For :class:`~decimal.Decimal`, the coefficient of the "
"result is formed from the coefficient digits of the value; scientific "
"notation is used for values smaller than ``1e-6`` in absolute value and "
"values where the place value of the least significant digit is larger than "
"1, and fixed-point notation is used otherwise."
msgstr ""

#: ../../library/string.rst:569
msgid ""
"Positive and negative infinity, positive and negative zero, and nans, are "
"formatted as ``inf``, ``-inf``, ``0``, ``-0`` and ``nan`` respectively, "
"regardless of the precision."
msgstr ""

#: ../../library/string.rst:574
msgid "``'G'``"
msgstr "``'G'``"

#: ../../library/string.rst:574
msgid ""
"General format. Same as ``'g'`` except switches to ``'E'`` if the number "
"gets too large. The representations of infinity and NaN are uppercased, too."
msgstr ""

#: ../../library/string.rst:578
msgid ""
"Number. This is the same as ``'g'``, except that it uses the current locale "
"setting to insert the appropriate number separator characters."
msgstr ""

#: ../../library/string.rst:582
msgid "``'%'``"
msgstr "``'%'``"

#: ../../library/string.rst:582
msgid ""
"Percentage. Multiplies the number by 100 and displays in fixed (``'f'``) "
"format, followed by a percent sign."
msgstr ""

#: ../../library/string.rst:585
msgid ""
"For :class:`float` this is like the ``'g'`` type, except that when fixed-"
"point notation is used to format the result, it always includes at least one "
"digit past the decimal point, and switches to the scientific notation when "
"``exp >= p - 1``.  When the precision is not specified, the latter will be "
"as large as needed to represent the given value faithfully."
msgstr ""

#: ../../library/string.rst:593
msgid ""
"For :class:`~decimal.Decimal`, this is the same as either ``'g'`` or ``'G'`` "
"depending on the value of ``context.capitals`` for the current decimal "
"context."
msgstr ""

#: ../../library/string.rst:597
msgid ""
"The overall effect is to match the output of :func:`str` as altered by the "
"other format modifiers."
msgstr ""

#: ../../library/string.rst:601
msgid ""
"The result should be correctly rounded to a given precision ``p`` of digits "
"after the decimal point.  The rounding mode for :class:`float` matches that "
"of the :func:`round` builtin.  For :class:`~decimal.Decimal`, the rounding "
"mode of the current :ref:`context <decimal-context>` will be used."
msgstr ""

#: ../../library/string.rst:606
msgid ""
"The available presentation types for :class:`complex` are the same as those "
"for :class:`float` (``'%'`` is not allowed).  Both the real and imaginary "
"components of a complex number are formatted as floating-point numbers, "
"according to the specified presentation type.  They are separated by the "
"mandatory sign of the imaginary part, the latter being terminated by a ``j`` "
"suffix.  If the presentation type is missing, the result will match the "
"output of :func:`str` (complex numbers with a non-zero real part are also "
"surrounded by parentheses), possibly altered by other format modifiers."
msgstr ""

#: ../../library/string.rst:619
msgid "Format examples"
msgstr "格式範例"

#: ../../library/string.rst:621
msgid ""
"This section contains examples of the :meth:`str.format` syntax and "
"comparison with the old ``%``-formatting."
msgstr "本節包含 :meth:`str.format` 語法以及與舊式 ``%`` 格式的比較。"

#: ../../library/string.rst:624
msgid ""
"In most of the cases the syntax is similar to the old ``%``-formatting, with "
"the addition of the ``{}`` and with ``:`` used instead of ``%``. For "
"example, ``'%03.2f'`` can be translated to ``'{:03.2f}'``."
msgstr ""
"此語法在大多情況下與舊式的 ``%`` 格式類似，只是增加了 ``{}`` 和 ``:`` 來取代 "
"``%``。例如，``'%03.2f'`` 可以改寫為 ``'{:03.2f}'``。"

#: ../../library/string.rst:628
msgid ""
"The new format syntax also supports new and different options, shown in the "
"following examples."
msgstr "新的語法還支援新的選項，將在以下的範例中說明。"

#: ../../library/string.rst:631
msgid "Accessing arguments by position::"
msgstr "按位置存取引數： ::"

#: ../../library/string.rst:633
msgid ""
">>> '{0}, {1}, {2}'.format('a', 'b', 'c')\n"
"'a, b, c'\n"
">>> '{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ only\n"
"'a, b, c'\n"
">>> '{2}, {1}, {0}'.format('a', 'b', 'c')\n"
"'c, b, a'\n"
">>> '{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence\n"
"'c, b, a'\n"
">>> '{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be "
"repeated\n"
"'abracadabra'"
msgstr ""
">>> '{0}, {1}, {2}'.format('a', 'b', 'c')\n"
"'a, b, c'\n"
">>> '{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ only\n"
"'a, b, c'\n"
">>> '{2}, {1}, {0}'.format('a', 'b', 'c')\n"
"'c, b, a'\n"
">>> '{2}, {1}, {0}'.format(*'abc')      # 解包引數序列\n"
"'c, b, a'\n"
">>> '{0}{1}{0}'.format('abra', 'cad')   # 引數索引可以重複\n"
"'abracadabra'"

#: ../../library/string.rst:644
msgid "Accessing arguments by name::"
msgstr "按名稱存取引數： ::"

#: ../../library/string.rst:646
msgid ""
">>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', "
"longitude='-115.81W')\n"
"'Coordinates: 37.24N, -115.81W'\n"
">>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}\n"
">>> 'Coordinates: {latitude}, {longitude}'.format(**coord)\n"
"'Coordinates: 37.24N, -115.81W'"
msgstr ""

#: ../../library/string.rst:652
msgid "Accessing arguments' attributes::"
msgstr "存取引數的屬性： ::"

#: ../../library/string.rst:654
msgid ""
">>> c = 3-5j\n"
">>> ('The complex number {0} is formed from the real part {0.real} '\n"
"...  'and the imaginary part {0.imag}.').format(c)\n"
"'The complex number (3-5j) is formed from the real part 3.0 and the "
"imaginary part -5.0.'\n"
">>> class Point:\n"
"...     def __init__(self, x, y):\n"
"...         self.x, self.y = x, y\n"
"...     def __str__(self):\n"
"...         return 'Point({self.x}, {self.y})'.format(self=self)\n"
"...\n"
">>> str(Point(4, 2))\n"
"'Point(4, 2)'"
msgstr ""

#: ../../library/string.rst:667
msgid "Accessing arguments' items::"
msgstr "存取引數的內容： ::"

#: ../../library/string.rst:669
msgid ""
">>> coord = (3, 5)\n"
">>> 'X: {0[0]};  Y: {0[1]}'.format(coord)\n"
"'X: 3;  Y: 5'"
msgstr ""
">>> coord = (3, 5)\n"
">>> 'X: {0[0]};  Y: {0[1]}'.format(coord)\n"
"'X: 3;  Y: 5'"

#: ../../library/string.rst:673
msgid "Replacing ``%s`` and ``%r``::"
msgstr "替換 ``%s`` 和 ``%r``： ::"

#: ../../library/string.rst:675
msgid ""
">>> \"repr() shows quotes: {!r}; str() doesn't: {!s}\".format('test1', "
"'test2')\n"
"\"repr() shows quotes: 'test1'; str() doesn't: test2\""
msgstr ""
">>> \"repr() shows quotes: {!r}; str() doesn't: {!s}\".format('test1', "
"'test2')\n"
"\"repr() shows quotes: 'test1'; str() doesn't: test2\""

#: ../../library/string.rst:678
msgid "Aligning the text and specifying a width::"
msgstr "對齊文字以及指定寬度： ::"

#: ../../library/string.rst:680
msgid ""
">>> '{:<30}'.format('left aligned')\n"
"'left aligned                  '\n"
">>> '{:>30}'.format('right aligned')\n"
"'                 right aligned'\n"
">>> '{:^30}'.format('centered')\n"
"'           centered           '\n"
">>> '{:*^30}'.format('centered')  # use '*' as a fill char\n"
"'***********centered***********'"
msgstr ""

#: ../../library/string.rst:689
msgid "Replacing ``%+f``, ``%-f``, and ``% f`` and specifying a sign::"
msgstr "替換 ``%+f``、``%-f`` 和 ``% f`` 以及指定正負號： ::"

#: ../../library/string.rst:691
msgid ""
">>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always\n"
"'+3.140000; -3.140000'\n"
">>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers\n"
"' 3.140000; -3.140000'\n"
">>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as "
"'{:f}; {:f}'\n"
"'3.140000; -3.140000'"
msgstr ""
">>> '{:+f}; {:+f}'.format(3.14, -3.14)  # 總會顯示\n"
"'+3.140000; -3.140000'\n"
">>> '{: f}; {: f}'.format(3.14, -3.14)  # 若為正數則顯示空格\n"
"' 3.140000; -3.140000'\n"
">>> '{:-f}; {:-f}'.format(3.14, -3.14)  # 只顯示負號 -- 與 '{:f}; {:f}' 相"
"同\n"
"'3.140000; -3.140000'"

#: ../../library/string.rst:698
msgid ""
"Replacing ``%x`` and ``%o`` and converting the value to different bases::"
msgstr "替換 ``%x`` 和 ``%o`` 並將其值轉換為不同的進位制： ::"

#: ../../library/string.rst:700
msgid ""
">>> # format also supports binary numbers\n"
">>> \"int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}\".format(42)\n"
"'int: 42;  hex: 2a;  oct: 52;  bin: 101010'\n"
">>> # with 0x, 0o, or 0b as prefix:\n"
">>> \"int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}\".format(42)\n"
"'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'"
msgstr ""

#: ../../library/string.rst:707
msgid "Using the comma as a thousands separator::"
msgstr "使用逗號作為千位分隔符： ::"

#: ../../library/string.rst:709
msgid ""
">>> '{:,}'.format(1234567890)\n"
"'1,234,567,890'"
msgstr ""
">>> '{:,}'.format(1234567890)\n"
"'1,234,567,890'"

#: ../../library/string.rst:712
msgid "Expressing a percentage::"
msgstr "表示為百分比： ::"

#: ../../library/string.rst:714
msgid ""
">>> points = 19\n"
">>> total = 22\n"
">>> 'Correct answers: {:.2%}'.format(points/total)\n"
"'Correct answers: 86.36%'"
msgstr ""
">>> points = 19\n"
">>> total = 22\n"
">>> 'Correct answers: {:.2%}'.format(points/total)\n"
"'Correct answers: 86.36%'"

#: ../../library/string.rst:719
msgid "Using type-specific formatting::"
msgstr "作為特定型別格式： ::"

#: ../../library/string.rst:721
msgid ""
">>> import datetime\n"
">>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)\n"
">>> '{:%Y-%m-%d %H:%M:%S}'.format(d)\n"
"'2010-07-04 12:15:58'"
msgstr ""
">>> import datetime\n"
">>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)\n"
">>> '{:%Y-%m-%d %H:%M:%S}'.format(d)\n"
"'2010-07-04 12:15:58'"

#: ../../library/string.rst:726
msgid "Nesting arguments and more complex examples::"
msgstr "巢狀引數及更多複雜範例： ::"

#: ../../library/string.rst:728
msgid ""
">>> for align, text in zip('<^>', ['left', 'center', 'right']):\n"
"...     '{0:{fill}{align}16}'.format(text, fill=align, align=align)\n"
"...\n"
"'left<<<<<<<<<<<<'\n"
"'^^^^^center^^^^^'\n"
"'>>>>>>>>>>>right'\n"
">>>\n"
">>> octets = [192, 168, 0, 1]\n"
">>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)\n"
"'C0A80001'\n"
">>> int(_, 16)\n"
"3232235521\n"
">>>\n"
">>> width = 5\n"
">>> for num in range(5,12): \n"
"...     for base in 'dXob':\n"
"...         print('{0:{width}{base}}'.format(num, base=base, width=width), "
"end=' ')\n"
"...     print()\n"
"...\n"
"    5     5     5   101\n"
"    6     6     6   110\n"
"    7     7     7   111\n"
"    8     8    10  1000\n"
"    9     9    11  1001\n"
"   10     A    12  1010\n"
"   11     B    13  1011"
msgstr ""
">>> for align, text in zip('<^>', ['left', 'center', 'right']):\n"
"...     '{0:{fill}{align}16}'.format(text, fill=align, align=align)\n"
"...\n"
"'left<<<<<<<<<<<<'\n"
"'^^^^^center^^^^^'\n"
"'>>>>>>>>>>>right'\n"
">>>\n"
">>> octets = [192, 168, 0, 1]\n"
">>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)\n"
"'C0A80001'\n"
">>> int(_, 16)\n"
"3232235521\n"
">>>\n"
">>> width = 5\n"
">>> for num in range(5,12): \n"
"...     for base in 'dXob':\n"
"...         print('{0:{width}{base}}'.format(num, base=base, width=width), "
"end=' ')\n"
"...     print()\n"
"...\n"
"    5     5     5   101\n"
"    6     6     6   110\n"
"    7     7     7   111\n"
"    8     8    10  1000\n"
"    9     9    11  1001\n"
"   10     A    12  1010\n"
"   11     B    13  1011"

#: ../../library/string.rst:760
msgid "Template strings"
msgstr "模板字串"

#: ../../library/string.rst:762
msgid ""
"Template strings provide simpler string substitutions as described "
"in :pep:`292`.  A primary use case for template strings is for "
"internationalization (i18n) since in that context, the simpler syntax and "
"functionality makes it easier to translate than other built-in string "
"formatting facilities in Python.  As an example of a library built on "
"template strings for i18n, see the `flufl.i18n <https://"
"flufli18n.readthedocs.io/en/latest/>`_ package."
msgstr ""
"模板字串提供如 :pep:`292` 所述更簡單的字串替換。模板字串的主要用例是國際化 "
"(i18n)，因為在這種情況下，更簡單的語法和功能使得它比其他 Python 內建字串格式"
"化工具更容易翻譯。基於模板字串建構的 i18n 函式庫範例，請參閱 `flufl.i18n "
"<https://flufli18n.readthedocs.io/en/latest/>`_ 套件。"

#: ../../library/string.rst:772
msgid ""
"Template strings support ``$``-based substitutions, using the following "
"rules:"
msgstr ""

#: ../../library/string.rst:774
msgid "``$$`` is an escape; it is replaced with a single ``$``."
msgstr ""

#: ../../library/string.rst:776
msgid ""
"``$identifier`` names a substitution placeholder matching a mapping key of "
"``\"identifier\"``.  By default, ``\"identifier\"`` is restricted to any "
"case-insensitive ASCII alphanumeric string (including underscores) that "
"starts with an underscore or ASCII letter.  The first non-identifier "
"character after the ``$`` character terminates this placeholder "
"specification."
msgstr ""

#: ../../library/string.rst:783
msgid ""
"``${identifier}`` is equivalent to ``$identifier``.  It is required when "
"valid identifier characters follow the placeholder but are not part of the "
"placeholder, such as ``\"${noun}ification\"``."
msgstr ""

#: ../../library/string.rst:787
msgid ""
"Any other appearance of ``$`` in the string will result in "
"a :exc:`ValueError` being raised."
msgstr ""

#: ../../library/string.rst:790
msgid ""
"The :mod:`string` module provides a :class:`Template` class that implements "
"these rules.  The methods of :class:`Template` are:"
msgstr ""

#: ../../library/string.rst:796
msgid "The constructor takes a single argument which is the template string."
msgstr ""

#: ../../library/string.rst:801
msgid ""
"Performs the template substitution, returning a new string.  *mapping* is "
"any dictionary-like object with keys that match the placeholders in the "
"template.  Alternatively, you can provide keyword arguments, where the "
"keywords are the placeholders.  When both *mapping* and *kwds* are given and "
"there are duplicates, the placeholders from *kwds* take precedence."
msgstr ""
"進行模板替換，並回傳一個新的字串。 *mapping* 是任何有金鑰並符合模板裡佔位符號"
"的字典型物件。或者如果關鍵字就是佔位符號時，你也可以改提供關鍵字引數。當 "
"*mapping* 跟 *kwds* 同時給定並存在重複時，*kwds* 的佔位符號會被優先使用。"

#: ../../library/string.rst:810
msgid ""
"Like :meth:`substitute`, except that if placeholders are missing from "
"*mapping* and *kwds*, instead of raising a :exc:`KeyError` exception, the "
"original placeholder will appear in the resulting string intact.  Also, "
"unlike with :meth:`substitute`, any other appearances of the ``$`` will "
"simply return ``$`` instead of raising :exc:`ValueError`."
msgstr ""
"類似於 :meth:`substitute`，但如果 *mapping* 與 *kwds* 中缺少佔位符號的話，原"
"始的佔位符號會完整地出現在結果字串裡，而不會引發 :exc:`KeyError` 例外。此外，"
"與 :meth:`substitute` 不同的是，任何包含 ``$`` 的字句會直接回傳 ``$`` 而非引"
"發 :exc:`ValueError`。"

#: ../../library/string.rst:816
msgid ""
"While other exceptions may still occur, this method is called \"safe\" "
"because it always tries to return a usable string instead of raising an "
"exception.  In another sense, :meth:`safe_substitute` may be anything other "
"than safe, since it will silently ignore malformed templates containing "
"dangling delimiters, unmatched braces, or placeholders that are not valid "
"Python identifiers."
msgstr ""
"雖然仍可能發生其他例外，但這個方法被認為是「安全」的，因為它總是試圖回傳一個"
"有用的字串而不是引發例外。從另一個角度來看，:meth:`safe_substitute` 可能並非"
"完全安全，因為它會默默忽略格式錯誤的模板，這些模板包含了多餘的左右定界符、不"
"匹配的括號，或者不是有效的 Python 識別字的佔位符號。"

#: ../../library/string.rst:826
msgid ""
"Returns false if the template has invalid placeholders that will "
"cause :meth:`substitute` to raise :exc:`ValueError`."
msgstr ""
"如果模板有將導致 :meth:`substitute` 引發 :exc:`ValueError` 的無效佔位符號，就"
"會回傳 false。"

#: ../../library/string.rst:834
msgid ""
"Returns a list of the valid identifiers in the template, in the order they "
"first appear, ignoring any invalid identifiers."
msgstr ""
"回傳模板中有效識別字的串列，按照它們首次出現的順序，並忽略任何無效的識別字。"

#: ../../library/string.rst:839
msgid ":class:`Template` instances also provide one public data attribute:"
msgstr ":class:`Template` 實例也提供一個公開的資料屬性："

#: ../../library/string.rst:843
msgid ""
"This is the object passed to the constructor's *template* argument.  In "
"general, you shouldn't change it, but read-only access is not enforced."
msgstr ""
"這是傳遞給建構函式 *template* 引數的物件。一般來說，你不應該改變它，但並沒有"
"強制設定成唯讀。"

#: ../../library/string.rst:846
msgid "Here is an example of how to use a Template::"
msgstr "以下是如何使用 Template 的一個範例： ::"

#: ../../library/string.rst:848
msgid ""
">>> from string import Template\n"
">>> s = Template('$who likes $what')\n"
">>> s.substitute(who='tim', what='kung pao')\n"
"'tim likes kung pao'\n"
">>> d = dict(who='tim')\n"
">>> Template('Give $who $100').substitute(d)\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: Invalid placeholder in string: line 1, col 11\n"
">>> Template('$who likes $what').substitute(d)\n"
"Traceback (most recent call last):\n"
"...\n"
"KeyError: 'what'\n"
">>> Template('$who likes $what').safe_substitute(d)\n"
"'tim likes $what'"
msgstr ""
">>> from string import Template\n"
">>> s = Template('$who likes $what')\n"
">>> s.substitute(who='tim', what='kung pao')\n"
"'tim likes kung pao'\n"
">>> d = dict(who='tim')\n"
">>> Template('Give $who $100').substitute(d)\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: Invalid placeholder in string: line 1, col 11\n"
">>> Template('$who likes $what').substitute(d)\n"
"Traceback (most recent call last):\n"
"...\n"
"KeyError: 'what'\n"
">>> Template('$who likes $what').safe_substitute(d)\n"
"'tim likes $what'"

#: ../../library/string.rst:864
msgid ""
"Advanced usage: you can derive subclasses of :class:`Template` to customize "
"the placeholder syntax, delimiter character, or the entire regular "
"expression used to parse template strings.  To do this, you can override "
"these class attributes:"
msgstr ""
"進階用法：你可以衍生 :class:`Template` 類別來自定義佔位符號語法、左右定界符字"
"元，或者用於剖析模板字串的正規表示式。你可以透過覆寫這些類別屬性來達成："

#: ../../library/string.rst:869
msgid ""
"*delimiter* -- This is the literal string describing a placeholder "
"introducing delimiter.  The default value is ``$``.  Note that this should "
"*not* be a regular expression, as the implementation will "
"call :meth:`re.escape` on this string as needed.  Note further that you "
"cannot change the delimiter after class creation (i.e. a different delimiter "
"must be set in the subclass's class namespace)."
msgstr ""
"*delimiter* -- 這是描述引入左右定界符的文字字串。預設值是 ``$``。請注意這\\ *"
"不是*\\ 正規表示式，因為實作會在需要時對這個字串呼叫 :meth:`re.escape`。也請"
"注意你不能在建立類別後修改左右定界符。（意即在子類別的命名空間中必須設置不同"
"的左右定界符）"

#: ../../library/string.rst:876
msgid ""
"*idpattern* -- This is the regular expression describing the pattern for non-"
"braced placeholders.  The default value is the regular expression ``(?a:[_a-"
"z][_a-z0-9]*)``.  If this is given and *braceidpattern* is ``None`` this "
"pattern will also apply to braced placeholders."
msgstr ""

#: ../../library/string.rst:883
msgid ""
"Since default *flags* is ``re.IGNORECASE``, pattern ``[a-z]`` can match with "
"some non-ASCII characters. That's why we use the local ``a`` flag here."
msgstr ""

#: ../../library/string.rst:887
msgid ""
"*braceidpattern* can be used to define separate patterns used inside and "
"outside the braces."
msgstr ""

#: ../../library/string.rst:891
msgid ""
"*braceidpattern* -- This is like *idpattern* but describes the pattern for "
"braced placeholders.  Defaults to ``None`` which means to fall back to "
"*idpattern* (i.e. the same pattern is used both inside and outside braces). "
"If given, this allows you to define different patterns for braced and "
"unbraced placeholders."
msgstr ""

#: ../../library/string.rst:899
msgid ""
"*flags* -- The regular expression flags that will be applied when compiling "
"the regular expression used for recognizing substitutions.  The default "
"value is ``re.IGNORECASE``.  Note that ``re.VERBOSE`` will always be added "
"to the flags, so custom *idpattern*\\ s must follow conventions for verbose "
"regular expressions."
msgstr ""

#: ../../library/string.rst:907
msgid ""
"Alternatively, you can provide the entire regular expression pattern by "
"overriding the class attribute *pattern*.  If you do this, the value must be "
"a regular expression object with four named capturing groups.  The capturing "
"groups correspond to the rules given above, along with the invalid "
"placeholder rule:"
msgstr ""

#: ../../library/string.rst:913
msgid ""
"*escaped* -- This group matches the escape sequence, e.g. ``$$``, in the "
"default pattern."
msgstr "*escaped* -- 此群組與跳脫序列匹配，例如在預設模式下為 ``$$``。"

#: ../../library/string.rst:916
msgid ""
"*named* -- This group matches the unbraced placeholder name; it should not "
"include the delimiter in capturing group."
msgstr ""
"*named* -- 此群組與不帶大括號的佔位符號名稱匹配；它不應包含擷取群組中的左右定"
"界符號。"

#: ../../library/string.rst:919
msgid ""
"*braced* -- This group matches the brace enclosed placeholder name; it "
"should not include either the delimiter or braces in the capturing group."
msgstr ""
"*braced* -- 此群組與大括號括起來的佔位符號名稱匹配；它不應在擷取群組中包含左"
"右定界符或大括號。"

#: ../../library/string.rst:922
msgid ""
"*invalid* -- This group matches any other delimiter pattern (usually a "
"single delimiter), and it should appear last in the regular expression."
msgstr ""
"*invalid* -- 此群組與任何其他左右定界符模式（通常是單一左右定界符）匹配，且它"
"應該出現在正規表示式的最後。"

#: ../../library/string.rst:925
msgid ""
"The methods on this class will raise :exc:`ValueError` if the pattern "
"matches the template without one of these named groups matching."
msgstr ""
"當此模式有匹配於模板但這些命名組中卻有任一個不匹配，此類別的方法將引"
"發 :exc:`ValueError`。"

#: ../../library/string.rst:930
msgid "Helper functions"
msgstr "輔助函式"

#: ../../library/string.rst:934
msgid ""
"Split the argument into words using :meth:`str.split`, capitalize each word "
"using :meth:`str.capitalize`, and join the capitalized words "
"using :meth:`str.join`.  If the optional second argument *sep* is absent or "
"``None``, runs of whitespace characters are replaced by a single space and "
"leading and trailing whitespace are removed, otherwise *sep* is used to "
"split and join the words."
msgstr ""
"使用 :meth:`str.split` 將引數分割為字詞，使用 :meth:`str.capitalize` 將每個單"
"字大寫，並使用 :meth:`str.join` 將大寫字詞連接起來。如果可選的第二引數 *sep* "
"不存在或為 ``None``，則連續的空白字元將替換為單一空格，並且刪除前導和尾隨空"
"白；在其他情況下則使用 *sep* 來分割和連接單字。"

#: ../../library/string.rst:202
msgid "{} (curly brackets)"
msgstr "{} （花括號）"

#: ../../library/string.rst:202 ../../library/string.rst:342
#: ../../library/string.rst:375 ../../library/string.rst:394
#: ../../library/string.rst:403 ../../library/string.rst:417
#: ../../library/string.rst:428
msgid "in string formatting"
msgstr "於字串格式化"

#: ../../library/string.rst:202
msgid ". (dot)"
msgstr ". （點）"

#: ../../library/string.rst:202
msgid "[] (square brackets)"
msgstr "[] （方括號）"

#: ../../library/string.rst:202
msgid "! (exclamation)"
msgstr "! （驚嘆號）"

#: ../../library/string.rst:202
msgid ": (colon)"
msgstr ": （冒號）"

#: ../../library/string.rst:342
msgid "< (less)"
msgstr "< （小於）"

#: ../../library/string.rst:342
msgid "> (greater)"
msgstr "> （大於）"

#: ../../library/string.rst:342
msgid "= (equals)"
msgstr "= （等於）"

#: ../../library/string.rst:342
msgid "^ (caret)"
msgstr "^ （插入符號）"

#: ../../library/string.rst:375
msgid "+ (plus)"
msgstr "+ （加號）"

#: ../../library/string.rst:375
msgid "- (minus)"
msgstr "- （減號）"

#: ../../library/string.rst:394
msgid "z"
msgstr "z"

#: ../../library/string.rst:403
msgid "# (hash)"
msgstr "# （井字號）"

#: ../../library/string.rst:417
msgid ", (comma)"
msgstr ", （逗號）"

#: ../../library/string.rst:428
msgid "_ (underscore)"
msgstr "_ （底線）"

#: ../../library/string.rst:770
msgid "$ (dollar)"
msgstr "$ （金錢符號）"

#: ../../library/string.rst:770
msgid "in template strings"
msgstr "於 template strings（模板字串）"