string.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-07-17 17:39+0800\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:64
msgid ""
"String of ASCII characters which are considered printable.  This is a "
"combination of :const:`digits`, :const:`ascii_letters`, :const:"
"`punctuation`, and :const:`whitespace`."
msgstr ""
"ASCII 字元的字串是可被列印輸出的。 這是 :const:`digits`、:const:"
"`ascii_letters`、:const:`punctuation` 和 :const:`whitespace` 的組合。"

#: ../../library/string.rst:71
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:79
msgid "Custom String Formatting"
msgstr "自訂字串格式"

#: ../../library/string.rst:81
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:90
msgid "The :class:`Formatter` class has the following public methods:"
msgstr ":class:`Formatter` 類別有以下的公開方法："

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

#: ../../library/string.rst:104
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:112
msgid ""
"In addition, the :class:`Formatter` defines a number of methods that are "
"intended to be replaced by subclasses:"
msgstr ""

#: ../../library/string.rst:117
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:122
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:131
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:140
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:145
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:149
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:153
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:158
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:163
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:173
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:178
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:187
msgid "Format String Syntax"
msgstr "格式化文字語法"

#: ../../library/string.rst:189
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:202
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:207
msgid "The grammar for a replacement field is as follows:"
msgstr ""

#: ../../library/string.rst:219
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:226
msgid "See also the :ref:`formatspec` section."
msgstr "另請參閱 :ref:`formatspec` 部份。"

#: ../../library/string.rst:228
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:242
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:246
msgid ""
"The positional argument specifiers can be omitted for :class:`Formatter`."
msgstr ""

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

#: ../../library/string.rst:258
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:265
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:269
msgid "Some examples::"
msgstr ""
"一些範例：\n"
"\n"
"::"

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

#: ../../library/string.rst:283
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:290
msgid "See the :ref:`formatexamples` section for some examples."
msgstr "範例請見 :ref:`formatexamples`。"

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

#: ../../library/string.rst:298
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:305
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:308
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:312
msgid "The general form of a *standard format specifier* is:"
msgstr "*標準格式說明符號 (standard format specifier)* 的一般型式如下："

#: ../../library/string.rst:324
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:333
msgid "The meaning of the various alignment options is as follows:"
msgstr ""

#: ../../library/string.rst:342 ../../library/string.rst:373
msgid "Option"
msgstr "選項"

#: ../../library/string.rst:342 ../../library/string.rst:373
#: ../../library/string.rst:456 ../../library/string.rst:467
#: ../../library/string.rst:502
msgid "Meaning"
msgstr ""

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

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

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

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

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

#: ../../library/string.rst:350
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.  It becomes the default "
"for numbers when '0' immediately precedes the field width."
msgstr ""

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

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

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

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

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

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

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

#: ../../library/string.rst:367 ../../library/string.rst:381
msgid "space"
msgstr ""

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

#: ../../library/string.rst:388
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:392
msgid "Added the ``'z'`` option (see also :pep:`682`)."
msgstr "新增 ``'z'`` 選項（請見 :pep:`682`\\ ）。"

#: ../../library/string.rst:397
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:411
msgid ""
"The ``','`` option signals the use of a comma for a thousands separator. For "
"a locale aware separator, use the ``'n'`` integer presentation type instead."
msgstr ""

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

#: ../../library/string.rst:420
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:427
msgid "Added the ``'_'`` option (see also :pep:`515`)."
msgstr "新增 ``'_'`` 選項（請見 :pep:`515`\\ ）。"

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

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

#: ../../library/string.rst:443
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:451
msgid "Finally, the *type* determines how the data should be presented."
msgstr "最終，型別決定了資料將會如何呈現"

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

#: ../../library/string.rst:456 ../../library/string.rst:467
#: ../../library/string.rst:502
msgid "Type"
msgstr "型別"

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

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

#: ../../library/string.rst:461 ../../library/string.rst:490
#: ../../library/string.rst:577
msgid "None"
msgstr "None"

#: ../../library/string.rst:461
msgid "The same as ``'s'``."
msgstr ""

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/string.rst:481
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:486 ../../library/string.rst:570
msgid "``'n'``"
msgstr "``'n'``"

#: ../../library/string.rst:486
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:490
msgid "The same as ``'d'``."
msgstr ""

#: ../../library/string.rst:493
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:498
msgid ""
"The available presentation types for :class:`float` and :class:`~decimal."
"Decimal` values are:"
msgstr ""

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

#: ../../library/string.rst:504
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 no digits follow the decimal point, the decimal point is also "
"removed unless the ``#`` option is used."
msgstr ""

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

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

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

#: ../../library/string.rst:519
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 no digits follow the "
"decimal point, the decimal point is also removed unless the ``#`` option is "
"used."
msgstr ""

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

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

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

#: ../../library/string.rst:532
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:539
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:552
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:561
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:566
msgid "``'G'``"
msgstr "``'G'``"

#: ../../library/string.rst:566
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:570
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:574
msgid "``'%'``"
msgstr "``'%'``"

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

#: ../../library/string.rst:577
msgid ""
"For :class:`float` this is the same as ``'g'``, except that when fixed-point "
"notation is used to format the result, it always includes at least one digit "
"past the decimal point. The precision used is as large as needed to "
"represent the given value faithfully."
msgstr ""

#: ../../library/string.rst:583
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:587
msgid ""
"The overall effect is to match the output of :func:`str` as altered by the "
"other format modifiers."
msgstr ""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/string.rst:738
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:748
msgid ""
"Template strings support ``$``-based substitutions, using the following "
"rules:"
msgstr ""

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

#: ../../library/string.rst:752
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:759
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:763
msgid ""
"Any other appearance of ``$`` in the string will result in a :exc:"
"`ValueError` being raised."
msgstr ""

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

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

#: ../../library/string.rst:777
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:786
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:792
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:802
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:810
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:815
msgid ":class:`Template` instances also provide one public data attribute:"
msgstr ":class:`Template` 實例也提供一個公開的資料屬性："

#: ../../library/string.rst:819
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:822
msgid "Here is an example of how to use a Template::"
msgstr "以下是如何使用 Template 的一個範例： ::"

#: ../../library/string.rst:840
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:845
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:852
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:859
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:863
msgid ""
"*braceidpattern* can be used to define separate patterns used inside and "
"outside the braces."
msgstr ""

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

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

#: ../../library/string.rst:895
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:898
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:901
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:906
msgid "Helper functions"
msgstr "輔助函式"

#: ../../library/string.rst:910
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:195
msgid "{} (curly brackets)"
msgstr "{} （花括號）"

#: ../../library/string.rst:195 ../../library/string.rst:335
#: ../../library/string.rst:367 ../../library/string.rst:386
#: ../../library/string.rst:395 ../../library/string.rst:409
#: ../../library/string.rst:418
msgid "in string formatting"
msgstr "於字串格式化"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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