unicode.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# tomo, 2021
# Shin Saito, 2021
# Takanori Suzuki <takanori@takanory.net>, 2023
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-03-28 14:18+0000\n"
"PO-Revision-Date: 2021-06-28 00:53+0000\n"
"Last-Translator: Takanori Suzuki <takanori@takanory.net>, 2023\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../howto/unicode.rst:5
msgid "Unicode HOWTO"
msgstr "Unicode HOWTO"

#: ../../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 ""
"この HOWTO 文書は、文字データの表現のための Unicode 仕様の Python におけるサ"
"ポートについて論じ、さらに 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 ""
"今日のプログラムは広範囲の文字を扱える必要があります。\n"
"アプリケーションは国際化され、ユーザーが選べる様々な言語でメッセージや出力を"
"表示します; 同じプログラムが、英語、フランス語、日本語、ヘブライ語、ロシア語"
"でエラーメッセージを出力する必要があるかもしれません。\n"
"Webコンテンツはどんな言語でも書かれる可能性がありますし、様々な絵文字が含まれ"
"ることもあります。\n"
"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/) は、人類の言語で使われる全ての文字を列挙"
"し、それぞれの文字自身の一意な符号を与えるのを目的とした仕様です。\n"
"Unicode 仕様は継続的に改訂され、新しい言語や記号を追加する更新がなされていま"
"す。"

#: ../../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 ""
"**文字** は文章の最小の構成要素です。\n"
"'A', 'B', 'C' などは全て異なる文字です。\n"
"'È' と 'Í' も同様に異なる文字です。\n"
"文字は、話している言語や文脈によって変わってきます。\n"
"例えば、「ローマ数字の 1」という文字 'Ⅰ' は大文字の 'I' とは別の文字です。\n"
"両者は通常は同じに見えますが、異なる意味を持つ別々の2つの文字です。"

#: ../../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 ""

#: ../../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 ""

#: ../../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`` はコードポイントであり、それはある特定の文字を表し"
"ているのです; この場合では、 'BLACK CHESS KNIGHT', '♞' という文字を表していま"
"す。\n"
"形式ばらない文脈では、このコードポイントと文字の区別は忘れ去られることもあり"
"ます。"

#: ../../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 "
"toolkit や端末のフォントレンダラーの仕事です。"

#: ../../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`` (10 進表記で 1,114,111) までの数値です。このコードポ"
"イント列はメモリ上では **コードユニット** 列として表され、その **コードユニッ"
"ト** 列は 8-bit のバイト列にマップされます。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 ""

#: ../../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 ""

#: ../../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 の使用量が増加するのはそれほど問題にはなりません (デスク"
"トップコンピュータはギガバイト単位の 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 ""
"``strlen()`` のような現存する C 関数と互換性がありません、そのためワイド文字"
"列関数一式が新たに必要となります。"

#: ../../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 ""

#: ../../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 ""

#: ../../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 以上の場合、128 から 255 までのバイトからなる、2、3 また"
"は 4 バイトのシーケンスに変換します。"

#: ../../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 ""

#: ../../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 はかなりコンパクトです; よく使われている文字の大多数は 1 バイトか 2 バ"
"イトで表現できます。"

#: ../../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-bit データは正当な 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 ""

#: ../../howto/unicode.rst:158 ../../howto/unicode.rst:514
#: ../../howto/unicode.rst:735
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 コンソーシアムのサイト <https://www.unicode.org>`_ には文字の図表、"
"用語辞典、PDF 版の Unicode 仕様があります。これ読むのはそれなりに難しいので覚"
"悟してください。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 ""

#: ../../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 ""

#: ../../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 の記事はしばしば役に立ちます; 例えば、\"`character encoding "
"<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 ""

#: ../../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 ""

#: ../../howto/unicode.rst:206
msgid ""
"Side note: Python 3 also supports using Unicode characters in identifiers::"
msgstr "追記: Python3 は 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 ""

#: ../../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 のみに保ちたい場合は、文字列リテラルでエスケープシーケンスが使えます。"
"(使ってるシステムによっては、\\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 ""

#: ../../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` メソッドを使って文字列"
"を作ることもできます。このメソッドは ``UTF-8`` のような値を *encoding* 引数に"
"取り、オプションで *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'`` (``REPLACEMENT CHARACTER`` "
"である ``U+FFFD`` を使う)、 ``'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 ""

#: ../../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 ""
"Unicode 文字列の一つの文字は :func:`chr` 組み込み関数で作成することができま"
"す、この関数は整数を引数にとり、対応するコードポイントを含む長さ1の Unicode "
"文字列を返します。逆の操作は :func:`ord` 組み込み関数です、この関数は一文字"
"の Unicode 文字列を引数にとり、コードポイント値を返します::"

#: ../../howto/unicode.rst:260
msgid ""
">>> chr(57344)\n"
"'\\ue000'\n"
">>> ord('\\ue000')\n"
"57344"
msgstr ""

#: ../../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 文字列を指定された *encoding* でエンコードして、 :"
"class:`bytes` による表現で返します。"

#: ../../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` メソッドのパラメータと同じものですが、"
"サポートされているハンドラの数がもう少し多いです。\n"
"``'strict'`` 、 ``'ignore'`` 、 ``'replace'`` (このメソッドでは、エンコードで"
"きなかった文字の代わりに疑問符を挿入する) の他に、 ``'xmlcharrefreplace'`` "
"(XML 文字参照を挿入する) と ``backslashreplace`` (エスケープシーケンス "
"``\\nNNNN`` を挿入する)、 ``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 ""

#: ../../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 では扱わ"
"ないことにします。"

#: ../../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`` を使い、続けてコードポイントを4桁の16進数を書きます。エスケープシーケ"
"ンス ``\\U`` も同様です、ただし4桁ではなく8桁の16進数を使います::"

#: ../../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 ""

#: ../../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 ""

#: ../../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 がサポートしているのは "
"'coding' のみです。 ``-*-`` の記法は 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:356
msgid "Unicode Properties"
msgstr "Unicode プロパティ"

#: ../../howto/unicode.rst:358
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 ""

#: ../../howto/unicode.rst:366
msgid ""
"The following program displays some information about several characters, "
"and prints the numeric value of one particular character::"
msgstr ""
"以下のプログラムはいくつかの文字に対する情報を表示し、特定の文字の数値を印字"
"します::"

#: ../../howto/unicode.rst:369
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 ""

#: ../../howto/unicode.rst:380
msgid "When run, this prints:"
msgstr "実行すると、このように出力されます::"

#: ../../howto/unicode.rst:382
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 ""

#: ../../howto/unicode.rst:391
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 ""
"カテゴリーコードは文字の性質を略記で表したものです。カテゴリーコードは "
"\"Letter\"、\"Number\"、\"Punctuation\"、\"Symbol\" などのカテゴリーに分類さ"
"れ、さらにサブカテゴリーに細分化されます。上記の出力からコードを拾うと、"
"``'Ll'`` は 'Letter, lowercase'、``'No'`` は \"Number, other\"、``'Mn'`` は "
"\"Mark, nonspacing\"、``'So'`` は \"Symbol, other\" を意味しています。カテゴ"
"リーコードの一覧は `Unicode Character Database 文書の General Category "
"Values 節 <https://www.unicode.org/reports/tr44/#General_Category_Values>`_ "
"を参照してください。"

#: ../../howto/unicode.rst:402
msgid "Comparing Strings"
msgstr ""

#: ../../howto/unicode.rst:404
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 ""

#: ../../howto/unicode.rst:412
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 ""

#: ../../howto/unicode.rst:421
msgid ""
">>> street = 'Gürzenichstraße'\n"
">>> street.casefold()\n"
"'gürzenichstrasse'"
msgstr ""

#: ../../howto/unicode.rst:425
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 ""

#: ../../howto/unicode.rst:434
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 ""

#: ../../howto/unicode.rst:448
msgid "When run, this outputs:"
msgstr "実行すると、このように出力されます:"

#: ../../howto/unicode.rst:450
msgid ""
"$ python compare-strs.py\n"
"length of first string= 1\n"
"length of second string= 2\n"
"True"
msgstr ""

#: ../../howto/unicode.rst:457
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 ""

#: ../../howto/unicode.rst:461
msgid "The Unicode Standard also specifies how to do caseless comparisons::"
msgstr ""

#: ../../howto/unicode.rst:463
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 ""

#: ../../howto/unicode.rst:477
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 ""

#: ../../howto/unicode.rst:484
msgid "Unicode Regular Expressions"
msgstr "Unicode 正規表現"

#: ../../howto/unicode.rst:486
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:493
msgid ""
"The string in this example has the number 57 written in both Thai and Arabic "
"numerals::"
msgstr ""
"この例にある文字列には、タイ語の数字とアラビア数字の両方で数字の 57 が書いて"
"あります。"

#: ../../howto/unicode.rst:496
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 ""

#: ../../howto/unicode.rst:503
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+`` はタイ語の数字と一致し、それを出力します。フラグ :"
"const:`re.ASCII` を :func:`~re.compile` に渡した場合、 ``\\d+`` は先程とは"
"違って部分文字列 \"57\" に一致します。"

#: ../../howto/unicode.rst:507
msgid ""
"Similarly, ``\\w`` matches a wide variety of Unicode characters but only "
"``[a-zA-Z0-9_]`` in bytes or if :const:`re.ASCII` is supplied, and ``\\s`` "
"will match either Unicode whitespace characters or ``[ \\t\\n\\r\\f\\v]``."
msgstr ""
"同様に、 ``\\w`` は非常に多くの Unicode 文字に一致しますが、バイト列の場合も"
"しくは :const:`re.ASCII` が渡された場合は ``[a-zA-Z0-9_]`` にしか一致しませ"
"ん。 ``\\s`` は文字列では Unicode 空白文字に、バイト列では "
"``[ \\t\\n\\r\\f\\v]`` に一致します。"

#: ../../howto/unicode.rst:518
msgid "Some good alternative discussions of Python's Unicode support are:"
msgstr "Python の Unicode サポートについての参考になる議論は以下の2つです:"

#: ../../howto/unicode.rst:520
msgid ""
"`Processing Text Files in Python 3 <https://python-notes.curiousefficiency."
"org/en/latest/python3/text_file_processing.html>`_, by Nick Coghlan."
msgstr ""
"Nick Coghlan による `Processing Text Files in Python 3 <https://python-notes."
"curiousefficiency.org/en/latest/python3/text_file_processing.html>`_"

#: ../../howto/unicode.rst:521
msgid ""
"`Pragmatic Unicode <https://nedbatchelder.com/text/unipain.html>`_, a PyCon "
"2012 presentation by Ned Batchelder."
msgstr ""
"Ned Batchelder による PyCon 2012 での発表 `Pragmatic Unicode <https://"
"nedbatchelder.com/text/unipain.html>`_"

#: ../../howto/unicode.rst:523
msgid ""
"The :class:`str` type is described in the Python library reference at :ref:"
"`textseq`."
msgstr ""
":class:`str` 型については Python ライブラリリファレンスの :ref:`textseq` で解"
"説されています。"

#: ../../howto/unicode.rst:526
msgid "The documentation for the :mod:`unicodedata` module."
msgstr ":mod:`unicodedata` モジュールについてのドキュメント。"

#: ../../howto/unicode.rst:528
msgid "The documentation for the :mod:`codecs` module."
msgstr ":mod:`codecs` モジュールについてのドキュメント。"

#: ../../howto/unicode.rst:530
msgid ""
"Marc-André Lemburg gave `a presentation titled \"Python and Unicode\" (PDF "
"slides) <https://downloads.egenix.com/python/Unicode-EPC2002-Talk.pdf>`_ at "
"EuroPython 2002.  The slides are an excellent overview of the design of "
"Python 2's Unicode features (where the Unicode string type is called "
"``unicode`` and literals start with ``u``)."
msgstr ""
"Marc-André Lemburg は EuroPython 2002 で `\"Python and Unicode\" というタイト"
"ルのプレゼンテーション (PDF スライド) <https://downloads.egenix.com/python/"
"Unicode-EPC2002-Talk.pdf>`_ を行いました。このスライドは Python 2 の Unicode "
"機能 (Unicode 文字列型が ``unicode`` と呼ばれ、リテラルは ``u`` で始まりま"
"す) の設計について概観する素晴しい資料です。"

#: ../../howto/unicode.rst:538
msgid "Reading and Writing Unicode Data"
msgstr "Unicode データを読み書きする"

#: ../../howto/unicode.rst:540
msgid ""
"Once you've written some code that works with Unicode data, the next problem "
"is input/output.  How do you get Unicode strings into your program, and how "
"do you convert Unicode into a form suitable for storage or transmission?"
msgstr ""
"一旦 Unicode データに対してコードが動作するように書き終えたら、次の問題は入出"
"力です。プログラムは Unicode 文字列をどう受けとり、どう Unicode を外部記憶装"
"置や送受信装置に適した形式に変換するのでしょう?"

#: ../../howto/unicode.rst:544
msgid ""
"It's possible that you may not need to do anything depending on your input "
"sources and output destinations; you should check whether the libraries used "
"in your application support Unicode natively.  XML parsers often return "
"Unicode data, for example.  Many relational databases also support Unicode-"
"valued columns and can return Unicode values from an SQL query."
msgstr ""
"入力ソースと出力先に依存しないような方法は可能です; アプリケーションに利用さ"
"れているライブラリが Unicode をそのままサポートしているかを調べなければいけま"
"せん。例えば XML パーサーは大抵 Unicode データを返します。多くのリレーショナ"
"ルデータベースも Unicode 値の入ったコラムをサポートしていますし、 SQL の問い"
"合わせで Unicode 値を返すことができます。"

#: ../../howto/unicode.rst:550
msgid ""
"Unicode data is usually converted to a particular encoding before it gets "
"written to disk or sent over a socket.  It's possible to do all the work "
"yourself: open a file, read an 8-bit bytes object from it, and convert the "
"bytes with ``bytes.decode(encoding)``.  However, the manual approach is not "
"recommended."
msgstr ""
"Unicode のデータはディスクに書き込まれたり、ソケットを介して送信されたりする"
"にあたって、通常、特定のエンコーディングに変換されます。推奨はされませんが、"
"これを手動で行うことも可能です。ファイルを開き、8バイトオブジェクトを読み込"
"み、バイト列を ``bytes.decode(encoding)`` で変換することにより実現できます。"

#: ../../howto/unicode.rst:555
msgid ""
"One problem is the multi-byte nature of encodings; one Unicode character can "
"be represented by several bytes.  If you want to read the file in arbitrary-"
"sized chunks (say, 1024 or 4096 bytes), you need to write error-handling "
"code to catch the case where only part of the bytes encoding a single "
"Unicode character are read at the end of a chunk.  One solution would be to "
"read the entire file into memory and then perform the decoding, but that "
"prevents you from working with files that are extremely large; if you need "
"to read a 2 GiB file, you need 2 GiB of RAM. (More, really, since for at "
"least a moment you'd need to have both the encoded string and its Unicode "
"version in memory.)"
msgstr ""
"1つの問題はエンコーディングがマルチバイトに渡るという性質です; 1つの Unicode "
"文字はいくつかのバイトで表現され得ます。任意のサイズのチャンク (例えば、1024 "
"もしくは 4096 バイト) にファイルの内容を読み込みたい場合、ある1つの Unicode "
"文字をエンコードしたバイト列の一部だけがチャンクの末尾まで読み込まれたケース"
"に対応する、エラー処理コードを書く必要があります。1つの解決策はファイル全体を"
"メモリに読み込み、デコード処理を実行することですが、こうしてしまうと非常に大"
"きなファイルを処理するときの妨げになります; 2 GiB のファイルを読み込む必要が"
"ある場合、2 GiB の RAM が必要になります。(実際には、少なくともある瞬間では、"
"エンコードされた文字列と Unicode 文字列の両方をメモリに保持する必要があるた"
"め、より多くのメモリが必要です。)"

#: ../../howto/unicode.rst:565
msgid ""
"The solution would be to use the low-level decoding interface to catch the "
"case of partial coding sequences.  The work of implementing this has already "
"been done for you: the built-in :func:`open` function can return a file-like "
"object that assumes the file's contents are in a specified encoding and "
"accepts Unicode parameters for methods such as :meth:`~io.TextIOBase.read` "
"and :meth:`~io.TextIOBase.write`.  This works through :func:`open`\\'s "
"*encoding* and *errors* parameters which are interpreted just like those in :"
"meth:`str.encode` and :meth:`bytes.decode`."
msgstr ""

#: ../../howto/unicode.rst:574
msgid "Reading Unicode from a file is therefore simple::"
msgstr "そのためファイルから Unicode を読むのは単純です::"

#: ../../howto/unicode.rst:576
msgid ""
"with open('unicode.txt', encoding='utf-8') as f:\n"
"    for line in f:\n"
"        print(repr(line))"
msgstr ""

#: ../../howto/unicode.rst:580
msgid ""
"It's also possible to open files in update mode, allowing both reading and "
"writing::"
msgstr "読み書きの両方ができる update モードでファイルを開くことも可能です::"

#: ../../howto/unicode.rst:583
msgid ""
"with open('test', encoding='utf-8', mode='w+') as f:\n"
"    f.write('\\u4500 blah blah blah\\n')\n"
"    f.seek(0)\n"
"    print(repr(f.readline()[:1]))"
msgstr ""

#: ../../howto/unicode.rst:588
msgid ""
"The Unicode character ``U+FEFF`` is used as a byte-order mark (BOM), and is "
"often written as the first character of a file in order to assist with "
"autodetection of the file's byte ordering.  Some encodings, such as UTF-16, "
"expect a BOM to be present at the start of a file; when such an encoding is "
"used, the BOM will be automatically written as the first character and will "
"be silently dropped when the file is read.  There are variants of these "
"encodings, such as 'utf-16-le' and 'utf-16-be' for little-endian and big-"
"endian encodings, that specify one particular byte ordering and don't skip "
"the BOM."
msgstr ""
"Unicode 文字 ``U+FEFF`` は byte-order mark (BOM) として使われ、ファイルのバイ"
"ト順の自動判定を支援するために、ファイルの最初の文字として書かれます。UTF-16 "
"のようないくつかのエンコーディングは、ファイルの先頭に BOM があることを要求し"
"ます; そのようなエンコーディングが使われるとき、自動的に BOM が最初の文字とし"
"て書かれ、ファイルを読むときに暗黙の内に取り除かれます。これらのエンコーディ"
"ングには、リトルエンディアン (little-endian) 用の 'utf-16-le' やビッグエン"
"ディアン (big-endian) 用の 'utf-16-be' というような変種があり、これらは特定の"
"1つのバイト順を指定していて BOM をスキップしません。"

#: ../../howto/unicode.rst:597
msgid ""
"In some areas, it is also convention to use a \"BOM\" at the start of UTF-8 "
"encoded files; the name is misleading since UTF-8 is not byte-order "
"dependent. The mark simply announces that the file is encoded in UTF-8.  For "
"reading such files, use the 'utf-8-sig' codec to automatically skip the mark "
"if present."
msgstr ""

#: ../../howto/unicode.rst:604
msgid "Unicode filenames"
msgstr "Unicode ファイル名"

#: ../../howto/unicode.rst:606
msgid ""
"Most of the operating systems in common use today support filenames that "
"contain arbitrary Unicode characters.  Usually this is implemented by "
"converting the Unicode string into some encoding that varies depending on "
"the system.  Today Python is converging on using UTF-8: Python on MacOS has "
"used UTF-8 for several versions, and Python 3.6 switched to using UTF-8 on "
"Windows as well.  On Unix systems, there will only be a :term:`filesystem "
"encoding <filesystem encoding and error handler>`. if you've set the "
"``LANG`` or ``LC_CTYPE`` environment variables; if you haven't, the default "
"encoding is again UTF-8."
msgstr ""

#: ../../howto/unicode.rst:616
msgid ""
"The :func:`sys.getfilesystemencoding` function returns the encoding to use "
"on your current system, in case you want to do the encoding manually, but "
"there's not much reason to bother.  When opening a file for reading or "
"writing, you can usually just provide the Unicode string as the filename, "
"and it will be automatically converted to the right encoding for you::"
msgstr ""
":func:`sys.getfilesystemencoding` 関数は現在のシステムで利用するエンコーディ"
"ングを返し、エンコーディングを手動で設定したい場合利用します、ただしわざわざ"
"そうする積極的な理由はありません。読み書きのためにファイルを開く時には、ファ"
"イル名を Unicode 文字列として渡すだけで正しいエンコーディングに自動的に変更さ"
"れます::"

#: ../../howto/unicode.rst:622
msgid ""
"filename = 'filename\\u4500abc'\n"
"with open(filename, 'w') as f:\n"
"    f.write('blah\\n')"
msgstr ""

#: ../../howto/unicode.rst:626
msgid ""
"Functions in the :mod:`os` module such as :func:`os.stat` will also accept "
"Unicode filenames."
msgstr ""
":func:`os.stat` のような :mod:`os` モジュールの関数も Unicode のファイル名を"
"受け付けます。"

#: ../../howto/unicode.rst:629
msgid ""
"The :func:`os.listdir` function returns filenames, which raises an issue: "
"should it return the Unicode version of filenames, or should it return bytes "
"containing the encoded versions?  :func:`os.listdir` can do both, depending "
"on whether you provided the directory path as bytes or a Unicode string.  If "
"you pass a Unicode string as the path, filenames will be decoded using the "
"filesystem's encoding and a list of Unicode strings will be returned, while "
"passing a byte path will return the filenames as bytes.  For example, "
"assuming the default :term:`filesystem encoding <filesystem encoding and "
"error handler>` is UTF-8, running the following program::"
msgstr ""

#: ../../howto/unicode.rst:639
msgid ""
"fn = 'filename\\u4500abc'\n"
"f = open(fn, 'w')\n"
"f.close()\n"
"\n"
"import os\n"
"print(os.listdir(b'.'))\n"
"print(os.listdir('.'))"
msgstr ""

#: ../../howto/unicode.rst:647
msgid "will produce the following output:"
msgstr "以下の出力結果が生成されます:"

#: ../../howto/unicode.rst:649
msgid ""
"$ python listdir-test.py\n"
"[b'filename\\xe4\\x94\\x80abc', ...]\n"
"['filename\\u4500abc', ...]"
msgstr ""

#: ../../howto/unicode.rst:655
msgid ""
"The first list contains UTF-8-encoded filenames, and the second list "
"contains the Unicode versions."
msgstr ""
"最初のリストは UTF-8 でエンコーディングされたファイル名を含み、第二のリスト"
"は Unicode 版を含んでいます。"

#: ../../howto/unicode.rst:658
msgid ""
"Note that on most occasions, you should can just stick with using Unicode "
"with these APIs.  The bytes APIs should only be used on systems where "
"undecodable file names can be present; that's pretty much only Unix systems "
"now."
msgstr ""

#: ../../howto/unicode.rst:665
msgid "Tips for Writing Unicode-aware Programs"
msgstr "Unicode 対応のプログラムを書くための Tips"

#: ../../howto/unicode.rst:667
msgid ""
"This section provides some suggestions on writing software that deals with "
"Unicode."
msgstr ""
"この章では Unicode を扱うプログラムを書くためのいくつかの提案を紹介します。"

#: ../../howto/unicode.rst:670
msgid "The most important tip is:"
msgstr "最も重要な助言としては:"

#: ../../howto/unicode.rst:672
msgid ""
"Software should only work with Unicode strings internally, decoding the "
"input data as soon as possible and encoding the output only at the end."
msgstr ""
"ソフトウェアは内部では Unicode 文字列のみを利用し、入力データはできるだけ早期"
"にデコードし、出力の直前でエンコードすべきです。"

#: ../../howto/unicode.rst:675
msgid ""
"If you attempt to write processing functions that accept both Unicode and "
"byte strings, you will find your program vulnerable to bugs wherever you "
"combine the two different kinds of strings.  There is no automatic encoding "
"or decoding: if you do e.g. ``str + bytes``, a :exc:`TypeError` will be "
"raised."
msgstr ""

#: ../../howto/unicode.rst:680
msgid ""
"When using data coming from a web browser or some other untrusted source, a "
"common technique is to check for illegal characters in a string before using "
"the string in a generated command line or storing it in a database.  If "
"you're doing this, be careful to check the decoded string, not the encoded "
"bytes data; some encodings may have interesting properties, such as not "
"being bijective or not being fully ASCII-compatible.  This is especially "
"true if the input data also specifies the encoding, since the attacker can "
"then choose a clever way to hide malicious text in the encoded bytestream."
msgstr ""
"web ブラウザから来るデータやその他の信頼できないところからのデータを利用する"
"場合、それらの文字列から生成したコマンド行の実行や、それらの文字列をデータ"
"ベースに蓄える前に文字列の中に不正な文字が含まれていないか確認するのが一般的"
"です。もしそういう状況になった場合には、エンコードされたバイトデータではな"
"く、デコードされた文字列のチェックを入念に行なって下さい; いくつかのエンコー"
"ディングは問題となる性質を持っています、例えば全単射でなかったり、完全に "
"ASCII 互換でないなど。入力データがエンコーディングを指定している場合でもそう"
"して下さい、なぜなら攻撃者は巧みに悪意あるテキストをエンコードした文字列の中"
"に隠すことができるからです。"

#: ../../howto/unicode.rst:691
msgid "Converting Between File Encodings"
msgstr "ファイルエンコーディングの変換"

#: ../../howto/unicode.rst:693
msgid ""
"The :class:`~codecs.StreamRecoder` class can transparently convert between "
"encodings, taking a stream that returns data in encoding #1 and behaving "
"like a stream returning data in encoding #2."
msgstr ""

#: ../../howto/unicode.rst:697
msgid ""
"For example, if you have an input file *f* that's in Latin-1, you can wrap "
"it with a :class:`~codecs.StreamRecoder` to return bytes encoded in UTF-8::"
msgstr ""

#: ../../howto/unicode.rst:701
msgid ""
"new_f = codecs.StreamRecoder(f,\n"
"    # en/decoder: used by read() to encode its results and\n"
"    # by write() to decode its input.\n"
"    codecs.getencoder('utf-8'), codecs.getdecoder('utf-8'),\n"
"\n"
"    # reader/writer: used to read and write to the stream.\n"
"    codecs.getreader('latin-1'), codecs.getwriter('latin-1') )"
msgstr ""

#: ../../howto/unicode.rst:711
msgid "Files in an Unknown Encoding"
msgstr "不明なエンコーディングのファイル"

#: ../../howto/unicode.rst:713
msgid ""
"What can you do if you need to make a change to a file, but don't know the "
"file's encoding?  If you know the encoding is ASCII-compatible and only want "
"to examine or modify the ASCII parts, you can open the file with the "
"``surrogateescape`` error handler::"
msgstr ""

#: ../../howto/unicode.rst:718
msgid ""
"with open(fname, 'r', encoding=\"ascii\", errors=\"surrogateescape\") as f:\n"
"    data = f.read()\n"
"\n"
"# make changes to the string 'data'\n"
"\n"
"with open(fname + '.new', 'w',\n"
"          encoding=\"ascii\", errors=\"surrogateescape\") as f:\n"
"    f.write(data)"
msgstr ""

#: ../../howto/unicode.rst:727
msgid ""
"The ``surrogateescape`` error handler will decode any non-ASCII bytes as "
"code points in a special range running from U+DC80 to U+DCFF.  These code "
"points will then turn back into the same bytes when the ``surrogateescape`` "
"error handler is used to encode the data and write it back out."
msgstr ""

#: ../../howto/unicode.rst:737
msgid ""
"One section of `Mastering Python 3 Input/Output <https://pyvideo.org/"
"video/289/pycon-2010--mastering-python-3-i-o>`_, a PyCon 2010 talk by David "
"Beazley, discusses text processing and binary data handling."
msgstr ""

#: ../../howto/unicode.rst:741
msgid ""
"The `PDF slides for Marc-André Lemburg's presentation \"Writing Unicode-"
"aware Applications in Python\" <https://downloads.egenix.com/python/LSM2005-"
"Developing-Unicode-aware-applications-in-Python.pdf>`_ discuss questions of "
"character encodings as well as how to internationalize and localize an "
"application.  These slides cover Python 2.x only."
msgstr ""
"Marc-André Lemburg のプレゼンテーション \"Writing Unicode-aware Applications "
"in Python\" の PDF スライドが <https://downloads.egenix.com/python/LSM2005-"
"Developing-Unicode-aware-applications-in-Python.pdf> から入手可能です、そして"
"文字エンコーディングの問題と同様にアプリケーションの国際化やローカライズにつ"
"いても議論されています。このスライドは Python 2.x のみをカバーしています。"

#: ../../howto/unicode.rst:747
msgid ""
"`The Guts of Unicode in Python <https://pyvideo.org/video/1768/the-guts-of-"
"unicode-in-python>`_ is a PyCon 2013 talk by Benjamin Peterson that "
"discusses the internal Unicode representation in Python 3.3."
msgstr ""

#: ../../howto/unicode.rst:754
msgid "Acknowledgements"
msgstr "謝辞"

#: ../../howto/unicode.rst:756
msgid ""
"The initial draft of this document was written by Andrew Kuchling. It has "
"since been revised further by Alexander Belopolsky, Georg Brandl, Andrew "
"Kuchling, and Ezio Melotti."
msgstr ""
"このドキュメントの最初の草稿は Andrew Kuchling によって書かれました。それから"
"さらに Alexander Belopolsky, Georg Brandl, Andrew Kuchling, Ezio Melotti らで"
"改訂が重ねられています。"

#: ../../howto/unicode.rst:760
msgid ""
"Thanks to the following people who have noted errors or offered suggestions "
"on this article: Éric Araujo, Nicholas Bastin, Nick Coghlan, Marius "
"Gedminas, Kent Johnson, Ken Krugler, Marc-André Lemburg, Martin von Löwis, "
"Terry J. Reedy, Serhiy Storchaka, Eryk Sun, Chad Whitacre, Graham Wideman."
msgstr ""
"この記事中の誤りの指摘や提案を申し出てくれた以下の人々に感謝します: Éric "
"Araujo, Nicholas Bastin, Nick Coghlan, Marius Gedminas, Kent Johnson, Ken "
"Krugler, Marc-André Lemburg, Martin von Löwis, Terry J. Reedy, Serhiy "
"Storchaka, Eryk Sun, Chad Whitacre, Graham Wideman."