# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

# 99 <wh2099@pm.me>, 2026

# Freesand Leo <yuqinju@163.com>, 2026

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-05-19 16:47+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: Freesand Leo <yuqinju@163.com>, 2026\n"

"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../howto/unicode.rst:5

msgid "Unicode HOWTO"

msgstr "Unicode 指南"

#: ../../howto/unicode.rst:0

msgid "Release"

msgstr "发布版本"

#: ../../howto/unicode.rst:7

msgid "1.12"

msgstr "1.12"

#: ../../howto/unicode.rst:9

msgid ""

"This HOWTO discusses Python's support for the Unicode specification for "

"representing textual data, and explains various problems that people "

"commonly encounter when trying to work with Unicode."

msgstr "本文介绍了 Python 对表示文本数据的 Unicode 规范的支持，并对各种 Unicode 常见使用问题做了解释。"

#: ../../howto/unicode.rst:15

msgid "Introduction to Unicode"

msgstr "Unicode 概述"

#: ../../howto/unicode.rst:18

msgid "Definitions"

msgstr "定义"

#: ../../howto/unicode.rst:20

msgid ""

"Today's programs need to be able to handle a wide variety of characters. "

"Applications are often internationalized to display messages and output in a"

" variety of user-selectable languages; the same program might need to output"

" an error message in English, French, Japanese, Hebrew, or Russian. Web "

"content can be written in any of these languages and can also include a "

"variety of emoji symbols. Python's string type uses the Unicode Standard for"

" representing characters, which lets Python programs work with all these "

"different possible characters."

msgstr ""

"如今的程序需要能够处理各种各样的字符。应用程序通常做了国际化处理，用户可以选择不同的语言显示信息和输出数据。同一个程序可能需要以英语、法语、日语、希伯来语或俄语输出错误信息。网页内容可能由这些语言书写，并且可能包含不同的表情符号。Python"

" 的字符串类型采用 Unicode 标准来表示字符，使得 Python 程序能够正常处理所有这些不同的字符。"

#: ../../howto/unicode.rst:30

msgid ""

"Unicode (https://www.unicode.org/) is a specification that aims to list "

"every character used by human languages and give each character its own "

"unique code. The Unicode specifications are continually revised and updated"

" to add new languages and symbols."

msgstr ""

"Unicode "

"规范（https://www.unicode.org/）旨在罗列人类语言所用到的所有字符，并赋予每个字符唯一的编码。该规范一直在进行修订和更新，不断加入新的语种和符号。"

#: ../../howto/unicode.rst:35

msgid ""

"A **character** is the smallest possible component of a text. 'A', 'B', "

"'C', etc., are all different characters. So are 'È' and 'Í'. Characters "

"vary depending on the language or context you're talking about. For "

"example, there's a character for \"Roman Numeral One\", 'Ⅰ', that's separate"

" from the uppercase letter 'I'. They'll usually look the same, but these "

"are two different characters that have different meanings."

msgstr ""

"一个 **字符** 是文本的最小组件。‘A’、‘B’、‘C’等都是不同的字符。‘È’和‘Í’ "

"也一样。字符会随着语言或者上下文的变化而变化。比如，‘Ⅰ’是一个表示“罗马数字 1”的字符，它与大写字母‘I’ "

"不同。它们往往看起来相同，但这是两个有着不同含义的字符。"

#: ../../howto/unicode.rst:42

msgid ""

"The Unicode standard describes how characters are represented by **code "

"points**. A code point value is an integer in the range 0 to 0x10FFFF "

"(about 1.1 million values, the `actual number assigned "

"<https://www.unicode.org/versions/latest/#Summary>`_ is less than that). In "

"the standard and in this document, a code point is written using the "

"notation ``U+265E`` to mean the character with value ``0x265e`` (9,822 in "

"decimal)."

msgstr ""

"Unicode 标准描述了字符是如何用 **码位（code point）** 表示的。码位的取值范围是 0 到 0x10FFFF 的整数（大约 110 "

"万个值，`实际分配的数字 <https://www.unicode.org/versions/latest/#Summary>`_ 没有那么多）。在 "

"Unicode 标准和本文中，码位采用 ``U+265E`` 的形式，表示值为 ``0x265e`` 的字符（十进制为 9822）。"

#: ../../howto/unicode.rst:50

msgid ""

"The Unicode standard contains a lot of tables listing characters and their "

"corresponding code points:"

msgstr "Unicode 标准中包含了许多表格，列出了很多字符及其对应的码位。"

#: ../../howto/unicode.rst:53

msgid ""

"0061 'a'; LATIN SMALL LETTER A\n"

"0062 'b'; LATIN SMALL LETTER B\n"

"0063 'c'; LATIN SMALL LETTER C\n"

"...\n"

"007B '{'; LEFT CURLY BRACKET\n"

"...\n"

"2167 'Ⅷ'; ROMAN NUMERAL EIGHT\n"

"2168 'Ⅸ'; ROMAN NUMERAL NINE\n"

"...\n"

"265E '♞'; BLACK CHESS KNIGHT\n"

"265F '♟'; BLACK CHESS PAWN\n"

"...\n"

"1F600 '😀'; GRINNING FACE\n"

"1F609 '😉'; WINKING FACE\n"

"..."

msgstr ""

"0061 'a'; 拉丁字母 A 小写\n"

"0062 'b'; 拉丁字母 B 小写\n"

"0063 'c'; 拉丁字母 C 小写\n"

"...\n"

"007B '{'; 左花括号\n"

"...\n"

"2167 'Ⅷ'; 罗马数字八\n"

"2168 'Ⅸ'; 罗马数字九\n"

"...\n"

"265E '♞'; 国际象棋黑马\n"

"265F '♟'; 国际象棋黑兵\n"

"...\n"

"1F600 '😀'; 微笑脸\n"

"1F609 '😉'; 眨眼脸\n"

"..."

#: ../../howto/unicode.rst:71

msgid ""

"Strictly, these definitions imply that it's meaningless to say 'this is "

"character ``U+265E``'. ``U+265E`` is a code point, which represents some "

"particular character; in this case, it represents the character 'BLACK CHESS"

" KNIGHT', '♞'. In informal contexts, this distinction between code points "

"and characters will sometimes be forgotten."

msgstr ""

"严格地说，上述定义暗示了以下说法是没有意义的：“这是字符 ``U+265E``”。``U+265E`` "

"只是一个码位，代表某个特定的字符；这里它代表了字符“国际象棋黑骑士” '♞'。在非正式的上下文中，有时会忽略码位和字符的区别。"

#: ../../howto/unicode.rst:78

msgid ""

"A character is represented on a screen or on paper by a set of graphical "

"elements that's called a **glyph**. The glyph for an uppercase A, for "

"example, is two diagonal strokes and a horizontal stroke, though the exact "

"details will depend on the font being used. Most Python code doesn't need "

"to worry about glyphs; figuring out the correct glyph to display is "

"generally the job of a GUI toolkit or a terminal's font renderer."

msgstr ""

"一个字符在屏幕或纸上被表示为一组图形元素，被称为 **字形（glyph）** 。比如，大写字母 A "

"的字形，是两笔斜线和一笔横线，而具体的细节取决于所使用的字体。大部分 Python 代码不必担心字形，找到正确的显示字形通常是交给 GUI "

"工具包或终端的字体渲染程序来完成。"

#: ../../howto/unicode.rst:87

msgid "Encodings"

msgstr "编码"

#: ../../howto/unicode.rst:89

msgid ""

"To summarize the previous section: a Unicode string is a sequence of code "

"points, which are numbers from 0 through ``0x10FFFF`` (1,114,111 decimal). "

"This sequence of code points needs to be represented in memory as a set of "

"**code units**, and **code units** are then mapped to 8-bit bytes. The "

"rules for translating a Unicode string into a sequence of bytes are called a"

" **character encoding**, or just an **encoding**."

msgstr ""

"上一段可以归结为：一个 Unicode 字符串是一系列码位（从 0 到 ``0x10FFFF`` 或者说十进制的 1,114,111 "

"的数字）组成的序列。这一序列在内存中需被表示为一组 **码元（code unit）** ， **码元** 会映射成包含八个二进制位的字节。将 "

"Unicode 字符串翻译成字节序列的规则称为 **字符编码** ，或者 **编码** 。"

#: ../../howto/unicode.rst:97

msgid ""

"The first encoding you might think of is using 32-bit integers as the code "

"unit, and then using the CPU's representation of 32-bit integers. In this "

"representation, the string \"Python\" might look like this:"

msgstr ""

"大家首先会想到的编码可能是用 32 位的整数作为码元，然后采用 CPU 对 32 位整数的表示法。字符串 \"Python\" "

"用这种表示法可能会如下所示："

#: ../../howto/unicode.rst:101

msgid ""

" P y t h o n\n"

"0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00\n"

" 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23"

msgstr ""

" P y t h o n\n"

"0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00\n"

" 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23"

#: ../../howto/unicode.rst:107

msgid ""

"This representation is straightforward but using it presents a number of "

"problems."

msgstr "这种表示法非常直白，但也存在一些问题。"

#: ../../howto/unicode.rst:110

msgid "It's not portable; different processors order the bytes differently."

msgstr "不具可移植性；不同的处理器的字节序不同。"

#: ../../howto/unicode.rst:112

msgid ""

"It's very wasteful of space. In most texts, the majority of the code points"

" are less than 127, or less than 255, so a lot of space is occupied by "

"``0x00`` bytes. The above string takes 24 bytes compared to the 6 bytes "

"needed for an ASCII representation. Increased RAM usage doesn't matter too "

"much (desktop computers have gigabytes of RAM, and strings aren't usually "

"that large), but expanding our usage of disk and network bandwidth by a "

"factor of 4 is intolerable."

msgstr ""

"非常浪费空间。在大多数文本中，大部分码位都小于 127 或 255，因此字节 ``0x00`` 占用了大量空间。相较于 ASCII 表示法所需的 6 "

"个字节，以上字符串需要占用 24 个字节。RAM 用量的增加没那么要紧（台式计算机有成 GB 的 "

"RAM，而字符串通常不会有那么大），但要把磁盘和网络带宽的用量增加 4 倍是无法忍受的。"

#: ../../howto/unicode.rst:120

msgid ""

"It's not compatible with existing C functions such as ``strlen()``, so a new"

" family of wide string functions would need to be used."

msgstr "与现有的 C 函数 (如 ``strlen()``) 不兼容，因此需要采用一套新的宽字符串函数。"

#: ../../howto/unicode.rst:123

msgid ""

"Therefore this encoding isn't used very much, and people instead choose "

"other encodings that are more efficient and convenient, such as UTF-8."

msgstr "因此这种编码用得不多，人们转而选择其他更高效、更方便的编码，比如 UTF-8。"

#: ../../howto/unicode.rst:126

msgid ""

"UTF-8 is one of the most commonly used encodings, and Python often defaults "

"to using it. UTF stands for \"Unicode Transformation Format\", and the '8' "

"means that 8-bit values are used in the encoding. (There are also UTF-16 "

"and UTF-32 encodings, but they are less frequently used than UTF-8.) UTF-8 "

"uses the following rules:"

msgstr ""

"UTF-8 是最常用的编码之一，Python 往往默认会采用它。UTF 代表“Unicode Transformation Format”，'8' "

"表示编码采用 8 位数。（UTF-16 和 UTF-32 编码也是存在的，但其使用频率不如 UTF-8。）UTF-8 的规则如下："

#: ../../howto/unicode.rst:132

msgid ""

"If the code point is < 128, it's represented by the corresponding byte "

"value."

msgstr "如果码位 < 128，则直接用对应的字节值表示。"

#: ../../howto/unicode.rst:133

msgid ""

"If the code point is >= 128, it's turned into a sequence of two, three, or "

"four bytes, where each byte of the sequence is between 128 and 255."

msgstr "如果码位 >= 128，则转换为 2、3、4 个字节的序列，每个字节值都位于 128 和 255 之间。"

#: ../../howto/unicode.rst:136

msgid "UTF-8 has several convenient properties:"

msgstr "UTF-8 有几个很方便的特性："

#: ../../howto/unicode.rst:138

msgid "It can handle any Unicode code point."

msgstr "可以处理任何 Unicode 码位。"

#: ../../howto/unicode.rst:139

msgid ""

"A Unicode string is turned into a sequence of bytes that contains embedded "

"zero bytes only where they represent the null character (U+0000). This means"

" that UTF-8 strings can be processed by C functions such as ``strcpy()`` and"

" sent through protocols that can't handle zero bytes for anything other than"

" end-of-string markers."

msgstr ""

"Unicode 字符串被转换为一个字节序列，仅在表示空（null）字符（U+0000）时才会包含零值的字节。这意味着 ``strcpy()`` 之类的 "

"C 函数可以处理 UTF-8 字符串，而且用那些不能处理字符串结束符之外的零值字节的协议也能发送。"

#: ../../howto/unicode.rst:144

msgid "A string of ASCII text is also valid UTF-8 text."

msgstr "ASCII 字符串也是合法的 UTF-8 文本。"

#: ../../howto/unicode.rst:145

msgid ""

"UTF-8 is fairly compact; the majority of commonly used characters can be "

"represented with one or two bytes."

msgstr "UTF-8 相当紧凑；大多数常用字符均可用一两个字节表示。"

#: ../../howto/unicode.rst:147

msgid ""

"If bytes are corrupted or lost, it's possible to determine the start of the "

"next UTF-8-encoded code point and resynchronize. It's also unlikely that "

"random 8-bit data will look like valid UTF-8."

msgstr ""

"如果字节数据被损坏或丢失，则可以找出下一个 UTF-8 码点的开始位置并重新开始同步。随机的 8 位数据也不太可能像是有效的 UTF-8 编码。"

#: ../../howto/unicode.rst:150

msgid ""

"UTF-8 is a byte oriented encoding. The encoding specifies that each "

"character is represented by a specific sequence of one or more bytes. This "

"avoids the byte-ordering issues that can occur with integer and word "

"oriented encodings, like UTF-16 and UTF-32, where the sequence of bytes "

"varies depending on the hardware on which the string was encoded."

msgstr ""

"UTF-8 是一种面向字节的编码。编码规定了每个字符由一个或多个字节的序列表示。这避免了面向整数和面向字的编码（如 UTF-16 和 "

"UTF-32）可能出现的字节顺序问题，那时的字节序列会因执行编码的硬件而异。"

#: ../../howto/unicode.rst:158 ../../howto/unicode.rst:516

#: ../../howto/unicode.rst:737

msgid "References"

msgstr "参考文献"

#: ../../howto/unicode.rst:160

msgid ""

"The `Unicode Consortium site <https://www.unicode.org>`_ has character "

"charts, a glossary, and PDF versions of the Unicode specification. Be "

"prepared for some difficult reading. `A chronology "

"<https://www.unicode.org/history/>`_ of the origin and development of "

"Unicode is also available on the site."

msgstr ""

"`Unicode Consortium 站点 <https://www.unicode.org>`_ 包含 Unicode 规范的字符图表、词汇表和 "

"PDF 版本。请做好准备，有些内容读起来有点难度。该网站上还提供了 Unicode 起源和发展的 `年表 "

"<https://www.unicode.org/history/>`_ ."

#: ../../howto/unicode.rst:165

msgid ""

"On the Computerphile Youtube channel, Tom Scott briefly `discusses the "

"history of Unicode and UTF-8 <https://www.youtube.com/watch?v=MijmeoH9LT4>`_"

" (9 minutes 36 seconds)."

msgstr ""

"在 Computerphile 的 Youtube 频道上，Tom Scott 简要地 `讨论 Unicode 和 UTF-8 的历史 "

"<https://www.youtube.com/watch?v=MijmeoH9LT4>`_ (9 分 36 秒)。"

#: ../../howto/unicode.rst:169

msgid ""

"To help understand the standard, Jukka Korpela has written `an introductory "

"guide <https://jkorpela.fi/unicode/guide.html>`_ to reading the Unicode "

"character tables."

msgstr ""

"为了帮助理解该标准，Jukka Korpela 编写了阅读 Unicode 字符表的 `介绍性指南 "

"<https://jkorpela.fi/unicode/guide.html>`_ ."

#: ../../howto/unicode.rst:173

msgid ""

"Another `good introductory article "

"<https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-"

"software-developer-absolutely-positively-must-know-about-unicode-and-"

"character-sets-no-excuses/>`_ was written by Joel Spolsky. If this "

"introduction didn't make things clear to you, you should try reading this "

"alternate article before continuing."

msgstr ""

"Joel Spolsky 撰写了另一篇 `不错的介绍性文章 "

"<https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-"

"software-developer-absolutely-positively-must-know-about-unicode-and-"

"character-sets-no-excuses/>`_。如果本文没让您弄清楚，那应在继续之前先试着读读这篇文章。"

#: ../../howto/unicode.rst:178

msgid ""

"Wikipedia entries are often helpful; see the entries for \"`character "

"encoding <https://en.wikipedia.org/wiki/Character_encoding>`_\" and `UTF-8 "

"<https://en.wikipedia.org/wiki/UTF-8>`_, for example."

msgstr ""

"Wikipedia 条目通常也有帮助；例如请参阅 \"`字符编码 "

"<https://en.wikipedia.org/wiki/Character_encoding>`_\" 和 `UTF-8 "

"<https://en.wikipedia.org/wiki/UTF-8>`_ 的条目。"

#: ../../howto/unicode.rst:184

msgid "Python's Unicode Support"

msgstr "Python 对 Unicode 的支持"

#: ../../howto/unicode.rst:186

msgid ""

"Now that you've learned the rudiments of Unicode, we can look at Python's "

"Unicode features."

msgstr "现在您已经了解了 Unicode 的基础知识，可以看下 Python 的 Unicode 特性。"

#: ../../howto/unicode.rst:190

msgid "The String Type"

msgstr "字符串类型"

#: ../../howto/unicode.rst:192

msgid ""

"Since Python 3.0, the language's :class:`str` type contains Unicode "

"characters, meaning any string created using ``\"unicode rocks!\"``, "

"``'unicode rocks!'``, or the triple-quoted string syntax is stored as "

"Unicode."

msgstr ""

"从 Python 3.0 开始， :class:`str` 类型包含了 Unicode 字符，这意味着用 ``\"unicode "

"rocks!\"``、``'unicode rocks!'`` 或三重引号字符串语法创建的任何字符串都会存储为 Unicode。"

#: ../../howto/unicode.rst:196

msgid ""

"The default encoding for Python source code is UTF-8, so you can simply "

"include a Unicode character in a string literal::"

msgstr "Python 源代码的默认编码是 UTF-8，因此可以直接在字符串中包含 Unicode 字符::"

#: ../../howto/unicode.rst:199

msgid ""

"try:\n"

" with open('/tmp/input.txt', 'r') as f:\n"

" ...\n"

"except OSError:\n"

" # 'File not found' error message.\n"

" print(\"Fichier non trouvé\")"

msgstr ""

"try:\n"

" with open('/tmp/input.txt', 'r') as f:\n"

" ...\n"

"except OSError:\n"

" # 'File not found' 错误消息。\n"

" print(\"Fichier non trouvé\")"

#: ../../howto/unicode.rst:206

msgid ""

"Side note: Python 3 also supports using Unicode characters in identifiers::"

msgstr "旁注：Python 3 还支持在标识符中使用 Unicode 字符::"

#: ../../howto/unicode.rst:208

msgid ""

"répertoire = \"/tmp/records.log\"\n"

"with open(répertoire, \"w\") as f:\n"

" f.write(\"test\\n\")"

msgstr ""

"répertoire = \"/tmp/records.log\"\n"

"with open(répertoire, \"w\") as f:\n"

" f.write(\"test\\n\")"

#: ../../howto/unicode.rst:212

msgid ""

"If you can't enter a particular character in your editor or want to keep the"

" source code ASCII-only for some reason, you can also use escape sequences "

"in string literals. (Depending on your system, you may see the actual "

"capital-delta glyph instead of a \\u escape.) ::"

msgstr ""

"如果无法在编辑器中输入某个字符，或出于某种原因想只保留 ASCII 编码的源代码，则还可以在字符串中使用转义序列。（根据系统的不同，可能会看到真的大写 "

"Delta 字形而不是 \\u 转义符。）::"

#: ../../howto/unicode.rst:217

msgid ""

">>> \"\\N{GREEK CAPITAL LETTER DELTA}\" # Using the character name\n"

"'\\u0394'\n"

">>> \"\\u0394\" # Using a 16-bit hex value\n"

"'\\u0394'\n"

">>> \"\\U00000394\" # Using a 32-bit hex value\n"

"'\\u0394'"

msgstr ""

">>> \"\\N{GREEK CAPITAL LETTER DELTA}\" # 使用字符名称\n"

"'\\u0394'\n"

">>> \"\\u0394\" # 使用 16 比特位十六进制数值\n"

"'\\u0394'\n"

">>> \"\\U00000394\" # 使用 32 比特位十六进制数值\n"

"'\\u0394'"

#: ../../howto/unicode.rst:224

msgid ""

"In addition, one can create a string using the :func:`~bytes.decode` method "

"of :class:`bytes`. This method takes an *encoding* argument, such as "

"``UTF-8``, and optionally an *errors* argument."

msgstr ""

"此外，可以用 :class:`bytes` 的 :func:`~bytes.decode` 方法创建一个字符串。该方法可以接受 *encoding* "

"参数，比如可以为 ``UTF-8``，以及可选的 *errors* 参数。"

#: ../../howto/unicode.rst:228

msgid ""

"The *errors* argument specifies the response when the input string can't be "

"converted according to the encoding's rules. Legal values for this argument"

" are ``'strict'`` (raise a :exc:`UnicodeDecodeError` exception), "

"``'replace'`` (use ``U+FFFD``, ``REPLACEMENT CHARACTER``), ``'ignore'`` "

"(just leave the character out of the Unicode result), or "

"``'backslashreplace'`` (inserts a ``\\xNN`` escape sequence). The following "

"examples show the differences::"

msgstr ""

"若无法根据编码规则对输入字符串进行编码，*errors* 参数指定了响应策略。该参数的合法值可以是 ``'strict'`` (触发 "

":exc:`UnicodeDecodeError` 异常)、``'replace'`` (用 ``U+FFFD``、``REPLACEMENT "

"CHARACTER``)、``'ignore'`` (只是将字符从 Unicode 结果中去掉)，或 ``'backslashreplace'`` "

"(插入一个 ``\\xNN`` 转义序列)。以下示例演示了这些不同的参数::"

#: ../../howto/unicode.rst:236

msgid ""

">>> b'\\x80abc'.decode(\"utf-8\", \"strict\")\n"

"Traceback (most recent call last):\n"

" ...\n"

"UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0:\n"

" invalid start byte\n"

">>> b'\\x80abc'.decode(\"utf-8\", \"replace\")\n"

"'\\ufffdabc'\n"

">>> b'\\x80abc'.decode(\"utf-8\", \"backslashreplace\")\n"

"'\\\\x80abc'\n"

">>> b'\\x80abc'.decode(\"utf-8\", \"ignore\")\n"

"'abc'"

msgstr ""

">>> b'\\x80abc'.decode(\"utf-8\", \"strict\")\n"

"Traceback (most recent call last):\n"

" ...\n"

"UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0:\n"

" invalid start byte\n"

">>> b'\\x80abc'.decode(\"utf-8\", \"replace\")\n"

"'\\ufffdabc'\n"

">>> b'\\x80abc'.decode(\"utf-8\", \"backslashreplace\")\n"

"'\\\\x80abc'\n"

">>> b'\\x80abc'.decode(\"utf-8\", \"ignore\")\n"

"'abc'"

#: ../../howto/unicode.rst:248

msgid ""

"Encodings are specified as strings containing the encoding's name. Python "

"comes with roughly 100 different encodings; see the Python Library Reference"

" at :ref:`standard-encodings` for a list. Some encodings have multiple "

"names; for example, ``'latin-1'``, ``'iso_8859_1'`` and ``'8859``' are all "

"synonyms for the same encoding."

msgstr ""

"编码格式以包含编码格式名称的字符串来指明。Python 有大约 100 种不同的编码格式；清单详见 Python 库参考文档 "

":ref:`standard-encodings`。一些编码格式有多个名称，比如 ``'latin-1'``、``'iso_8859_1'`` 和 "

"``'8859`` 都是指同一种编码。"

#: ../../howto/unicode.rst:254

msgid ""

"One-character Unicode strings can also be created with the :func:`chr` "

"built-in function, which takes integers and returns a Unicode string of "

"length 1 that contains the corresponding code point. The reverse operation "

"is the built-in :func:`ord` function that takes a one-character Unicode "

"string and returns the code point value::"

msgstr ""

"利用内置函数 :func:`chr` 还可以创建单字符的 Unicode 字符串，该函数可接受整数参数，并返回包含对应码位的长度为 1 的 "

"Unicode 字符串。内置函数 :func:`ord` 是其逆操作，参数为单个字符的 Unicode 字符串，并返回码位值::"

#: ../../howto/unicode.rst:260

msgid ""

">>> chr(57344)\n"

"'\\ue000'\n"

">>> ord('\\ue000')\n"

"57344"

msgstr ""

">>> chr(57344)\n"

"'\\ue000'\n"

">>> ord('\\ue000')\n"

"57344"

#: ../../howto/unicode.rst:266

msgid "Converting to Bytes"

msgstr "转换为字节"

#: ../../howto/unicode.rst:268

msgid ""

"The opposite method of :meth:`bytes.decode` is :meth:`str.encode`, which "

"returns a :class:`bytes` representation of the Unicode string, encoded in "

"the requested *encoding*."

msgstr ""

":meth:`bytes.decode` 的逆方法是 :meth:`str.encode`，它会返回 Unicode 字符串的 "

":class:`bytes` 形式，已按要求的 *encoding* 进行了编码。"

#: ../../howto/unicode.rst:272

msgid ""

"The *errors* parameter is the same as the parameter of the "

":meth:`~bytes.decode` method but supports a few more possible handlers. As "

"well as ``'strict'``, ``'ignore'``, and ``'replace'`` (which in this case "

"inserts a question mark instead of the unencodable character), there is also"

" ``'xmlcharrefreplace'`` (inserts an XML character reference), "

"``backslashreplace`` (inserts a ``\\uNNNN`` escape sequence) and "

"``namereplace`` (inserts a ``\\N{...}`` escape sequence)."

msgstr ""

"参数 *errors* 的意义与 :meth:`~bytes.decode` 方法相同，但支持更多可能的处理器。除了 ``'strict'``、 "

"``'ignore'`` 和 ``'replace'`` (这时会插入问号替换掉无法编码的字符)，还有 ``'xmlcharrefreplace'``"

" (插入一个 XML 字符引用)、``backslashreplace`` (插入一个 ``\\uNNNN`` 转义序列) 和 "

"``namereplace`` (插入一个 ``\\N{...}`` 转义序列)。"

#: ../../howto/unicode.rst:280

msgid "The following example shows the different results::"

msgstr "以下例子演示了各种不同的结果::"

#: ../../howto/unicode.rst:282

msgid ""

">>> u = chr(40960) + 'abcd' + chr(1972)\n"

">>> u.encode('utf-8')\n"

"b'\\xea\\x80\\x80abcd\\xde\\xb4'\n"

">>> u.encode('ascii')\n"

"Traceback (most recent call last):\n"

" ...\n"

"UnicodeEncodeError: 'ascii' codec can't encode character '\\ua000' in\n"

" position 0: ordinal not in range(128)\n"

">>> u.encode('ascii', 'ignore')\n"

"b'abcd'\n"

">>> u.encode('ascii', 'replace')\n"

"b'?abcd?'\n"

">>> u.encode('ascii', 'xmlcharrefreplace')\n"

"b'&#40960;abcd&#1972;'\n"

">>> u.encode('ascii', 'backslashreplace')\n"

"b'\\\\ua000abcd\\\\u07b4'\n"

">>> u.encode('ascii', 'namereplace')\n"

"b'\\\\N{YI SYLLABLE IT}abcd\\\\u07b4'"

msgstr ""

">>> u = chr(40960) + 'abcd' + chr(1972)\n"

">>> u.encode('utf-8')\n"

"b'\\xea\\x80\\x80abcd\\xde\\xb4'\n"

">>> u.encode('ascii')\n"

"Traceback (most recent call last):\n"

" ...\n"

"UnicodeEncodeError: 'ascii' codec can't encode character '\\ua000' in\n"

" position 0: ordinal not in range(128)\n"

">>> u.encode('ascii', 'ignore')\n"

"b'abcd'\n"

">>> u.encode('ascii', 'replace')\n"

"b'?abcd?'\n"

">>> u.encode('ascii', 'xmlcharrefreplace')\n"

"b'&#40960;abcd&#1972;'\n"

">>> u.encode('ascii', 'backslashreplace')\n"

"b'\\\\ua000abcd\\\\u07b4'\n"

">>> u.encode('ascii', 'namereplace')\n"

"b'\\\\N{YI SYLLABLE IT}abcd\\\\u07b4'"

#: ../../howto/unicode.rst:301

msgid ""

"The low-level routines for registering and accessing the available encodings"

" are found in the :mod:`codecs` module. Implementing new encodings also "

"requires understanding the :mod:`codecs` module. However, the encoding and "

"decoding functions returned by this module are usually more low-level than "

"is comfortable, and writing new encodings is a specialized task, so the "

"module won't be covered in this HOWTO."

msgstr ""

"用于注册和访问可用编码格式的底层函数，位于 :mod:`codecs` 模块中。若要实现新的编码格式，则还需要了解 :mod:`codecs` 模块。 "

"不过该模块返回的编码和解码函数通常更为底层一些，不大好用，编写新的编码格式是一项专业的任务，因此本文不会涉及该模块。"

#: ../../howto/unicode.rst:310

msgid "Unicode Literals in Python Source Code"

msgstr "Python 源代码中的 Unicode 字面值"

#: ../../howto/unicode.rst:312

msgid ""

"In Python source code, specific Unicode code points can be written using the"

" ``\\u`` escape sequence, which is followed by four hex digits giving the "

"code point. The ``\\U`` escape sequence is similar, but expects eight hex "

"digits, not four::"

msgstr ""

"在 Python 源代码中，可以用 ``\\u`` 转义序列书写特定的 Unicode 码位，该序列后跟 4 个代表码位的十六进制数字。``\\U`` "

"转义序列用法类似，但要用 8 个十六进制数字，而不是 4 个::"

#: ../../howto/unicode.rst:317

msgid ""

">>> s = \"a\\xac\\u1234\\u20ac\\U00008000\"\n"

"... # ^^^^ two-digit hex escape\n"

"... # ^^^^^^ four-digit Unicode escape\n"

"... # ^^^^^^^^^^ eight-digit Unicode escape\n"

">>> [ord(c) for c in s]\n"

"[97, 172, 4660, 8364, 32768]"

msgstr ""

">>> s = \"a\\xac\\u1234\\u20ac\\U00008000\"\n"

"... # ^^^^ 两位十六进制数转义\n"

"... # ^^^^^^ 四位 Unicode 转义\n"

"... # ^^^^^^^^^^ 八位 Unicode 转义\n"

">>> [ord(c) for c in s]\n"

"[97, 172, 4660, 8364, 32768]"

#: ../../howto/unicode.rst:324

msgid ""

"Using escape sequences for code points greater than 127 is fine in small "

"doses, but becomes an annoyance if you're using many accented characters, as"

" you would in a program with messages in French or some other accent-using "

"language. You can also assemble strings using the :func:`chr` built-in "

"function, but this is even more tedious."

msgstr ""

"对大于 127 "

"的码位使用转义序列，数量不多时没什么问题，但如果要用到很多重音字符，这会变得很烦人，类似于程序中的信息是用法语或其他使用重音的语言写的。也可以用内置函数"

" :func:`chr` 拼装字符串，但会更加乏味。"

#: ../../howto/unicode.rst:330

msgid ""

"Ideally, you'd want to be able to write literals in your language's natural "

"encoding. You could then edit Python source code with your favorite editor "

"which would display the accented characters naturally, and have the right "

"characters used at runtime."

msgstr ""

"理想情况下，都希望能用母语的编码书写文本。还能用喜好的编辑器编辑 Python 源代码，编辑器要能自然地显示重音符，并在运行时使用正确的字符。"

#: ../../howto/unicode.rst:335

msgid ""

"Python supports writing source code in UTF-8 by default, but you can use "

"almost any encoding if you declare the encoding being used. This is done by"

" including a special comment as either the first or second line of the "

"source file::"

msgstr ""

"默认情况下，Python 支持以 UTF-8 "

"格式编写源代码，但如果声明要用的编码，则几乎可以使用任何编码。只要在源文件的第一行或第二行包含一个特殊注释即可::"

#: ../../howto/unicode.rst:339

msgid ""

"#!/usr/bin/env python\n"

"# -*- coding: latin-1 -*-\n"

"\n"

"u = 'abcdé'\n"

"print(ord(u[-1]))"

msgstr ""

"#!/usr/bin/env python\n"

"# -*- coding: latin-1 -*-\n"

"\n"

"u = 'abcdé'\n"

"print(ord(u[-1]))"

#: ../../howto/unicode.rst:345

msgid ""

"The syntax is inspired by Emacs's notation for specifying variables local to"

" a file. Emacs supports many different variables, but Python only supports "

"'coding'. The ``-*-`` symbols indicate to Emacs that the comment is "

"special; they have no significance to Python but are a convention. Python "

"looks for ``coding: name`` or ``coding=name`` in the comment."

msgstr ""

"上述语法的灵感来自于 Emacs 用于指定文件局部变量的符号。Emacs 支持许多不同的变量，但 Python 仅支持“编码”。``-*-`` 符号向 "

"Emacs 标明该注释是特殊的；这对 Python 没有什么意义，只是一种约定。Python 会在注释中查找 ``coding: name`` 或 "

"``coding=name``."

#: ../../howto/unicode.rst:351

msgid ""

"If you don't include such a comment, the default encoding used will be UTF-8"

" as already mentioned. See also :pep:`263` for more information."

msgstr "如果没有这种注释，则默认编码将会是前面提到的 UTF-8。更多信息请参阅 :pep:`263`。"

#: ../../howto/unicode.rst:358

msgid "Unicode Properties"

msgstr "Unicode 属性"

#: ../../howto/unicode.rst:360

msgid ""

"The Unicode specification includes a database of information about code "

"points. For each defined code point, the information includes the "

"character's name, its category, the numeric value if applicable (for "

"characters representing numeric concepts such as the Roman numerals, "

"fractions such as one-third and four-fifths, etc.). There are also display-"

"related properties, such as how to use the code point in bidirectional text."

msgstr ""

"Unicode "

"规范包含了一个码位信息数据库。对于定义的每一个码位，都包含了字符的名称、类别、数值（对于表示数字概念的字符，如罗马数字、分数如三分之一和五分之四等）。还有有关显示的属性，比如如何在双向文本中使用码位。"

#: ../../howto/unicode.rst:368

msgid ""

"The following program displays some information about several characters, "

"and prints the numeric value of one particular character::"

msgstr "以下程序显示了几个字符的信息，并打印一个字符的数值::"

#: ../../howto/unicode.rst:371

msgid ""

"import unicodedata\n"

"\n"

"u = chr(233) + chr(0x0bf2) + chr(3972) + chr(6000) + chr(13231)\n"

"\n"

"for i, c in enumerate(u):\n"

" print(i, '%04x' % ord(c), unicodedata.category(c), end=\" \")\n"

" print(unicodedata.name(c))\n"

"\n"

"# Get numeric value of second character\n"

"print(unicodedata.numeric(u[1]))"

msgstr ""

"import unicodedata\n"

"\n"

"u = chr(233) + chr(0x0bf2) + chr(3972) + chr(6000) + chr(13231)\n"

"\n"

"for i, c in enumerate(u):\n"

" print(i, '%04x' % ord(c), unicodedata.category(c), end=\" \")\n"

" print(unicodedata.name(c))\n"

"\n"

"# 获取第二个字符的数值\n"

"print(unicodedata.numeric(u[1]))"

#: ../../howto/unicode.rst:382

msgid "When run, this prints:"

msgstr "当运行时，这将打印出："

#: ../../howto/unicode.rst:384

msgid ""

"0 00e9 Ll LATIN SMALL LETTER E WITH ACUTE\n"

"1 0bf2 No TAMIL NUMBER ONE THOUSAND\n"

"2 0f84 Mn TIBETAN MARK HALANTA\n"

"3 1770 Lo TAGBANWA LETTER SA\n"

"4 33af So SQUARE RAD OVER S SQUARED\n"

"1000.0"

msgstr ""

"0 00e9 Ll LATIN SMALL LETTER E WITH ACUTE\n"

"1 0bf2 No TAMIL NUMBER ONE THOUSAND\n"

"2 0f84 Mn TIBETAN MARK HALANTA\n"

"3 1770 Lo TAGBANWA LETTER SA\n"

"4 33af So SQUARE RAD OVER S SQUARED\n"

"1000.0"

#: ../../howto/unicode.rst:393

msgid ""

"The category codes are abbreviations describing the nature of the character."

" These are grouped into categories such as \"Letter\", \"Number\", "

"\"Punctuation\", or \"Symbol\", which in turn are broken up into "

"subcategories. To take the codes from the above output, ``'Ll'`` means "

"'Letter, lowercase', ``'No'`` means \"Number, other\", ``'Mn'`` is \"Mark, "

"nonspacing\", and ``'So'`` is \"Symbol, other\". See `the General Category "

"Values section of the Unicode Character Database documentation "

"<https://www.unicode.org/reports/tr44/#General_Category_Values>`_ for a list"

" of category codes."

msgstr ""

"类别代码是描述字符性质的一个缩写。分为“字母”、“数字”、“标点符号”或“符号”等类别，而这些类别又分为子类别。就以上输出的代码而言，``'Ll'`` "

"表示“字母，小写”，``'No'`` 表示“数字，其他”，``'Mn'`` 表示“标记，非空白符” , ``'So'`` "

"是“符号，其他”。有关类别代码的清单，请参阅 `Unicode 字符库文档 "

"<https://www.unicode.org/reports/tr44/#General_Category_Values>`_ "

"的“通用类别值”部分。"

#: ../../howto/unicode.rst:404

msgid "Comparing Strings"

msgstr "字符串比较"

#: ../../howto/unicode.rst:406

msgid ""

"Unicode adds some complication to comparing strings, because the same set of"

" characters can be represented by different sequences of code points. For "

"example, a letter like 'ê' can be represented as a single code point U+00EA,"

" or as U+0065 U+0302, which is the code point for 'e' followed by a code "

"point for 'COMBINING CIRCUMFLEX ACCENT'. These will produce the same output"

" when printed, but one is a string of length 1 and the other is of length 2."

msgstr ""

"Unicode 让字符串的比较变得复杂了一些，因为同一组字符可能由不同的码位序列组成。例如，像“ê”这样的字母可以表示为单码位 U+00EA，或是 "

"U+0065 U+0302，即“e”的码位后跟“COMBINING CIRCUMFLEX "

"ACCENT”的码位。虽然在打印时会产生同样的输出，但一个是长度为 1 的字符串，另一个是长度为 2 的字符串。"

#: ../../howto/unicode.rst:414

msgid ""

"One tool for a case-insensitive comparison is the :meth:`~str.casefold` "

"string method that converts a string to a case-insensitive form following an"

" algorithm described by the Unicode Standard. This algorithm has special "

"handling for characters such as the German letter 'ß' (code point U+00DF), "

"which becomes the pair of lowercase letters 'ss'."

msgstr ""

"一种不区分大小写比较的工具是字符串方法 :meth:`~str.casefold`，将按照 Unicode "

"标准描述的算法将字符串转换为不区分大小写的形式。该算法对诸如德语字母“ß”（代码点 U+00DF）之类的字符进行了特殊处理，变为一对小写字母“ss”。"

#: ../../howto/unicode.rst:423

msgid ""

">>> street = 'Gürzenichstraße'\n"

">>> street.casefold()\n"

"'gürzenichstrasse'"

msgstr ""

">>> street = 'Gürzenichstraße'\n"

">>> street.casefold()\n"

"'gürzenichstrasse'"

#: ../../howto/unicode.rst:427

msgid ""

"A second tool is the :mod:`unicodedata` module's "

":func:`~unicodedata.normalize` function that converts strings to one of "

"several normal forms, where letters followed by a combining character are "

"replaced with single characters. :func:`~unicodedata.normalize` can be used"

" to perform string comparisons that won't falsely report inequality if two "

"strings use combining characters differently:"

msgstr ""

"第二个工具是 :mod:`unicodedata` 模块的 :func:`~unicodedata.normalize` "

"函数，该函数可将字符串转换为几种规范化形式之一，即用单字符替换后面带一个组合字符的多个字母。 "

":func:`~unicodedata.normalize` 可被用于执行字符串比较，如果两个字符串使用不同的组合字符，也不会错误地报告两者不相等："

#: ../../howto/unicode.rst:436

msgid ""

"import unicodedata\n"

"\n"

"def compare_strs(s1, s2):\n"

" def NFD(s):\n"

" return unicodedata.normalize('NFD', s)\n"

"\n"

" return NFD(s1) == NFD(s2)\n"

"\n"

"single_char = 'ê'\n"

"multiple_chars = '\\N{LATIN SMALL LETTER E}\\N{COMBINING CIRCUMFLEX ACCENT}'\n"

"print('length of first string=', len(single_char))\n"

"print('length of second string=', len(multiple_chars))\n"

"print(compare_strs(single_char, multiple_chars))"

msgstr ""

"import unicodedata\n"

"\n"

"def compare_strs(s1, s2):\n"

" def NFD(s):\n"

" return unicodedata.normalize('NFD', s)\n"

"\n"

" return NFD(s1) == NFD(s2)\n"

"\n"

"single_char = 'ê'\n"

"multiple_chars = '\\N{LATIN SMALL LETTER E}\\N{COMBINING CIRCUMFLEX ACCENT}'\n"

"print('length of first string=', len(single_char))\n"

"print('length of second string=', len(multiple_chars))\n"

"print(compare_strs(single_char, multiple_chars))"

#: ../../howto/unicode.rst:450

msgid "When run, this outputs:"

msgstr "当运行时，这将输出："

#: ../../howto/unicode.rst:452

msgid ""

"$ python compare-strs.py\n"

"length of first string= 1\n"

"length of second string= 2\n"

"True"

msgstr ""

"$ python compare-strs.py\n"

"length of first string= 1\n"

"length of second string= 2\n"

"True"

#: ../../howto/unicode.rst:459

msgid ""

"The first argument to the :func:`~unicodedata.normalize` function is a "

"string giving the desired normalization form, which can be one of 'NFC', "

"'NFKC', 'NFD', and 'NFKD'."

msgstr ""

":func:`~unicodedata.normalize` "

"函数的第一个参数是个字符串，给出所需的规范化形式，可以是“NFC”、“NFKC”、“NFD”和“NFKD”之一。"

#: ../../howto/unicode.rst:463

msgid "The Unicode Standard also specifies how to do caseless comparisons::"

msgstr "Unicode 标准还设定了如何进行不区分大小写的比较::"

#: ../../howto/unicode.rst:465

msgid ""

"import unicodedata\n"

"\n"

"def compare_caseless(s1, s2):\n"

" def NFD(s):\n"

" return unicodedata.normalize('NFD', s)\n"

"\n"

" return NFD(NFD(s1).casefold()) == NFD(NFD(s2).casefold())\n"

"\n"

"# Example usage\n"

"single_char = 'ê'\n"

"multiple_chars = '\\N{LATIN CAPITAL LETTER E}\\N{COMBINING CIRCUMFLEX ACCENT}'\n"

"\n"

"print(compare_caseless(single_char, multiple_chars))"

msgstr ""

"import unicodedata\n"

"\n"

"def compare_caseless(s1, s2):\n"

" def NFD(s):\n"

" return unicodedata.normalize('NFD', s)\n"

"\n"

" return NFD(NFD(s1).casefold()) == NFD(NFD(s2).casefold())\n"

"\n"

"# 使用示例\n"

"single_char = 'ê'\n"

"multiple_chars = '\\N{LATIN CAPITAL LETTER E}\\N{COMBINING CIRCUMFLEX ACCENT}'\n"

"\n"

"print(compare_caseless(single_char, multiple_chars))"

#: ../../howto/unicode.rst:479

msgid ""

"This will print ``True``. (Why is :func:`!NFD` invoked twice? Because "

"there are a few characters that make :meth:`~str.casefold` return a non-"

"normalized string, so the result needs to be normalized again. See section "

"3.13 of the Unicode Standard for a discussion and an example.)"

msgstr ""

"这将打印 ``True``。 （为什么 :func:`!NFD` 会被调用两次？因为有几个字符会使 :meth:`~str.casefold` "

"返回非规范化的字符串，所以需要再次对结果进行规范化处理。有关讨论和示例，请参阅 Unicode 标准第 3.13 节）。"

#: ../../howto/unicode.rst:486

msgid "Unicode Regular Expressions"

msgstr "Unicode 正则表达式"

#: ../../howto/unicode.rst:488

msgid ""

"The regular expressions supported by the :mod:`re` module can be provided "

"either as bytes or strings. Some of the special character sequences such as"

" ``\\d`` and ``\\w`` have different meanings depending on whether the "

"pattern is supplied as bytes or a string. For example, ``\\d`` will match "

"the characters ``[0-9]`` in bytes but in strings will match any character "

"that's in the ``'Nd'`` category."

msgstr ""

":mod:`re` 模块支持的正则表达式可以用字节串或字符串的形式提供。有一些特殊字符序列，比如 ``\\d`` 和 ``\\w`` "

"具有不同的含义，具体取决于匹配模式是以字节串还是字符串形式提供的。例如，``\\d`` 将匹配字节串中的字符 ``[0-9]``，但对于字符串将会匹配 "

"``'Nd'`` 类别中的任何字符。"

#: ../../howto/unicode.rst:495

msgid ""

"The string in this example has the number 57 written in both Thai and Arabic"

" numerals::"

msgstr "上述示例中的字符串包含了泰语和阿拉伯数字书写的数字 57::"

#: ../../howto/unicode.rst:498

msgid ""

"import re\n"

"p = re.compile(r'\\d+')\n"

"\n"

"s = \"Over \\u0e55\\u0e57 57 flavours\"\n"

"m = p.search(s)\n"

"print(repr(m.group()))"

msgstr ""

"import re\n"

"p = re.compile(r'\\d+')\n"

"\n"

"s = \"Over \\u0e55\\u0e57 57 flavours\"\n"

"m = p.search(s)\n"

"print(repr(m.group()))"

#: ../../howto/unicode.rst:505

msgid ""

"When executed, ``\\d+`` will match the Thai numerals and print them out. If"

" you supply the :const:`re.ASCII` flag to :func:`~re.compile`, ``\\d+`` will"

" match the substring \"57\" instead."

msgstr ""

"执行时，``\\d+`` 将匹配上泰语数字并打印出来。如果向 :func:`~re.compile` 提供的是 :const:`re.ASCII` "

"标志，``\\d+`` 则会匹配子串 \"57\"。"