unicode.po

# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Leon H., 2017
# Liang-Bo Wang <me@liang2.tw>, 2016
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-04-10 00:23+0000\n"
"PO-Revision-Date: 2018-05-23 14:08+0000\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"

#: ../../c-api/unicode.rst:6
msgid "Unicode Objects and Codecs"
msgstr "Unicode 物件與編解碼器"

#: ../../c-api/unicode.rst:12
msgid "Unicode Objects"
msgstr "Unicode 物件"

#: ../../c-api/unicode.rst:14
msgid ""
"Since the implementation of :pep:`393` in Python 3.3, Unicode objects "
"internally use a variety of representations, in order to allow handling the "
"complete range of Unicode characters while staying memory efficient.  There "
"are special cases for strings where all code points are below 128, 256, or "
"65536; otherwise, code points must be below 1114112 (which is the full "
"Unicode range)."
msgstr ""

#: ../../c-api/unicode.rst:20
msgid ""
"UTF-8 representation is created on demand and cached in the Unicode object."
msgstr "UTF-8 表示法會在需要時建立並快取在 Unicode 物件中。"

#: ../../c-api/unicode.rst:23
msgid ""
"The :c:type:`Py_UNICODE` representation has been removed since Python 3.12 "
"with deprecated APIs. See :pep:`623` for more information."
msgstr ""
"自 Python 3.12 起，已移除 :c:type:`Py_UNICODE` 表示法，並標示為已棄用的 API。"
"更多資訊請參閱 :pep:`623`。"

#: ../../c-api/unicode.rst:29
msgid "Unicode Type"
msgstr "Unicode 型別"

#: ../../c-api/unicode.rst:31
msgid ""
"These are the basic Unicode object types used for the Unicode implementation "
"in Python:"
msgstr "這些是 Python 中用於 Unicode 實作的基本 Unicode 物件型別："

#: ../../c-api/unicode.rst:36
msgid ""
"This instance of :c:type:`PyTypeObject` represents the Python Unicode type. "
"It is exposed to Python code as :py:class:`str`."
msgstr ""

#: ../../c-api/unicode.rst:42
msgid ""
"This instance of :c:type:`PyTypeObject` represents the Python Unicode "
"iterator type. It is used to iterate over Unicode string objects."
msgstr ""

#: ../../c-api/unicode.rst:50
msgid ""
"These types are typedefs for unsigned integer types wide enough to contain "
"characters of 32 bits, 16 bits and 8 bits, respectively.  When dealing with "
"single Unicode characters, use :c:type:`Py_UCS4`."
msgstr ""

#: ../../c-api/unicode.rst:61
msgid ""
"These subtypes of :c:type:`PyObject` represent a Python Unicode object.  In "
"almost all cases, they shouldn't be used directly, since all API functions "
"that deal with Unicode objects take and return :c:type:`PyObject` pointers."
msgstr ""

#: ../../c-api/unicode.rst:68
msgid ""
"The structure of a particular object can be determined using the following "
"macros. The macros cannot fail; their behavior is undefined if their "
"argument is not a Python Unicode object."
msgstr ""

#: ../../c-api/unicode.rst:77
msgid "True if *o* uses the :c:struct:`PyCompactUnicodeObject` structure."
msgstr ""

#: ../../c-api/unicode.rst:84
msgid "True if *o* uses the :c:struct:`PyASCIIObject` structure."
msgstr ""

#: ../../c-api/unicode.rst:89
msgid ""
"The following APIs are C macros and static inlined functions for fast checks "
"and access to internal read-only data of Unicode objects:"
msgstr ""

#: ../../c-api/unicode.rst:94
msgid ""
"Return true if the object *obj* is a Unicode object or an instance of a "
"Unicode subtype.  This function always succeeds."
msgstr ""

#: ../../c-api/unicode.rst:100
msgid ""
"Return true if the object *obj* is a Unicode object, but not an instance of "
"a subtype.  This function always succeeds."
msgstr ""

#: ../../c-api/unicode.rst:106
msgid ""
"Return the length of the Unicode string, in code points.  *unicode* has to "
"be a Unicode object in the \"canonical\" representation (not checked)."
msgstr ""

#: ../../c-api/unicode.rst:116
msgid ""
"Return a pointer to the canonical representation cast to UCS1, UCS2 or UCS4 "
"integer types for direct character access.  No checks are performed if the "
"canonical representation has the correct character size; use :c:func:"
"`PyUnicode_KIND` to select the right function."
msgstr ""

#: ../../c-api/unicode.rst:128
msgid "Return values of the :c:func:`PyUnicode_KIND` macro."
msgstr ""

#: ../../c-api/unicode.rst:132
msgid "``PyUnicode_WCHAR_KIND`` has been removed."
msgstr "``PyUnicode_WCHAR_KIND`` 已被移除。"

#: ../../c-api/unicode.rst:138
msgid ""
"Return one of the PyUnicode kind constants (see above) that indicate how "
"many bytes per character this Unicode object uses to store its data.  "
"*unicode* has to be a Unicode object in the \"canonical\" representation "
"(not checked)."
msgstr ""

#: ../../c-api/unicode.rst:147
msgid ""
"Return a void pointer to the raw Unicode buffer.  *unicode* has to be a "
"Unicode object in the \"canonical\" representation (not checked)."
msgstr ""

#: ../../c-api/unicode.rst:156
msgid ""
"Write the code point *value* to the given zero-based *index* in a string."
msgstr ""

#: ../../c-api/unicode.rst:158
msgid ""
"The *kind* value and *data* pointer must have been obtained from a string "
"using :c:func:`PyUnicode_KIND` and :c:func:`PyUnicode_DATA` respectively. "
"You must hold a reference to that string while calling :c:func:`!"
"PyUnicode_WRITE`. All requirements of :c:func:`PyUnicode_WriteChar` also "
"apply."
msgstr ""

#: ../../c-api/unicode.rst:164
msgid ""
"The function performs no checks for any of its requirements, and is intended "
"for usage in loops."
msgstr ""

#: ../../c-api/unicode.rst:173
msgid ""
"Read a code point from a canonical representation *data* (as obtained with :"
"c:func:`PyUnicode_DATA`).  No checks or ready calls are performed."
msgstr ""

#: ../../c-api/unicode.rst:181
msgid ""
"Read a character from a Unicode object *unicode*, which must be in the "
"\"canonical\" representation.  This is less efficient than :c:func:"
"`PyUnicode_READ` if you do multiple consecutive reads."
msgstr ""

#: ../../c-api/unicode.rst:190
msgid ""
"Return the maximum code point that is suitable for creating another string "
"based on *unicode*, which must be in the \"canonical\" representation.  This "
"is always an approximation but more efficient than iterating over the string."
msgstr ""

#: ../../c-api/unicode.rst:199
msgid ""
"Return ``1`` if the string is a valid identifier according to the language "
"definition, section :ref:`identifiers`. Return ``0`` otherwise."
msgstr ""

#: ../../c-api/unicode.rst:202
msgid ""
"The function does not call :c:func:`Py_FatalError` anymore if the string is "
"not ready."
msgstr ""

#: ../../c-api/unicode.rst:209
msgid ""
"Return true if the string only contains ASCII characters. Equivalent to :py:"
"meth:`str.isascii`."
msgstr ""

#: ../../c-api/unicode.rst:216
msgid "Unicode Character Properties"
msgstr ""

#: ../../c-api/unicode.rst:218
msgid ""
"Unicode provides many different character properties. The most often needed "
"ones are available through these macros which are mapped to C functions "
"depending on the Python configuration."
msgstr ""

#: ../../c-api/unicode.rst:225
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a whitespace character."
msgstr "根據 *ch* 是否為空白字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:230
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a lowercase character."
msgstr "根據 *ch* 是否為小寫字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:235
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is an uppercase character."
msgstr "根據 *ch* 是否為大寫字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:240
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a titlecase character."
msgstr "根據 *ch* 是否為首字大寫字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:245
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a linebreak character."
msgstr "根據 *ch* 是否為換行字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:250
msgid "Return ``1`` or ``0`` depending on whether *ch* is a decimal character."
msgstr "根據 *ch* 是否為十進位字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:255
msgid "Return ``1`` or ``0`` depending on whether *ch* is a digit character."
msgstr "根據 *ch* 是否為數字 (digit) 字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:260
msgid "Return ``1`` or ``0`` depending on whether *ch* is a numeric character."
msgstr "根據 *ch* 是否為數值 (numeric) 字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:265
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is an alphabetic character."
msgstr "根據 *ch* 是否為字母字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:270
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is an alphanumeric character."
msgstr "根據 *ch* 是否為字母數字 (alphanumeric) 字元來回傳 ``1`` 或 ``0``。"

#: ../../c-api/unicode.rst:275
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a printable character, in "
"the sense of :meth:`str.isprintable`."
msgstr ""
"根據 *ch* 是否為可列印字元（如 :meth:`str.isprintable` 所定義）來回傳 ``1`` "
"或 ``0``。"

#: ../../c-api/unicode.rst:279
msgid "These APIs can be used for fast direct character conversions:"
msgstr "這些 API 可用於快速直接字元轉換："

#: ../../c-api/unicode.rst:284
msgid "Return the character *ch* converted to lower case."
msgstr "回傳轉換為小寫的 *ch* 字元。"

#: ../../c-api/unicode.rst:289
msgid "Return the character *ch* converted to upper case."
msgstr "回傳轉換為大寫的 *ch* 字元。"

#: ../../c-api/unicode.rst:294
msgid "Return the character *ch* converted to title case."
msgstr "回傳轉換為首字大寫的 *ch* 字元。"

#: ../../c-api/unicode.rst:299
msgid ""
"Return the character *ch* converted to a decimal positive integer.  Return "
"``-1`` if this is not possible.  This function does not raise exceptions."
msgstr ""
"回傳轉換為十進位正整數的 *ch* 字元，若無法轉換則回傳 ``-1``。此函式不會引發例"
"外。"

#: ../../c-api/unicode.rst:305
msgid ""
"Return the character *ch* converted to a single digit integer. Return ``-1`` "
"if this is not possible.  This function does not raise exceptions."
msgstr ""
"回傳轉換為單一數字整數的 *ch* 字元，若無法轉換則回傳 ``-1``。此函式不會引發例"
"外。"

#: ../../c-api/unicode.rst:311
msgid ""
"Return the character *ch* converted to a double. Return ``-1.0`` if this is "
"not possible.  This function does not raise exceptions."
msgstr ""
"回傳轉換為雙精度浮點數 (double) 的 *ch* 字元，若無法轉換則回傳 ``-1.0``。此函"
"式不會引發例外。"

#: ../../c-api/unicode.rst:315
msgid "These APIs can be used to work with surrogates:"
msgstr "這些 API 可用於處理代理字元："

#: ../../c-api/unicode.rst:319
msgid "Check if *ch* is a surrogate (``0xD800 <= ch <= 0xDFFF``)."
msgstr "檢查 *ch* 是否為代理字元 (surrogate, ``0xD800 <= ch <= 0xDFFF``)。"

#: ../../c-api/unicode.rst:323
msgid "Check if *ch* is a high surrogate (``0xD800 <= ch <= 0xDBFF``)."
msgstr ""
"檢查 *ch* 是否為高代理字元 (high surrogate, ``0xD800 <= ch <= 0xDBFF``)。"

#: ../../c-api/unicode.rst:327
msgid "Check if *ch* is a low surrogate (``0xDC00 <= ch <= 0xDFFF``)."
msgstr ""
"檢查 *ch* 是否為低代理字元 (low surrogate, ``0xDC00 <= ch <= 0xDFFF``)。"

#: ../../c-api/unicode.rst:331
msgid ""
"Return the high UTF-16 surrogate (``0xD800`` to ``0xDBFF``) for a Unicode "
"code point in the range ``[0x10000; 0x10FFFF]``."
msgstr ""

#: ../../c-api/unicode.rst:336
msgid ""
"Return the low UTF-16 surrogate (``0xDC00`` to ``0xDFFF``) for a Unicode "
"code point in the range ``[0x10000; 0x10FFFF]``."
msgstr ""

#: ../../c-api/unicode.rst:341
msgid ""
"Join two surrogate code points and return a single :c:type:`Py_UCS4` value. "
"*high* and *low* are respectively the leading and trailing surrogates in a "
"surrogate pair. *high* must be in the range ``[0xD800; 0xDBFF]`` and *low* "
"must be in the range ``[0xDC00; 0xDFFF]``."
msgstr ""

#: ../../c-api/unicode.rst:348
msgid "Creating and accessing Unicode strings"
msgstr ""

#: ../../c-api/unicode.rst:350
msgid ""
"To create Unicode objects and access their basic sequence properties, use "
"these APIs:"
msgstr ""

#: ../../c-api/unicode.rst:355
msgid ""
"Create a new Unicode object.  *maxchar* should be the true maximum code "
"point to be placed in the string.  As an approximation, it can be rounded up "
"to the nearest value in the sequence 127, 255, 65535, 1114111."
msgstr ""

#: ../../c-api/unicode.rst:359
msgid "On error, set an exception and return ``NULL``."
msgstr ""

#: ../../c-api/unicode.rst:361
msgid ""
"After creation, the string can be filled by :c:func:`PyUnicode_WriteChar`, :"
"c:func:`PyUnicode_CopyCharacters`, :c:func:`PyUnicode_Fill`, :c:func:"
"`PyUnicode_WRITE` or similar. Since strings are supposed to be immutable, "
"take care to not “use” the result while it is being modified. In particular, "
"before it's filled with its final contents, a string:"
msgstr ""

#: ../../c-api/unicode.rst:368
msgid "must not be hashed,"
msgstr ""

#: ../../c-api/unicode.rst:369
msgid ""
"must not be :c:func:`converted to UTF-8 <PyUnicode_AsUTF8AndSize>`, or "
"another non-\"canonical\" representation,"
msgstr ""

#: ../../c-api/unicode.rst:371
msgid "must not have its reference count changed,"
msgstr ""

#: ../../c-api/unicode.rst:372
msgid "must not be shared with code that might do one of the above."
msgstr ""

#: ../../c-api/unicode.rst:374
msgid ""
"This list is not exhaustive. Avoiding these uses is your responsibility; "
"Python does not always check these requirements."
msgstr ""

#: ../../c-api/unicode.rst:377
msgid ""
"To avoid accidentally exposing a partially-written string object, prefer "
"using the :c:type:`PyUnicodeWriter` API, or one of the ``PyUnicode_From*`` "
"functions below."
msgstr ""

#: ../../c-api/unicode.rst:388
msgid ""
"Create a new Unicode object with the given *kind* (possible values are :c:"
"macro:`PyUnicode_1BYTE_KIND` etc., as returned by :c:func:"
"`PyUnicode_KIND`).  The *buffer* must point to an array of *size* units of "
"1, 2 or 4 bytes per character, as given by the kind."
msgstr ""

#: ../../c-api/unicode.rst:393
msgid ""
"If necessary, the input *buffer* is copied and transformed into the "
"canonical representation.  For example, if the *buffer* is a UCS4 string (:c:"
"macro:`PyUnicode_4BYTE_KIND`) and it consists only of codepoints in the UCS1 "
"range, it will be transformed into UCS1 (:c:macro:`PyUnicode_1BYTE_KIND`)."
msgstr ""

#: ../../c-api/unicode.rst:404
msgid ""
"Create a Unicode object from the char buffer *str*.  The bytes will be "
"interpreted as being UTF-8 encoded.  The buffer is copied into the new "
"object. The return value might be a shared object, i.e. modification of the "
"data is not allowed."
msgstr ""

#: ../../c-api/unicode.rst:410
msgid "This function raises :exc:`SystemError` when:"
msgstr "此函式在以下情況下會引發 :exc:`SystemError`："

#: ../../c-api/unicode.rst:412
msgid "*size* < 0,"
msgstr "*size* < 0，"

#: ../../c-api/unicode.rst:413
msgid "*str* is ``NULL`` and *size* > 0"
msgstr "*str* 為 ``NULL`` 且 *size* > 0"

#: ../../c-api/unicode.rst:415
msgid "*str* == ``NULL`` with *size* > 0 is not allowed anymore."
msgstr "*str* == ``NULL`` 且 *size* > 0 不再被允許。"

#: ../../c-api/unicode.rst:421
msgid ""
"Create a Unicode object from a UTF-8 encoded null-terminated char buffer "
"*str*."
msgstr ""

#: ../../c-api/unicode.rst:427
msgid ""
"Take a C :c:func:`printf`\\ -style *format* string and a variable number of "
"arguments, calculate the size of the resulting Python Unicode string and "
"return a string with the values formatted into it.  The variable arguments "
"must be C types and must correspond exactly to the format characters in the "
"*format* ASCII-encoded string."
msgstr ""

#: ../../c-api/unicode.rst:433
msgid ""
"A conversion specifier contains two or more characters and has the following "
"components, which must occur in this order:"
msgstr ""

#: ../../c-api/unicode.rst:436
msgid "The ``'%'`` character, which marks the start of the specifier."
msgstr ""

#: ../../c-api/unicode.rst:438
msgid ""
"Conversion flags (optional), which affect the result of some conversion "
"types."
msgstr ""

#: ../../c-api/unicode.rst:441
msgid ""
"Minimum field width (optional). If specified as an ``'*'`` (asterisk), the "
"actual width is given in the next argument, which must be of type :c:expr:"
"`int`, and the object to convert comes after the minimum field width and "
"optional precision."
msgstr ""

#: ../../c-api/unicode.rst:446
msgid ""
"Precision (optional), given as a ``'.'`` (dot) followed by the precision. If "
"specified as ``'*'`` (an asterisk), the actual precision is given in the "
"next argument, which must be of type :c:expr:`int`, and the value to convert "
"comes after the precision."
msgstr ""

#: ../../c-api/unicode.rst:451
msgid "Length modifier (optional)."
msgstr ""

#: ../../c-api/unicode.rst:453
msgid "Conversion type."
msgstr ""

#: ../../c-api/unicode.rst:455
msgid "The conversion flag characters are:"
msgstr ""

#: ../../c-api/unicode.rst:460
msgid "Flag"
msgstr "旗標"

#: ../../c-api/unicode.rst:460
msgid "Meaning"
msgstr "含義"

#: ../../c-api/unicode.rst:462
msgid "``0``"
msgstr "``0``"

#: ../../c-api/unicode.rst:462
msgid "The conversion will be zero padded for numeric values."
msgstr ""

#: ../../c-api/unicode.rst:464
msgid "``-``"
msgstr "``-``"

#: ../../c-api/unicode.rst:464
msgid ""
"The converted value is left adjusted (overrides the ``0`` flag if both are "
"given)."
msgstr ""

#: ../../c-api/unicode.rst:468
msgid ""
"The length modifiers for following integer conversions (``d``, ``i``, ``o``, "
"``u``, ``x``, or ``X``) specify the type of the argument (:c:expr:`int` by "
"default):"
msgstr ""

#: ../../c-api/unicode.rst:475
msgid "Modifier"
msgstr ""

#: ../../c-api/unicode.rst:475
msgid "Types"
msgstr ""

#: ../../c-api/unicode.rst:477
msgid "``l``"
msgstr "``l``"

#: ../../c-api/unicode.rst:477
msgid ":c:expr:`long` or :c:expr:`unsigned long`"
msgstr ":c:expr:`long` 或 :c:expr:`unsigned long`"

#: ../../c-api/unicode.rst:479
msgid "``ll``"
msgstr "``ll``"

#: ../../c-api/unicode.rst:479
msgid ":c:expr:`long long` or :c:expr:`unsigned long long`"
msgstr ":c:expr:`long long` 或 :c:expr:`unsigned long long`"

#: ../../c-api/unicode.rst:481
msgid "``j``"
msgstr "``j``"

#: ../../c-api/unicode.rst:481
msgid ":c:type:`intmax_t` or :c:type:`uintmax_t`"
msgstr ":c:type:`intmax_t` 或 :c:type:`uintmax_t`"

#: ../../c-api/unicode.rst:483
msgid "``z``"
msgstr "``z``"

#: ../../c-api/unicode.rst:483
msgid ":c:type:`size_t` or :c:type:`ssize_t`"
msgstr ":c:type:`size_t` 或 :c:type:`ssize_t`"

#: ../../c-api/unicode.rst:485
msgid "``t``"
msgstr "``t``"

#: ../../c-api/unicode.rst:485
msgid ":c:type:`ptrdiff_t`"
msgstr ":c:type:`ptrdiff_t`"

#: ../../c-api/unicode.rst:488
msgid ""
"The length modifier ``l`` for following conversions ``s`` or ``V`` specify "
"that the type of the argument is :c:expr:`const wchar_t*`."
msgstr ""

#: ../../c-api/unicode.rst:491
msgid "The conversion specifiers are:"
msgstr ""

#: ../../c-api/unicode.rst:497
msgid "Conversion Specifier"
msgstr ""

#: ../../c-api/unicode.rst:498
msgid "Type"
msgstr ""

#: ../../c-api/unicode.rst:499
msgid "Comment"
msgstr ""

#: ../../c-api/unicode.rst:501
msgid "``%``"
msgstr "``%``"

#: ../../c-api/unicode.rst:502
msgid "*n/a*"
msgstr "*n/a*"

#: ../../c-api/unicode.rst:503
msgid "The literal ``%`` character."
msgstr "字面 ``%`` 字元。"

#: ../../c-api/unicode.rst:505
msgid "``d``, ``i``"
msgstr "``d``, ``i``"

#: ../../c-api/unicode.rst:506 ../../c-api/unicode.rst:510
#: ../../c-api/unicode.rst:514 ../../c-api/unicode.rst:518
#: ../../c-api/unicode.rst:522
msgid "Specified by the length modifier"
msgstr ""

#: ../../c-api/unicode.rst:507
msgid "The decimal representation of a signed C integer."
msgstr "一個有符號 C 整數的十進位表示法。"

#: ../../c-api/unicode.rst:509
msgid "``u``"
msgstr "``u``"

#: ../../c-api/unicode.rst:511
msgid "The decimal representation of an unsigned C integer."
msgstr "一個無符號 C 整數的十進位表示法。"

#: ../../c-api/unicode.rst:513
msgid "``o``"
msgstr "``o``"

#: ../../c-api/unicode.rst:515
msgid "The octal representation of an unsigned C integer."
msgstr "一個無符號 C 整數的八進位表示法。"

#: ../../c-api/unicode.rst:517
msgid "``x``"
msgstr "``x``"

#: ../../c-api/unicode.rst:519
msgid "The hexadecimal representation of an unsigned C integer (lowercase)."
msgstr "一個無符號 C 整數的十六進位表示法（小寫）。"

#: ../../c-api/unicode.rst:521
msgid "``X``"
msgstr "``X``"

#: ../../c-api/unicode.rst:523
msgid "The hexadecimal representation of an unsigned C integer (uppercase)."
msgstr "一個無符號 C 整數的十六進位表示法（大寫）。"

#: ../../c-api/unicode.rst:525
msgid "``c``"
msgstr "``c``"

#: ../../c-api/unicode.rst:526
msgid ":c:expr:`int`"
msgstr ":c:expr:`int`"

#: ../../c-api/unicode.rst:527
msgid "A single character."
msgstr "一個單一字元。"

#: ../../c-api/unicode.rst:529
msgid "``s``"
msgstr "``s``"

#: ../../c-api/unicode.rst:530
msgid ":c:expr:`const char*` or :c:expr:`const wchar_t*`"
msgstr ":c:expr:`const char*` 或 :c:expr:`const wchar_t*`"

#: ../../c-api/unicode.rst:531
msgid "A null-terminated C character array."
msgstr "一個以 null 結尾的 C 字元陣列。"

#: ../../c-api/unicode.rst:533
msgid "``p``"
msgstr "``p``"

#: ../../c-api/unicode.rst:534
msgid ":c:expr:`const void*`"
msgstr ":c:expr:`const void*`"

#: ../../c-api/unicode.rst:535
msgid ""
"The hex representation of a C  pointer. Mostly equivalent to "
"``printf(\"%p\")`` except that it is guaranteed to start with the literal "
"``0x`` regardless of what the platform's ``printf`` yields."
msgstr ""

#: ../../c-api/unicode.rst:540
msgid "``A``"
msgstr "``A``"

#: ../../c-api/unicode.rst:541 ../../c-api/unicode.rst:545
#: ../../c-api/unicode.rst:555 ../../c-api/unicode.rst:559
#: ../../c-api/unicode.rst:563 ../../c-api/unicode.rst:568
msgid ":c:expr:`PyObject*`"
msgstr ":c:expr:`PyObject*`"

#: ../../c-api/unicode.rst:542
msgid "The result of calling :func:`ascii`."
msgstr "呼叫 :func:`ascii` 的結果。"

#: ../../c-api/unicode.rst:544
msgid "``U``"
msgstr "``U``"

#: ../../c-api/unicode.rst:546
msgid "A Unicode object."
msgstr "一個 Unicode 物件。"

#: ../../c-api/unicode.rst:548
msgid "``V``"
msgstr "``V``"

#: ../../c-api/unicode.rst:549
msgid ":c:expr:`PyObject*`, :c:expr:`const char*` or :c:expr:`const wchar_t*`"
msgstr ":c:expr:`PyObject*`、:c:expr:`const char*` 或 :c:expr:`const wchar_t*`"

#: ../../c-api/unicode.rst:550
msgid ""
"A Unicode object (which may be ``NULL``) and a null-terminated C character "
"array as a second parameter (which will be used, if the first parameter is "
"``NULL``)."
msgstr ""

#: ../../c-api/unicode.rst:554
msgid "``S``"
msgstr "``S``"

#: ../../c-api/unicode.rst:556
msgid "The result of calling :c:func:`PyObject_Str`."
msgstr "呼叫 :c:func:`PyObject_Str` 的結果。"

#: ../../c-api/unicode.rst:558
msgid "``R``"
msgstr "``R``"

#: ../../c-api/unicode.rst:560
msgid "The result of calling :c:func:`PyObject_Repr`."
msgstr "呼叫 :c:func:`PyObject_Repr` 的結果。"

#: ../../c-api/unicode.rst:562
msgid "``T``"
msgstr "``T``"

#: ../../c-api/unicode.rst:564
msgid ""
"Get the fully qualified name of an object type; call :c:func:"
"`PyType_GetFullyQualifiedName`."
msgstr ""

#: ../../c-api/unicode.rst:567
msgid "``#T``"
msgstr "``#T``"

#: ../../c-api/unicode.rst:569
msgid ""
"Similar to ``T`` format, but use a colon (``:``) as separator between the "
"module name and the qualified name."
msgstr ""

#: ../../c-api/unicode.rst:572
msgid "``N``"
msgstr "``N``"

#: ../../c-api/unicode.rst:573 ../../c-api/unicode.rst:578
msgid ":c:expr:`PyTypeObject*`"
msgstr ":c:expr:`PyTypeObject*`"

#: ../../c-api/unicode.rst:574
msgid ""
"Get the fully qualified name of a type; call :c:func:"
"`PyType_GetFullyQualifiedName`."
msgstr ""

#: ../../c-api/unicode.rst:577
msgid "``#N``"
msgstr "``#N``"

#: ../../c-api/unicode.rst:579
msgid ""
"Similar to ``N`` format, but use a colon (``:``) as separator between the "
"module name and the qualified name."
msgstr ""

#: ../../c-api/unicode.rst:583
msgid ""
"The width formatter unit is number of characters rather than bytes. The "
"precision formatter unit is number of bytes or :c:type:`wchar_t` items (if "
"the length modifier ``l`` is used) for ``\"%s\"`` and ``\"%V\"`` (if the "
"``PyObject*`` argument is ``NULL``), and a number of characters for "
"``\"%A\"``, ``\"%U\"``, ``\"%S\"``, ``\"%R\"`` and ``\"%V\"`` (if the "
"``PyObject*`` argument is not ``NULL``)."
msgstr ""

#: ../../c-api/unicode.rst:591
msgid ""
"Unlike to C :c:func:`printf` the ``0`` flag has effect even when a precision "
"is given for integer conversions (``d``, ``i``, ``u``, ``o``, ``x``, or "
"``X``)."
msgstr ""

#: ../../c-api/unicode.rst:595
msgid "Support for ``\"%lld\"`` and ``\"%llu\"`` added."
msgstr "新增對 ``\"%lld\"`` 和 ``\"%llu\"`` 的支援。"

#: ../../c-api/unicode.rst:598
msgid "Support for ``\"%li\"``, ``\"%lli\"`` and ``\"%zi\"`` added."
msgstr "新增對 ``\"%li\"``、``\"%lli\"`` 和 ``\"%zi\"`` 的支援。"

#: ../../c-api/unicode.rst:601
msgid ""
"Support width and precision formatter for ``\"%s\"``, ``\"%A\"``, "
"``\"%U\"``, ``\"%V\"``, ``\"%S\"``, ``\"%R\"`` added."
msgstr ""
"新增對 ``\"%s\"``、``\"%A\"``、``\"%U\"``、``\"%V\"``、``\"%S\"``、"
"``\"%R\"`` 的寬度和精確度格式化支援。"

#: ../../c-api/unicode.rst:605
msgid ""
"Support for conversion specifiers ``o`` and ``X``. Support for length "
"modifiers ``j`` and ``t``. Length modifiers are now applied to all integer "
"conversions. Length modifier ``l`` is now applied to conversion specifiers "
"``s`` and ``V``. Support for variable width and precision ``*``. Support for "
"flag ``-``."
msgstr ""

#: ../../c-api/unicode.rst:613
msgid ""
"An unrecognized format character now sets a :exc:`SystemError`. In previous "
"versions it caused all the rest of the format string to be copied as-is to "
"the result string, and any extra arguments discarded."
msgstr ""

#: ../../c-api/unicode.rst:617
msgid "Support for ``%T``, ``%#T``, ``%N`` and ``%#N`` formats added."
msgstr "新增對 ``%T``、``%#T``、``%N`` 和 ``%#N`` 格式的支援。"

#: ../../c-api/unicode.rst:623
msgid ""
"Identical to :c:func:`PyUnicode_FromFormat` except that it takes exactly two "
"arguments."
msgstr ""

#: ../../c-api/unicode.rst:629
msgid ""
"Copy an instance of a Unicode subtype to a new true Unicode object if "
"necessary. If *obj* is already a true Unicode object (not a subtype), return "
"a new :term:`strong reference` to the object."
msgstr ""

#: ../../c-api/unicode.rst:633
msgid ""
"Objects other than Unicode or its subtypes will cause a :exc:`TypeError`."
msgstr ""

#: ../../c-api/unicode.rst:638
msgid "Create a Unicode Object from the given Unicode code point *ordinal*."
msgstr ""

#: ../../c-api/unicode.rst:640
msgid ""
"The ordinal must be in ``range(0x110000)``. A :exc:`ValueError` is raised in "
"the case it is not."
msgstr ""

#: ../../c-api/unicode.rst:647
msgid "Decode an encoded object *obj* to a Unicode object."
msgstr ""

#: ../../c-api/unicode.rst:649
msgid ""
":class:`bytes`, :class:`bytearray` and other :term:`bytes-like objects "
"<bytes-like object>` are decoded according to the given *encoding* and using "
"the error handling defined by *errors*. Both can be ``NULL`` to have the "
"interface use the default values (see :ref:`builtincodecs` for details)."
msgstr ""

#: ../../c-api/unicode.rst:655
msgid ""
"All other objects, including Unicode objects, cause a :exc:`TypeError` to be "
"set."
msgstr ""

#: ../../c-api/unicode.rst:658
msgid ""
"The API returns ``NULL`` if there was an error.  The caller is responsible "
"for decref'ing the returned objects."
msgstr ""

#: ../../c-api/unicode.rst:664
msgid ""
"Append the string *right* to the end of *p_left*. *p_left* must point to a :"
"term:`strong reference` to a Unicode object; :c:func:`!PyUnicode_Append` "
"releases (\"steals\") this reference."
msgstr ""

#: ../../c-api/unicode.rst:668
msgid "On error, set *\\*p_left* to ``NULL`` and set an exception."
msgstr "於錯誤發生時，將 *\\*p_left* 設為 ``NULL`` 並設定例外。"

#: ../../c-api/unicode.rst:670
msgid "On success, set *\\*p_left* to a new strong reference to the result."
msgstr ""

#: ../../c-api/unicode.rst:675
msgid ""
"The function is similar to :c:func:`PyUnicode_Append`, with the only "
"difference being that it decrements the reference count of *right* by one."
msgstr ""

#: ../../c-api/unicode.rst:681
msgid ""
"Return a mapping suitable for decoding a custom single-byte encoding. Given "
"a Unicode string *string* of up to 256 characters representing an encoding "
"table, returns either a compact internal mapping object or a dictionary "
"mapping character ordinals to byte values. Raises a :exc:`TypeError` and "
"return ``NULL`` on invalid input."
msgstr ""

#: ../../c-api/unicode.rst:692
msgid ""
"Return the name of the default string encoding, ``\"utf-8\"``. See :func:"
"`sys.getdefaultencoding`."
msgstr ""

#: ../../c-api/unicode.rst:695
msgid ""
"The returned string does not need to be freed, and is valid until "
"interpreter shutdown."
msgstr ""

#: ../../c-api/unicode.rst:701
msgid "Return the length of the Unicode object, in code points."
msgstr ""

#: ../../c-api/unicode.rst:703
msgid "On error, set an exception and return ``-1``."
msgstr "發生錯誤時，設定例外並回傳 ``-1``。"

#: ../../c-api/unicode.rst:714
msgid ""
"Copy characters from one Unicode object into another.  This function "
"performs character conversion when necessary and falls back to :c:func:`!"
"memcpy` if possible.  Returns ``-1`` and sets an exception on error, "
"otherwise returns the number of copied characters."
msgstr ""

#: ../../c-api/unicode.rst:719 ../../c-api/unicode.rst:749
#: ../../c-api/unicode.rst:769
msgid ""
"The string must not have been “used” yet. See :c:func:`PyUnicode_New` for "
"details."
msgstr ""

#: ../../c-api/unicode.rst:727
msgid ""
"Resize a Unicode object *\\*unicode* to the new *length* in code points."
msgstr ""

#: ../../c-api/unicode.rst:729
msgid ""
"Try to resize the string in place (which is usually faster than allocating a "
"new string and copying characters), or create a new string."
msgstr ""

#: ../../c-api/unicode.rst:732
msgid ""
"*\\*unicode* is modified to point to the new (resized) object and ``0`` is "
"returned on success. Otherwise, ``-1`` is returned and an exception is set, "
"and *\\*unicode* is left untouched."
msgstr ""

#: ../../c-api/unicode.rst:736
msgid ""
"The function doesn't check string content, the result may not be a string in "
"canonical representation."
msgstr ""

#: ../../c-api/unicode.rst:743
msgid ""
"Fill a string with a character: write *fill_char* into ``unicode[start:"
"start+length]``."
msgstr ""

#: ../../c-api/unicode.rst:746
msgid ""
"Fail if *fill_char* is bigger than the string maximum character, or if the "
"string has more than 1 reference."
msgstr ""

#: ../../c-api/unicode.rst:752
msgid ""
"Return the number of written character, or return ``-1`` and raise an "
"exception on error."
msgstr ""

#: ../../c-api/unicode.rst:761
msgid ""
"Write a *character* to the string *unicode* at the zero-based *index*. "
"Return ``0`` on success, ``-1`` on error with an exception set."
msgstr ""

#: ../../c-api/unicode.rst:764
msgid ""
"This function checks that *unicode* is a Unicode object, that the index is "
"not out of bounds, and that the object's reference count is one. See :c:func:"
"`PyUnicode_WRITE` for a version that skips these checks, making them your "
"responsibility."
msgstr ""

#: ../../c-api/unicode.rst:777
msgid ""
"Read a character from a string.  This function checks that *unicode* is a "
"Unicode object and the index is not out of bounds, in contrast to :c:func:"
"`PyUnicode_READ_CHAR`, which performs no error checking."
msgstr ""

#: ../../c-api/unicode.rst:781
msgid "Return character on success, ``-1`` on error with an exception set."
msgstr "成功時回傳字元，發生錯誤時設定例外並回傳 ``-1``。"

#: ../../c-api/unicode.rst:789
msgid ""
"Return a substring of *unicode*, from character index *start* (included) to "
"character index *end* (excluded).  Negative indices are not supported. On "
"error, set an exception and return ``NULL``."
msgstr ""

#: ../../c-api/unicode.rst:799
msgid ""
"Copy the string *unicode* into a UCS4 buffer, including a null character, if "
"*copy_null* is set.  Returns ``NULL`` and sets an exception on error (in "
"particular, a :exc:`SystemError` if *buflen* is smaller than the length of "
"*unicode*).  *buffer* is returned on success."
msgstr ""

#: ../../c-api/unicode.rst:809
msgid ""
"Copy the string *unicode* into a new UCS4 buffer that is allocated using :c:"
"func:`PyMem_Malloc`.  If this fails, ``NULL`` is returned with a :exc:"
"`MemoryError` set.  The returned buffer always has an extra null code point "
"appended."
msgstr ""

#: ../../c-api/unicode.rst:818
msgid "Locale Encoding"
msgstr ""

#: ../../c-api/unicode.rst:820
msgid ""
"The current locale encoding can be used to decode text from the operating "
"system."
msgstr ""

#: ../../c-api/unicode.rst:827
msgid ""
"Decode a string from UTF-8 on Android and VxWorks, or from the current "
"locale encoding on other platforms. The supported error handlers are "
"``\"strict\"`` and ``\"surrogateescape\"`` (:pep:`383`). The decoder uses "
"``\"strict\"`` error handler if *errors* is ``NULL``.  *str* must end with a "
"null character but cannot contain embedded null characters."
msgstr ""

#: ../../c-api/unicode.rst:834
msgid ""
"Use :c:func:`PyUnicode_DecodeFSDefaultAndSize` to decode a string from the :"
"term:`filesystem encoding and error handler`."
msgstr ""

#: ../../c-api/unicode.rst:837 ../../c-api/unicode.rst:872
msgid "This function ignores the :ref:`Python UTF-8 Mode <utf8-mode>`."
msgstr "此函式會忽略 :ref:`Python UTF-8 模式 <utf8-mode>`。"

#: ../../c-api/unicode.rst:841 ../../c-api/unicode.rst:957
msgid "The :c:func:`Py_DecodeLocale` function."
msgstr ":c:func:`Py_DecodeLocale` 函式。"

#: ../../c-api/unicode.rst:845
msgid ""
"The function now also uses the current locale encoding for the "
"``surrogateescape`` error handler, except on Android. Previously, :c:func:"
"`Py_DecodeLocale` was used for the ``surrogateescape``, and the current "
"locale encoding was used for ``strict``."
msgstr ""

#: ../../c-api/unicode.rst:854
msgid ""
"Similar to :c:func:`PyUnicode_DecodeLocaleAndSize`, but compute the string "
"length using :c:func:`!strlen`."
msgstr ""
"類似於 :c:func:`PyUnicode_DecodeLocaleAndSize`，但使用 :c:func:`!strlen` 計算"
"字串長度。"

#: ../../c-api/unicode.rst:862
msgid ""
"Encode a Unicode object to UTF-8 on Android and VxWorks, or to the current "
"locale encoding on other platforms. The supported error handlers are "
"``\"strict\"`` and ``\"surrogateescape\"`` (:pep:`383`). The encoder uses "
"``\"strict\"`` error handler if *errors* is ``NULL``. Return a :class:"
"`bytes` object. *unicode* cannot contain embedded null characters."
msgstr ""

#: ../../c-api/unicode.rst:869
msgid ""
"Use :c:func:`PyUnicode_EncodeFSDefault` to encode a string to the :term:"
"`filesystem encoding and error handler`."
msgstr ""

#: ../../c-api/unicode.rst:876 ../../c-api/unicode.rst:988
msgid "The :c:func:`Py_EncodeLocale` function."
msgstr ":c:func:`Py_EncodeLocale` 函式。"

#: ../../c-api/unicode.rst:880
msgid ""
"The function now also uses the current locale encoding for the "
"``surrogateescape`` error handler, except on Android. Previously, :c:func:"
"`Py_EncodeLocale` was used for the ``surrogateescape``, and the current "
"locale encoding was used for ``strict``."
msgstr ""

#: ../../c-api/unicode.rst:889
msgid "File System Encoding"
msgstr "檔案系統編碼"

#: ../../c-api/unicode.rst:891
msgid ""
"Functions encoding to and decoding from the :term:`filesystem encoding and "
"error handler` (:pep:`383` and :pep:`529`)."
msgstr ""

#: ../../c-api/unicode.rst:894
msgid ""
"To encode file names to :class:`bytes` during argument parsing, the "
"``\"O&\"`` converter should be used, passing :c:func:`!"
"PyUnicode_FSConverter` as the conversion function:"
msgstr ""

#: ../../c-api/unicode.rst:900
msgid ""
":ref:`PyArg_Parse\\* converter <arg-parsing>`: encode :class:`str` objects "
"-- obtained directly or through the :class:`os.PathLike` interface -- to :"
"class:`bytes` using :c:func:`PyUnicode_EncodeFSDefault`; :class:`bytes` "
"objects are output as-is. *result* must be an address of a C variable of "
"type :c:expr:`PyObject*` (or :c:expr:`PyBytesObject*`). On success, set the "
"variable to a new :term:`strong reference` to a :ref:`bytes object "
"<bytesobjects>` which must be released when it is no longer used and return "
"a non-zero value (:c:macro:`Py_CLEANUP_SUPPORTED`). Embedded null bytes are "
"not allowed in the result. On failure, return ``0`` with an exception set."
msgstr ""

#: ../../c-api/unicode.rst:912
msgid ""
"If *obj* is ``NULL``, the function releases a strong reference stored in the "
"variable referred by *result* and returns ``1``."
msgstr ""

#: ../../c-api/unicode.rst:917 ../../c-api/unicode.rst:944
msgid "Accepts a :term:`path-like object`."
msgstr "接受一個 :term:`path-like object`。"

#: ../../c-api/unicode.rst:920
msgid ""
"To decode file names to :class:`str` during argument parsing, the ``\"O&\"`` "
"converter should be used, passing :c:func:`!PyUnicode_FSDecoder` as the "
"conversion function:"
msgstr ""

#: ../../c-api/unicode.rst:926
msgid ""
":ref:`PyArg_Parse\\* converter <arg-parsing>`: decode :class:`bytes` objects "
"-- obtained either directly or indirectly through the :class:`os.PathLike` "
"interface -- to :class:`str` using :c:func:"
"`PyUnicode_DecodeFSDefaultAndSize`; :class:`str` objects are output as-is. "
"*result* must be an address of a C variable of type :c:expr:`PyObject*` (or :"
"c:expr:`PyUnicodeObject*`). On success, set the variable to a new :term:"
"`strong reference` to a :ref:`Unicode object <unicodeobjects>` which must be "
"released when it is no longer used and return a non-zero value (:c:macro:"
"`Py_CLEANUP_SUPPORTED`). Embedded null characters are not allowed in the "
"result. On failure, return ``0`` with an exception set."
msgstr ""

#: ../../c-api/unicode.rst:939
msgid ""
"If *obj* is ``NULL``, release the strong reference to the object referred to "
"by *result* and return ``1``."
msgstr ""

#: ../../c-api/unicode.rst:950
msgid "Decode a string from the :term:`filesystem encoding and error handler`."
msgstr ""

#: ../../c-api/unicode.rst:952
msgid ""
"If you need to decode a string from the current locale encoding, use :c:func:"
"`PyUnicode_DecodeLocaleAndSize`."
msgstr ""

#: ../../c-api/unicode.rst:959 ../../c-api/unicode.rst:972
#: ../../c-api/unicode.rst:992
msgid ""
"The :term:`filesystem error handler <filesystem encoding and error handler>` "
"is now used."
msgstr ""

#: ../../c-api/unicode.rst:966
msgid ""
"Decode a null-terminated string from the :term:`filesystem encoding and "
"error handler`."
msgstr ""

#: ../../c-api/unicode.rst:969
msgid ""
"If the string length is known, use :c:func:"
"`PyUnicode_DecodeFSDefaultAndSize`."
msgstr "如果字串長度已知，請使用 :c:func:`PyUnicode_DecodeFSDefaultAndSize`。"

#: ../../c-api/unicode.rst:979
msgid ""
"Encode a Unicode object to the :term:`filesystem encoding and error "
"handler`, and return :class:`bytes`. Note that the resulting :class:`bytes` "
"object can contain null bytes."
msgstr ""

#: ../../c-api/unicode.rst:983
msgid ""
"If you need to encode a string to the current locale encoding, use :c:func:"
"`PyUnicode_EncodeLocale`."
msgstr ""

#: ../../c-api/unicode.rst:997
msgid "wchar_t Support"
msgstr "wchar_t 支援"

#: ../../c-api/unicode.rst:999
msgid ":c:type:`wchar_t` support for platforms which support it:"
msgstr "對支援 :c:type:`wchar_t` 的平台提供支援："

#: ../../c-api/unicode.rst:1003
msgid ""
"Create a Unicode object from the :c:type:`wchar_t` buffer *wstr* of the "
"given *size*. Passing ``-1`` as the *size* indicates that the function must "
"itself compute the length, using :c:func:`!wcslen`. Return ``NULL`` on "
"failure."
msgstr ""

#: ../../c-api/unicode.rst:1011
msgid ""
"Copy the Unicode object contents into the :c:type:`wchar_t` buffer *wstr*.  "
"At most *size* :c:type:`wchar_t` characters are copied (excluding a possibly "
"trailing null termination character).  Return the number of :c:type:"
"`wchar_t` characters copied or ``-1`` in case of an error."
msgstr ""

#: ../../c-api/unicode.rst:1016
msgid ""
"When *wstr* is ``NULL``, instead return the *size* that would be required to "
"store all of *unicode* including a terminating null."
msgstr ""

#: ../../c-api/unicode.rst:1019
msgid ""
"Note that the resulting :c:expr:`wchar_t*` string may or may not be null-"
"terminated.  It is the responsibility of the caller to make sure that the :c:"
"expr:`wchar_t*` string is null-terminated in case this is required by the "
"application. Also, note that the :c:expr:`wchar_t*` string might contain "
"null characters, which would cause the string to be truncated when used with "
"most C functions."
msgstr ""

#: ../../c-api/unicode.rst:1029
msgid ""
"Convert the Unicode object to a wide character string. The output string "
"always ends with a null character. If *size* is not ``NULL``, write the "
"number of wide characters (excluding the trailing null termination "
"character) into *\\*size*. Note that the resulting :c:type:`wchar_t` string "
"might contain null characters, which would cause the string to be truncated "
"when used with most C functions. If *size* is ``NULL`` and the :c:expr:"
"`wchar_t*` string contains null characters a :exc:`ValueError` is raised."
msgstr ""

#: ../../c-api/unicode.rst:1037
msgid ""
"Returns a buffer allocated by :c:macro:`PyMem_New` (use :c:func:`PyMem_Free` "
"to free it) on success. On error, returns ``NULL`` and *\\*size* is "
"undefined. Raises a :exc:`MemoryError` if memory allocation is failed."
msgstr ""

#: ../../c-api/unicode.rst:1044
msgid ""
"Raises a :exc:`ValueError` if *size* is ``NULL`` and the :c:expr:`wchar_t*` "
"string contains null characters."
msgstr ""

#: ../../c-api/unicode.rst:1052
msgid "Built-in Codecs"
msgstr "內建編解碼器"

#: ../../c-api/unicode.rst:1054
msgid ""
"Python provides a set of built-in codecs which are written in C for speed. "
"All of these codecs are directly usable via the following functions."
msgstr ""

#: ../../c-api/unicode.rst:1057
msgid ""
"Many of the following APIs take two arguments encoding and errors, and they "
"have the same semantics as the ones of the built-in :func:`str` string "
"object constructor."
msgstr ""

#: ../../c-api/unicode.rst:1061
msgid ""
"Setting encoding to ``NULL`` causes the default encoding to be used which is "
"UTF-8.  The file system calls should use :c:func:`PyUnicode_FSConverter` for "
"encoding file names. This uses the :term:`filesystem encoding and error "
"handler` internally."
msgstr ""

#: ../../c-api/unicode.rst:1066
msgid ""
"Error handling is set by errors which may also be set to ``NULL`` meaning to "
"use the default handling defined for the codec.  Default error handling for "
"all built-in codecs is \"strict\" (:exc:`ValueError` is raised)."
msgstr ""

#: ../../c-api/unicode.rst:1070
msgid ""
"The codecs all use a similar interface.  Only deviations from the following "
"generic ones are documented for simplicity."
msgstr ""

#: ../../c-api/unicode.rst:1075
msgid "Generic Codecs"
msgstr "泛用編解碼器"

#: ../../c-api/unicode.rst:1077
msgid "The following macro is provided:"
msgstr ""

#: ../../c-api/unicode.rst:1082
msgid "The Unicode code point ``U+FFFD`` (replacement character)."
msgstr ""

#: ../../c-api/unicode.rst:1084
msgid ""
"This Unicode character is used as the replacement character during decoding "
"if the *errors* argument is set to \"replace\"."
msgstr ""

#: ../../c-api/unicode.rst:1088
msgid "These are the generic codec APIs:"
msgstr "這些是泛用編解碼器的 API："

#: ../../c-api/unicode.rst:1094
msgid ""
"Create a Unicode object by decoding *size* bytes of the encoded string "
"*str*. *encoding* and *errors* have the same meaning as the parameters of "
"the same name in the :func:`str` built-in function.  The codec to be used is "
"looked up using the Python codec registry.  Return ``NULL`` if an exception "
"was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1104
msgid ""
"Encode a Unicode object and return the result as Python bytes object. "
"*encoding* and *errors* have the same meaning as the parameters of the same "
"name in the Unicode :meth:`~str.encode` method. The codec to be used is "
"looked up using the Python codec registry. Return ``NULL`` if an exception "
"was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1112
msgid "UTF-8 Codecs"
msgstr "UTF-8 編解碼器"

#: ../../c-api/unicode.rst:1114
msgid "These are the UTF-8 codec APIs:"
msgstr "這些是 UTF-8 編解碼器的 API："

#: ../../c-api/unicode.rst:1119
msgid ""
"Create a Unicode object by decoding *size* bytes of the UTF-8 encoded string "
"*str*. Return ``NULL`` if an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1126
msgid ""
"If *consumed* is ``NULL``, behave like :c:func:`PyUnicode_DecodeUTF8`. If "
"*consumed* is not ``NULL``, trailing incomplete UTF-8 byte sequences will "
"not be treated as an error. Those bytes will not be decoded and the number "
"of bytes that have been decoded will be stored in *consumed*."
msgstr ""

#: ../../c-api/unicode.rst:1134
msgid ""
"Encode a Unicode object using UTF-8 and return the result as Python bytes "
"object.  Error handling is \"strict\".  Return ``NULL`` if an exception was "
"raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1138 ../../c-api/unicode.rst:1153
msgid ""
"The function fails if the string contains surrogate code points (``U+D800`` "
"- ``U+DFFF``)."
msgstr ""

#: ../../c-api/unicode.rst:1144
msgid ""
"Return a pointer to the UTF-8 encoding of the Unicode object, and store the "
"size of the encoded representation (in bytes) in *size*.  The *size* "
"argument can be ``NULL``; in this case no size will be stored.  The returned "
"buffer always has an extra null byte appended (not included in *size*), "
"regardless of whether there are any other null code points."
msgstr ""

#: ../../c-api/unicode.rst:1150
msgid ""
"On error, set an exception, set *size* to ``-1`` (if it's not NULL) and "
"return ``NULL``."
msgstr ""
"發生錯誤時，設定例外並將 *size* 設為 ``-1``\\ （如果不是 NULL），並回傳 "
"``NULL``。"

#: ../../c-api/unicode.rst:1156
msgid ""
"This caches the UTF-8 representation of the string in the Unicode object, "
"and subsequent calls will return a pointer to the same buffer.  The caller "
"is not responsible for deallocating the buffer. The buffer is deallocated "
"and pointers to it become invalid when the Unicode object is garbage "
"collected."
msgstr ""

#: ../../c-api/unicode.rst:1163 ../../c-api/unicode.rst:1185
msgid "The return type is now ``const char *`` rather of ``char *``."
msgstr "回傳型別現在是 ``const char *`` 而不是 ``char *``。"

#: ../../c-api/unicode.rst:1166
msgid "This function is a part of the :ref:`limited API <limited-c-api>`."
msgstr ""

#: ../../c-api/unicode.rst:1172
msgid "As :c:func:`PyUnicode_AsUTF8AndSize`, but does not store the size."
msgstr "與 :c:func:`PyUnicode_AsUTF8AndSize` 類似，但不儲存大小。"

#: ../../c-api/unicode.rst:1176
msgid ""
"This function does not have any special behavior for `null characters "
"<https://en.wikipedia.org/wiki/Null_character>`_ embedded within *unicode*. "
"As a result, strings containing null characters will remain in the returned "
"string, which some C functions might interpret as the end of the string, "
"leading to truncation. If truncation is an issue, it is recommended to use :"
"c:func:`PyUnicode_AsUTF8AndSize` instead."
msgstr ""

#: ../../c-api/unicode.rst:1190
msgid "UTF-32 Codecs"
msgstr "UTF-32 編解碼器"

#: ../../c-api/unicode.rst:1192
msgid "These are the UTF-32 codec APIs:"
msgstr "這些是 UTF-32 編解碼器的 API："

#: ../../c-api/unicode.rst:1198
msgid ""
"Decode *size* bytes from a UTF-32 encoded buffer string and return the "
"corresponding Unicode object.  *errors* (if non-``NULL``) defines the error "
"handling. It defaults to \"strict\"."
msgstr ""

#: ../../c-api/unicode.rst:1202 ../../c-api/unicode.rst:1252
msgid ""
"If *byteorder* is non-``NULL``, the decoder starts decoding using the given "
"byte order::"
msgstr ""

#: ../../c-api/unicode.rst:1205 ../../c-api/unicode.rst:1255
msgid ""
"*byteorder == -1: little endian\n"
"*byteorder == 0:  native order\n"
"*byteorder == 1:  big endian"
msgstr ""

#: ../../c-api/unicode.rst:1209
msgid ""
"If ``*byteorder`` is zero, and the first four bytes of the input data are a "
"byte order mark (BOM), the decoder switches to this byte order and the BOM "
"is not copied into the resulting Unicode string.  If ``*byteorder`` is "
"``-1`` or ``1``, any byte order mark is copied to the output."
msgstr ""

#: ../../c-api/unicode.rst:1214
msgid ""
"After completion, *\\*byteorder* is set to the current byte order at the end "
"of input data."
msgstr ""

#: ../../c-api/unicode.rst:1217 ../../c-api/unicode.rst:1268
msgid "If *byteorder* is ``NULL``, the codec starts in native order mode."
msgstr ""

#: ../../c-api/unicode.rst:1219 ../../c-api/unicode.rst:1270
msgid "Return ``NULL`` if an exception was raised by the codec."
msgstr "如果編解碼器引發例外則回傳 ``NULL``。"

#: ../../c-api/unicode.rst:1225
msgid ""
"If *consumed* is ``NULL``, behave like :c:func:`PyUnicode_DecodeUTF32`. If "
"*consumed* is not ``NULL``, :c:func:`PyUnicode_DecodeUTF32Stateful` will not "
"treat trailing incomplete UTF-32 byte sequences (such as a number of bytes "
"not divisible by four) as an error. Those bytes will not be decoded and the "
"number of bytes that have been decoded will be stored in *consumed*."
msgstr ""

#: ../../c-api/unicode.rst:1234
msgid ""
"Return a Python byte string using the UTF-32 encoding in native byte order. "
"The string always starts with a BOM mark.  Error handling is \"strict\". "
"Return ``NULL`` if an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1240
msgid "UTF-16 Codecs"
msgstr "UTF-16 編解碼器"

#: ../../c-api/unicode.rst:1242
msgid "These are the UTF-16 codec APIs:"
msgstr "這些是 UTF-16 編解碼器的 API："

#: ../../c-api/unicode.rst:1248
msgid ""
"Decode *size* bytes from a UTF-16 encoded buffer string and return the "
"corresponding Unicode object.  *errors* (if non-``NULL``) defines the error "
"handling. It defaults to \"strict\"."
msgstr ""

#: ../../c-api/unicode.rst:1259
msgid ""
"If ``*byteorder`` is zero, and the first two bytes of the input data are a "
"byte order mark (BOM), the decoder switches to this byte order and the BOM "
"is not copied into the resulting Unicode string.  If ``*byteorder`` is "
"``-1`` or ``1``, any byte order mark is copied to the output (where it will "
"result in either a ``\\ufeff`` or a ``\\ufffe`` character)."
msgstr ""

#: ../../c-api/unicode.rst:1265
msgid ""
"After completion, ``*byteorder`` is set to the current byte order at the end "
"of input data."
msgstr ""

#: ../../c-api/unicode.rst:1276
msgid ""
"If *consumed* is ``NULL``, behave like :c:func:`PyUnicode_DecodeUTF16`. If "
"*consumed* is not ``NULL``, :c:func:`PyUnicode_DecodeUTF16Stateful` will not "
"treat trailing incomplete UTF-16 byte sequences (such as an odd number of "
"bytes or a split surrogate pair) as an error. Those bytes will not be "
"decoded and the number of bytes that have been decoded will be stored in "
"*consumed*."
msgstr ""

#: ../../c-api/unicode.rst:1285
msgid ""
"Return a Python byte string using the UTF-16 encoding in native byte order. "
"The string always starts with a BOM mark.  Error handling is \"strict\". "
"Return ``NULL`` if an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1291
msgid "UTF-7 Codecs"
msgstr "UTF-7 編解碼器"

#: ../../c-api/unicode.rst:1293
msgid "These are the UTF-7 codec APIs:"
msgstr "這些是 UTF-7 編解碼器的 API："

#: ../../c-api/unicode.rst:1298
msgid ""
"Create a Unicode object by decoding *size* bytes of the UTF-7 encoded string "
"*str*.  Return ``NULL`` if an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1305
msgid ""
"If *consumed* is ``NULL``, behave like :c:func:`PyUnicode_DecodeUTF7`.  If "
"*consumed* is not ``NULL``, trailing incomplete UTF-7 base-64 sections will "
"not be treated as an error.  Those bytes will not be decoded and the number "
"of bytes that have been decoded will be stored in *consumed*."
msgstr ""

#: ../../c-api/unicode.rst:1312
msgid "Unicode-Escape Codecs"
msgstr ""

#: ../../c-api/unicode.rst:1314
msgid "These are the \"Unicode Escape\" codec APIs:"
msgstr ""

#: ../../c-api/unicode.rst:1320
msgid ""
"Create a Unicode object by decoding *size* bytes of the Unicode-Escape "
"encoded string *str*.  Return ``NULL`` if an exception was raised by the "
"codec."
msgstr ""

#: ../../c-api/unicode.rst:1326
msgid ""
"Encode a Unicode object using Unicode-Escape and return the result as a "
"bytes object.  Error handling is \"strict\".  Return ``NULL`` if an "
"exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1332
msgid "Raw-Unicode-Escape Codecs"
msgstr ""

#: ../../c-api/unicode.rst:1334
msgid "These are the \"Raw Unicode Escape\" codec APIs:"
msgstr ""

#: ../../c-api/unicode.rst:1340
msgid ""
"Create a Unicode object by decoding *size* bytes of the Raw-Unicode-Escape "
"encoded string *str*.  Return ``NULL`` if an exception was raised by the "
"codec."
msgstr ""

#: ../../c-api/unicode.rst:1346
msgid ""
"Encode a Unicode object using Raw-Unicode-Escape and return the result as a "
"bytes object.  Error handling is \"strict\".  Return ``NULL`` if an "
"exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1352
msgid "Latin-1 Codecs"
msgstr "Latin-1 編解碼器"

#: ../../c-api/unicode.rst:1354
msgid ""
"These are the Latin-1 codec APIs: Latin-1 corresponds to the first 256 "
"Unicode ordinals and only these are accepted by the codecs during encoding."
msgstr ""

#: ../../c-api/unicode.rst:1360
msgid ""
"Create a Unicode object by decoding *size* bytes of the Latin-1 encoded "
"string *str*.  Return ``NULL`` if an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1366
msgid ""
"Encode a Unicode object using Latin-1 and return the result as Python bytes "
"object.  Error handling is \"strict\".  Return ``NULL`` if an exception was "
"raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1372
msgid "ASCII Codecs"
msgstr "ASCII 編解碼器"

#: ../../c-api/unicode.rst:1374
msgid ""
"These are the ASCII codec APIs.  Only 7-bit ASCII data is accepted. All "
"other codes generate errors."
msgstr ""

#: ../../c-api/unicode.rst:1380
msgid ""
"Create a Unicode object by decoding *size* bytes of the ASCII encoded string "
"*str*.  Return ``NULL`` if an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1386
msgid ""
"Encode a Unicode object using ASCII and return the result as Python bytes "
"object.  Error handling is \"strict\".  Return ``NULL`` if an exception was "
"raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1392
msgid "Character Map Codecs"
msgstr ""

#: ../../c-api/unicode.rst:1394
msgid ""
"This codec is special in that it can be used to implement many different "
"codecs (and this is in fact what was done to obtain most of the standard "
"codecs included in the :mod:`!encodings` package). The codec uses mappings "
"to encode and decode characters.  The mapping objects provided must support "
"the :meth:`~object.__getitem__` mapping interface; dictionaries and "
"sequences work well."
msgstr ""

#: ../../c-api/unicode.rst:1400
msgid "These are the mapping codec APIs:"
msgstr "這些是對映編解碼器的 API："

#: ../../c-api/unicode.rst:1405
msgid ""
"Create a Unicode object by decoding *size* bytes of the encoded string *str* "
"using the given *mapping* object.  Return ``NULL`` if an exception was "
"raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1409
msgid ""
"If *mapping* is ``NULL``, Latin-1 decoding will be applied.  Else *mapping* "
"must map bytes ordinals (integers in the range from 0 to 255) to Unicode "
"strings, integers (which are then interpreted as Unicode ordinals) or "
"``None``.  Unmapped data bytes -- ones which cause a :exc:`LookupError`, as "
"well as ones which get mapped to ``None``, ``0xFFFE`` or ``'\\ufffe'``, are "
"treated as undefined mappings and cause an error."
msgstr ""

#: ../../c-api/unicode.rst:1420
msgid ""
"Encode a Unicode object using the given *mapping* object and return the "
"result as a bytes object.  Error handling is \"strict\".  Return ``NULL`` if "
"an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1424
msgid ""
"The *mapping* object must map Unicode ordinal integers to bytes objects, "
"integers in the range from 0 to 255 or ``None``.  Unmapped character "
"ordinals (ones which cause a :exc:`LookupError`) as well as mapped to "
"``None`` are treated as \"undefined mapping\" and cause an error."
msgstr ""

#: ../../c-api/unicode.rst:1430
msgid "The following codec API is special in that maps Unicode to Unicode."
msgstr ""

#: ../../c-api/unicode.rst:1434
msgid ""
"Translate a string by applying a character mapping table to it and return "
"the resulting Unicode object. Return ``NULL`` if an exception was raised by "
"the codec."
msgstr ""

#: ../../c-api/unicode.rst:1438
msgid ""
"The mapping table must map Unicode ordinal integers to Unicode ordinal "
"integers or ``None`` (causing deletion of the character)."
msgstr ""

#: ../../c-api/unicode.rst:1441
msgid ""
"Mapping tables need only provide the :meth:`~object.__getitem__` interface; "
"dictionaries and sequences work well.  Unmapped character ordinals (ones "
"which cause a :exc:`LookupError`) are left untouched and are copied as-is."
msgstr ""

#: ../../c-api/unicode.rst:1445
msgid ""
"*errors* has the usual meaning for codecs. It may be ``NULL`` which "
"indicates to use the default error handling."
msgstr ""

#: ../../c-api/unicode.rst:1450
msgid "MBCS codecs for Windows"
msgstr "Windows 的 MBCS 編解碼器"

#: ../../c-api/unicode.rst:1452
msgid ""
"These are the MBCS codec APIs. They are currently only available on Windows "
"and use the Win32 MBCS converters to implement the conversions.  Note that "
"MBCS (or DBCS) is a class of encodings, not just one.  The target encoding "
"is defined by the user settings on the machine running the codec."
msgstr ""

#: ../../c-api/unicode.rst:1459
msgid ""
"Create a Unicode object by decoding *size* bytes of the MBCS encoded string "
"*str*. Return ``NULL`` if an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1466
msgid ""
"If *consumed* is ``NULL``, behave like :c:func:`PyUnicode_DecodeMBCS`. If "
"*consumed* is not ``NULL``, :c:func:`PyUnicode_DecodeMBCSStateful` will not "
"decode trailing lead byte and the number of bytes that have been decoded "
"will be stored in *consumed*."
msgstr ""

#: ../../c-api/unicode.rst:1475
msgid ""
"Similar to :c:func:`PyUnicode_DecodeMBCSStateful`, except uses the code page "
"specified by *code_page*."
msgstr ""

#: ../../c-api/unicode.rst:1481
msgid ""
"Encode a Unicode object using MBCS and return the result as Python bytes "
"object.  Error handling is \"strict\".  Return ``NULL`` if an exception was "
"raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1488
msgid ""
"Encode the Unicode object using the specified code page and return a Python "
"bytes object.  Return ``NULL`` if an exception was raised by the codec. Use :"
"c:macro:`!CP_ACP` code page to get the MBCS encoder."
msgstr ""

#: ../../c-api/unicode.rst:1498
msgid "Methods and Slot Functions"
msgstr ""

#: ../../c-api/unicode.rst:1500
msgid ""
"The following APIs are capable of handling Unicode objects and strings on "
"input (we refer to them as strings in the descriptions) and return Unicode "
"objects or integers as appropriate."
msgstr ""

#: ../../c-api/unicode.rst:1504
msgid "They all return ``NULL`` or ``-1`` if an exception occurs."
msgstr "如果發生例外，則回傳 ``NULL`` 或 ``-1``。"

#: ../../c-api/unicode.rst:1509
msgid "Concat two strings giving a new Unicode string."
msgstr ""

#: ../../c-api/unicode.rst:1514
msgid ""
"Split a string giving a list of Unicode strings.  If *sep* is ``NULL``, "
"splitting will be done at all whitespace substrings.  Otherwise, splits "
"occur at the given separator.  At most *maxsplit* splits will be done.  If "
"negative, no limit is set.  Separators are not included in the resulting "
"list."
msgstr ""

#: ../../c-api/unicode.rst:1519 ../../c-api/unicode.rst:1529
#: ../../c-api/unicode.rst:1550 ../../c-api/unicode.rst:1563
msgid "On error, return ``NULL`` with an exception set."
msgstr "於錯誤發生時回傳 ``NULL`` 並設定例外。"

#: ../../c-api/unicode.rst:1521
msgid "Equivalent to :py:meth:`str.split`."
msgstr "等價於 :py:meth:`str.split`。"

#: ../../c-api/unicode.rst:1526
msgid ""
"Similar to :c:func:`PyUnicode_Split`, but splitting will be done beginning "
"at the end of the string."
msgstr ""

#: ../../c-api/unicode.rst:1531
msgid "Equivalent to :py:meth:`str.rsplit`."
msgstr "等價於 :py:meth:`str.rsplit`。"

#: ../../c-api/unicode.rst:1536
msgid ""
"Split a Unicode string at line breaks, returning a list of Unicode strings. "
"CRLF is considered to be one line break.  If *keepends* is ``0``, the Line "
"break characters are not included in the resulting strings."
msgstr ""

#: ../../c-api/unicode.rst:1543
msgid ""
"Split a Unicode string at the first occurrence of *sep*, and return a 3-"
"tuple containing the part before the separator, the separator itself, and "
"the part after the separator. If the separator is not found, return a 3-"
"tuple containing the string itself, followed by two empty strings."
msgstr ""

#: ../../c-api/unicode.rst:1548 ../../c-api/unicode.rst:1561
msgid "*sep* must not be empty."
msgstr "*sep* 不得為空。"

#: ../../c-api/unicode.rst:1552
msgid "Equivalent to :py:meth:`str.partition`."
msgstr "等價於 :py:meth:`str.partition`。"

#: ../../c-api/unicode.rst:1557
msgid ""
"Similar to :c:func:`PyUnicode_Partition`, but split a Unicode string at the "
"last occurrence of *sep*. If the separator is not found, return a 3-tuple "
"containing two empty strings, followed by the string itself."
msgstr ""

#: ../../c-api/unicode.rst:1565
msgid "Equivalent to :py:meth:`str.rpartition`."
msgstr "等價於 :py:meth:`str.rpartition`。"

#: ../../c-api/unicode.rst:1570
msgid ""
"Join a sequence of strings using the given *separator* and return the "
"resulting Unicode string."
msgstr ""

#: ../../c-api/unicode.rst:1577
msgid ""
"Return ``1`` if *substr* matches ``unicode[start:end]`` at the given tail "
"end (*direction* == ``-1`` means to do a prefix match, *direction* == ``1`` "
"a suffix match), ``0`` otherwise. Return ``-1`` if an error occurred."
msgstr ""

#: ../../c-api/unicode.rst:1585
msgid ""
"Return the first position of *substr* in ``unicode[start:end]`` using the "
"given *direction* (*direction* == ``1`` means to do a forward search, "
"*direction* == ``-1`` a backward search).  The return value is the index of "
"the first match; a value of ``-1`` indicates that no match was found, and "
"``-2`` indicates that an error occurred and an exception has been set."
msgstr ""

#: ../../c-api/unicode.rst:1595
msgid ""
"Return the first position of the character *ch* in ``unicode[start:end]`` "
"using the given *direction* (*direction* == ``1`` means to do a forward "
"search, *direction* == ``-1`` a backward search).  The return value is the "
"index of the first match; a value of ``-1`` indicates that no match was "
"found, and ``-2`` indicates that an error occurred and an exception has been "
"set."
msgstr ""

#: ../../c-api/unicode.rst:1603
msgid ""
"*start* and *end* are now adjusted to behave like ``unicode[start:end]``."
msgstr ""

#: ../../c-api/unicode.rst:1610
msgid ""
"Return the number of non-overlapping occurrences of *substr* in "
"``unicode[start:end]``.  Return ``-1`` if an error occurred."
msgstr ""

#: ../../c-api/unicode.rst:1617
msgid ""
"Replace at most *maxcount* occurrences of *substr* in *unicode* with "
"*replstr* and return the resulting Unicode object. *maxcount* == ``-1`` "
"means replace all occurrences."
msgstr ""

#: ../../c-api/unicode.rst:1624
msgid ""
"Compare two strings and return ``-1``, ``0``, ``1`` for less than, equal, "
"and greater than, respectively."
msgstr ""

#: ../../c-api/unicode.rst:1627
msgid ""
"This function returns ``-1`` upon failure, so one should call :c:func:"
"`PyErr_Occurred` to check for errors."
msgstr ""

#: ../../c-api/unicode.rst:1632
msgid "The :c:func:`PyUnicode_Equal` function."
msgstr ":c:func:`PyUnicode_Equal` 函式。"

#: ../../c-api/unicode.rst:1637
msgid "Test if two strings are equal:"
msgstr "測試兩個字串是否相等："

#: ../../c-api/unicode.rst:1639
msgid "Return ``1`` if *a* is equal to *b*."
msgstr "如果 *a* 等於 *b*，則回傳 ``1``。"

#: ../../c-api/unicode.rst:1640
msgid "Return ``0`` if *a* is not equal to *b*."
msgstr "如果 *a* 不等於 *b*，則回傳 ``0``。"

#: ../../c-api/unicode.rst:1641
msgid ""
"Set a :exc:`TypeError` exception and return ``-1`` if *a* or *b* is not a :"
"class:`str` object."
msgstr ""

#: ../../c-api/unicode.rst:1644
msgid "The function always succeeds if *a* and *b* are :class:`str` objects."
msgstr ""

#: ../../c-api/unicode.rst:1646
msgid ""
"The function works for :class:`str` subclasses, but does not honor custom "
"``__eq__()`` method."
msgstr ""

#: ../../c-api/unicode.rst:1651
msgid "The :c:func:`PyUnicode_Compare` function."
msgstr ":c:func:`PyUnicode_Compare` 函式。"

#: ../../c-api/unicode.rst:1658
msgid ""
"Compare a Unicode object with a char buffer which is interpreted as being "
"UTF-8 or ASCII encoded and return true (``1``) if they are equal, or false "
"(``0``) otherwise. If the Unicode object contains surrogate code points "
"(``U+D800`` - ``U+DFFF``) or the C string is not valid UTF-8, false (``0``) "
"is returned."
msgstr ""

#: ../../c-api/unicode.rst:1665 ../../c-api/unicode.rst:1686
msgid "This function does not raise exceptions."
msgstr "此函式不會引發例外。"

#: ../../c-api/unicode.rst:1672
msgid ""
"Similar to :c:func:`PyUnicode_EqualToUTF8AndSize`, but compute *string* "
"length using :c:func:`!strlen`. If the Unicode object contains null "
"characters, false (``0``) is returned."
msgstr ""

#: ../../c-api/unicode.rst:1681
msgid ""
"Compare a Unicode object, *unicode*, with *string* and return ``-1``, ``0``, "
"``1`` for less than, equal, and greater than, respectively. It is best to "
"pass only ASCII-encoded strings, but the function interprets the input "
"string as ISO-8859-1 if it contains non-ASCII characters."
msgstr ""

#: ../../c-api/unicode.rst:1691
msgid "Rich compare two Unicode strings and return one of the following:"
msgstr ""

#: ../../c-api/unicode.rst:1693
msgid "``NULL`` in case an exception was raised"
msgstr ""

#: ../../c-api/unicode.rst:1694
msgid ":c:data:`Py_True` or :c:data:`Py_False` for successful comparisons"
msgstr ""

#: ../../c-api/unicode.rst:1695
msgid ":c:data:`Py_NotImplemented` in case the type combination is unknown"
msgstr ""

#: ../../c-api/unicode.rst:1697
msgid ""
"Possible values for *op* are :c:macro:`Py_GT`, :c:macro:`Py_GE`, :c:macro:"
"`Py_EQ`, :c:macro:`Py_NE`, :c:macro:`Py_LT`, and :c:macro:`Py_LE`."
msgstr ""

#: ../../c-api/unicode.rst:1703
msgid ""
"Return a new string object from *format* and *args*; this is analogous to "
"``format % args``."
msgstr ""

#: ../../c-api/unicode.rst:1709
msgid ""
"Check whether *substr* is contained in *unicode* and return true or false "
"accordingly."
msgstr ""

#: ../../c-api/unicode.rst:1712
msgid ""
"*substr* has to coerce to a one element Unicode string. ``-1`` is returned "
"if there was an error."
msgstr ""

#: ../../c-api/unicode.rst:1718
msgid ""
"Intern the argument :c:expr:`*p_unicode` in place.  The argument must be the "
"address of a pointer variable pointing to a Python Unicode string object.  "
"If there is an existing interned string that is the same as :c:expr:"
"`*p_unicode`, it sets :c:expr:`*p_unicode` to it (releasing the reference to "
"the old string object and creating a new :term:`strong reference` to the "
"interned string object), otherwise it leaves :c:expr:`*p_unicode` alone and "
"interns it."
msgstr ""

#: ../../c-api/unicode.rst:1725
msgid ""
"(Clarification: even though there is a lot of talk about references, think "
"of this function as reference-neutral. You must own the object you pass in; "
"after the call you no longer own the passed-in reference, but you newly own "
"the result.)"
msgstr ""

#: ../../c-api/unicode.rst:1730
msgid ""
"This function never raises an exception. On error, it leaves its argument "
"unchanged without interning it."
msgstr ""

#: ../../c-api/unicode.rst:1733
msgid ""
"Instances of subclasses of :py:class:`str` may not be interned, that is, :c:"
"expr:`PyUnicode_CheckExact(*p_unicode)` must be true. If it is not, then -- "
"as with any other error -- the argument is left unchanged."
msgstr ""

#: ../../c-api/unicode.rst:1737
msgid ""
"Note that interned strings are not “immortal”. You must keep a reference to "
"the result to benefit from interning."
msgstr ""

#: ../../c-api/unicode.rst:1743
msgid ""
"A combination of :c:func:`PyUnicode_FromString` and :c:func:"
"`PyUnicode_InternInPlace`, meant for statically allocated strings."
msgstr ""

#: ../../c-api/unicode.rst:1746
msgid ""
"Return a new (\"owned\") reference to either a new Unicode string object "
"that has been interned, or an earlier interned string object with the same "
"value."
msgstr ""

#: ../../c-api/unicode.rst:1750
msgid ""
"Python may keep a reference to the result, or make it :term:`immortal`, "
"preventing it from being garbage-collected promptly. For interning an "
"unbounded number of different strings, such as ones coming from user input, "
"prefer calling :c:func:`PyUnicode_FromString` and :c:func:"
"`PyUnicode_InternInPlace` directly."
msgstr ""

#: ../../c-api/unicode.rst:1759
msgid ""
"Return a non-zero value if *str* is interned, zero if not. The *str* "
"argument must be a string; this is not checked. This function always "
"succeeds."
msgstr ""

#: ../../c-api/unicode.rst:1765
msgid ""
"A non-zero return value may carry additional information about *how* the "
"string is interned. The meaning of such non-zero values, as well as each "
"specific string's intern-related details, may change between CPython "
"versions."
msgstr ""

#: ../../c-api/unicode.rst:1772
msgid "PyUnicodeWriter"
msgstr "PyUnicodeWriter"

#: ../../c-api/unicode.rst:1774
msgid ""
"The :c:type:`PyUnicodeWriter` API can be used to create a Python :class:"
"`str` object."
msgstr ""

#: ../../c-api/unicode.rst:1781
msgid "A Unicode writer instance."
msgstr "一個 Unicode 寫入器實例。"

#: ../../c-api/unicode.rst:1783
msgid ""
"The instance must be destroyed by :c:func:`PyUnicodeWriter_Finish` on "
"success, or :c:func:`PyUnicodeWriter_Discard` on error."
msgstr ""

#: ../../c-api/unicode.rst:1788
msgid "Create a Unicode writer instance."
msgstr ""

#: ../../c-api/unicode.rst:1790
msgid "*length* must be greater than or equal to ``0``."
msgstr ""

#: ../../c-api/unicode.rst:1792
msgid ""
"If *length* is greater than ``0``, preallocate an internal buffer of "
"*length* characters."
msgstr ""

#: ../../c-api/unicode.rst:1795 ../../c-api/unicode.rst:1801
msgid "Set an exception and return ``NULL`` on error."
msgstr "發生錯誤時，設定例外並回傳 ``NULL``。"

#: ../../c-api/unicode.rst:1799
msgid ""
"Return the final Python :class:`str` object and destroy the writer instance."
msgstr ""

#: ../../c-api/unicode.rst:1803 ../../c-api/unicode.rst:1811
msgid "The writer instance is invalid after this call."
msgstr ""

#: ../../c-api/unicode.rst:1807
msgid "Discard the internal Unicode buffer and destroy the writer instance."
msgstr ""

#: ../../c-api/unicode.rst:1809
msgid "If *writer* is ``NULL``, no operation is performed."
msgstr ""

#: ../../c-api/unicode.rst:1815
msgid "Write the single Unicode character *ch* into *writer*."
msgstr ""

#: ../../c-api/unicode.rst:1817 ../../c-api/unicode.rst:1827
#: ../../c-api/unicode.rst:1842 ../../c-api/unicode.rst:1852
#: ../../c-api/unicode.rst:1861 ../../c-api/unicode.rst:1868
#: ../../c-api/unicode.rst:1881 ../../c-api/unicode.rst:1896
#: ../../c-api/unicode.rst:1903 ../../c-api/unicode.rst:1922
msgid ""
"On success, return ``0``. On error, set an exception, leave the writer "
"unchanged, and return ``-1``."
msgstr "成功時回傳 ``0``，發生錯誤時設定例外、保持寫入器不變，並回傳 ``-1``。"

#: ../../c-api/unicode.rst:1822
msgid ""
"Decode the string *str* from UTF-8 in strict mode and write the output into "
"*writer*."
msgstr ""

#: ../../c-api/unicode.rst:1824 ../../c-api/unicode.rst:1836
#: ../../c-api/unicode.rst:1911
msgid ""
"*size* is the string length in bytes. If *size* is equal to ``-1``, call "
"``strlen(str)`` to get the string length."
msgstr ""

#: ../../c-api/unicode.rst:1830
msgid "See also :c:func:`PyUnicodeWriter_DecodeUTF8Stateful`."
msgstr "另請參閱 :c:func:`PyUnicodeWriter_DecodeUTF8Stateful`。"

#: ../../c-api/unicode.rst:1834
msgid "Write the ASCII string *str* into *writer*."
msgstr ""

#: ../../c-api/unicode.rst:1839
msgid ""
"*str* must only contain ASCII characters. The behavior is undefined if *str* "
"contains non-ASCII characters."
msgstr ""

#: ../../c-api/unicode.rst:1847
msgid "Write the wide string *str* into *writer*."
msgstr ""

#: ../../c-api/unicode.rst:1849
msgid ""
"*size* is a number of wide characters. If *size* is equal to ``-1``, call "
"``wcslen(str)`` to get the string length."
msgstr ""

#: ../../c-api/unicode.rst:1857
msgid "Writer the UCS4 string *str* into *writer*."
msgstr ""

#: ../../c-api/unicode.rst:1859
msgid "*size* is a number of UCS4 characters."
msgstr "*size* 是 UCS4 字元的數量。"

#: ../../c-api/unicode.rst:1866
msgid ""
"Call :c:func:`PyObject_Str` on *obj* and write the output into *writer*."
msgstr "於 *obj* 上呼叫 :c:func:`PyObject_Str` 並將輸出寫入 *writer*。"

#: ../../c-api/unicode.rst:1871
msgid ""
"To write a :class:`str` subclass which overrides the :meth:`~object.__str__` "
"method, :c:func:`PyUnicode_FromObject` can be used to get the original "
"string."
msgstr ""

#: ../../c-api/unicode.rst:1877
msgid ""
"Call :c:func:`PyObject_Repr` on *obj* and write the output into *writer*."
msgstr "於 *obj* 上呼叫 :c:func:`PyObject_Repr` 並將輸出寫入 *writer*。"

#: ../../c-api/unicode.rst:1879
msgid "If *obj* is ``NULL``, write the string ``\"<NULL>\"`` into *writer*."
msgstr ""

#: ../../c-api/unicode.rst:1886
msgid "Added support for ``NULL``."
msgstr ""

#: ../../c-api/unicode.rst:1890
msgid "Write the substring ``str[start:end]`` into *writer*."
msgstr ""

#: ../../c-api/unicode.rst:1892
msgid ""
"*str* must be Python :class:`str` object. *start* must be greater than or "
"equal to 0, and less than or equal to *end*. *end* must be less than or "
"equal to *str* length."
msgstr ""

#: ../../c-api/unicode.rst:1901
msgid ""
"Similar to :c:func:`PyUnicode_FromFormat`, but write the output directly "
"into *writer*."
msgstr "類似於 :c:func:`PyUnicode_FromFormat`，但是直接將輸出寫入 *writer*。"

#: ../../c-api/unicode.rst:1908
msgid ""
"Decode the string *str* from UTF-8 with *errors* error handler and write the "
"output into *writer*."
msgstr ""

#: ../../c-api/unicode.rst:1914
msgid ""
"*errors* is an :ref:`error handler <error-handlers>` name, such as "
"``\"replace\"``. If *errors* is ``NULL``, use the strict error handler."
msgstr ""

#: ../../c-api/unicode.rst:1917
msgid ""
"If *consumed* is not ``NULL``, set *\\*consumed* to the number of decoded "
"bytes on success. If *consumed* is ``NULL``, treat trailing incomplete UTF-8 "
"byte sequences as an error."
msgstr ""

#: ../../c-api/unicode.rst:1925
msgid "See also :c:func:`PyUnicodeWriter_WriteUTF8`."
msgstr "另請參閱 :c:func:`PyUnicodeWriter_WriteUTF8`。"

#: ../../c-api/unicode.rst:1928
msgid "Deprecated API"
msgstr "已棄用的 API"

#: ../../c-api/unicode.rst:1930
msgid "The following API is deprecated."
msgstr "以下 API 已棄用。"

#: ../../c-api/unicode.rst:1934
msgid ""
"This is a typedef of :c:type:`wchar_t`, which is a 16-bit type or 32-bit "
"type depending on the platform. Please use :c:type:`wchar_t` directly "
"instead."
msgstr ""

#: ../../c-api/unicode.rst:1938
msgid ""
"In previous versions, this was a 16-bit type or a 32-bit type depending on "
"whether you selected a \"narrow\" or \"wide\" Unicode version of Python at "
"build time."
msgstr ""

#: ../../c-api/unicode.rst:1948
msgid ""
"Do nothing and return ``0``. This API is kept only for backward "
"compatibility, but there are no plans to remove it."
msgstr ""

#: ../../c-api/unicode.rst:1954
msgid ""
"This API does nothing since Python 3.12. Previously, this needed to be "
"called for each string created using the old API (:c:func:`!"
"PyUnicode_FromUnicode` or similar)."
msgstr ""

#: ../../c-api/unicode.rst:1962
msgid ""
"Do nothing and return ``1``. This API is kept only for backward "
"compatibility, but there are no plans to remove it."
msgstr ""

#: ../../c-api/unicode.rst:1968
msgid ""
"This API does nothing since Python 3.12. Previously, this could be called to "
"check if :c:func:`PyUnicode_READY` is necessary."
msgstr ""