Unicode HOWTO
*************

この HOWTO 文書は、文字データの表現のための Unicode 仕様の Python にお
けるサポートについて論じ、さらに Unicode を使おうというときによく出喰
わす多くの問題について説明します。


Unicode 入門
============


定義
----

今日のプログラムは広範囲の文字を扱える必要があります。 アプリケーショ
ンは国際化され、ユーザーが選べる様々な言語でメッセージや出力を表示しま
す; 同じプログラムが、英語、フランス語、日本語、ヘブライ語、ロシア語で
エラーメッセージを出力する必要があるかもしれません。 Webコンテンツはど
んな言語でも書かれる可能性がありますし、様々な絵文字が含まれることもあ
ります。 Python の文字列型は文字表現のための Unicode 標準を使っていて
、 Python プログラムは有り得る様々な文字を全て扱えます。

Unicode (https://www.unicode.org/) は、人類の言語で使われる全ての文字
を列挙し、それぞれの文字自身の一意な符号を与えるのを目的とした仕様です
。 Unicode 仕様は継続的に改訂され、新しい言語や記号を追加する更新がな
されています。

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

Unicode 標準は、文字を **コードポイント** で表す方法を定めています。
コードポイントの値は 0 から 0x10FFFF までの整数です (約 110 万個の値が
あり、実際に割り当てられた数 はそれより少なくなっています)。 標準とこ
の文書では、"U+265E" という表記で、値が "0x265e" (10 進数では 9,822)
の文字を表します。

Unicode 標準は、文字とそれに対応するコードポイントを列挙した多くの表を
含んでいます:

   0061    'a'; LATIN SMALL LETTER A
   0062    'b'; LATIN SMALL LETTER B
   0063    'c'; LATIN SMALL LETTER C
   ...
   007B    '{'; LEFT CURLY BRACKET
   ...
   2167    'Ⅷ'; ROMAN NUMERAL EIGHT
   2168    'Ⅸ'; ROMAN NUMERAL NINE
   ...
   265E    '♞'; BLACK CHESS KNIGHT
   265F    '♟'; BLACK CHESS PAWN
   ...
   1F600   '😀'; GRINNING FACE
   1F609   '😉'; WINKING FACE
   ...

厳密には、この定義から「これは文字 "U+265E" です」と言うのは意味の無い
ことだと分かります。"U+265E" はコードポイントであり、それはある特定の
文字を表しているのです; この場合では、 'BLACK CHESS KNIGHT', '♞' とい
う文字を表しています。 形式ばらない文脈では、このコードポイントと文字
の区別は忘れ去られることもあります。

文字は画面や紙面上では **グリフ (glyph)** と呼ばれるグラフィック要素の
組で表示されます。大文字の A のグリフは例えば、厳密な形は使っているフ
ォントによって異なりますが、斜めの線と水平の線です。たいていの Python
コードではグリフの心配をする必要はありません; 一般的には表示する正しい
グリフを見付けることは GUI toolkit や端末のフォントレンダラーの仕事で
す。


エンコーディング
----------------

前の節をまとめると: Unicode 文字列はコードポイントの列であり、コードポ
イントとは 0 から "0x10FFFF" (10 進表記で 1,114,111) までの数値です。
このコードポイント列はメモリ上では **コードユニット** 列として表され、
その **コードユニット** 列は 8-bit のバイト列にマップされます。Unicode
文字列をバイト列として翻訳する規則を **文字エンコーディング** または単
に **エンコーディング** と呼びます。

最初に思い付くエンコーディングは、32 ビット整数をコードユニットとし、
CPU の 32 ビット整数表現を使う方法かもしれません。 この方法では、文字
列 "Python" は例えば次のように表されます。

      P           y           t           h           o           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
      0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

この表現は直接的でわかりやすい方法ですが、この表現を使うにはいくつかの
問題があります。

1. 可搬性がない; プロセッサが異なるとバイトの順序づけも変わってしまい
   ます。

2. 無駄な領域が多いです。多くの文書では、コードポイントは 127 未満もし
   くは 255 未満が多数派を占め、そのため多くの領域が "0x00" というバイ
   トで埋め尽くされます。上の文字列は、ASCII 表現では 6 バイトなのに対
   し、24 バイトのサイズになっています。RAM の使用量が増加するのはそれ
   ほど問題にはなりません (デスクトップコンピュータはギガバイト単位の
   RAM を持っており、通常、文字列はそんな大きさにはなりません) が、デ
   ィスクとネットワーク帯域が 4 倍多く使われてしまうのは我慢できるもの
   ではありません。

3. "strlen()" のような現存する C 関数と互換性がありません、そのためワ
   イド文字列関数一式が新たに必要となります。

そのため、このエンコーディングはあまり使われず、代わりに UTF-8 のよう
な、より効率的で便利なエンコーディングが選ばれます。

UTF-8 は最も広く使われるエンコーディングの一つで、Python でもデフォル
トとしてよく使われます。 UTF は "Unicode Transformation Format" の略で
、「8」はエンコーディングに 8 ビットの値を使うことを意味します。
(UTF-16 や UTF-32 というエンコーディングもありますが、UTF-8 ほど頻繁に
は使われません。) UTF-8 は次の規則に従います。

1. コードポイントが 128 未満だった場合、対応するバイト値で表現します。

2. コードポイントが 128 以上の場合、128 から 255 までのバイトからなる
   、2、3 または 4 バイトのシーケンスに変換します。

UTF-8 はいくつかの便利な性質を持っています:

1. 任意の Unicode コードポイントを扱うことができる。

2. Unicode 文字列をバイト列に変換したとき、値がゼロのバイトが含まれる
   のは、それがヌル文字 (U+0000) を表す場合だけです。 そのため、UTF-8
   文字列は "strcpy()" などの C 関数で処理でき、文字列の終端以外ではゼ
   ロのバイトを扱えないプロトコルでも送信できます。

3. ASCII テキストの文字列は UTF-8 テキストとしても有効です。

4. UTF-8 はかなりコンパクトです; よく使われている文字の大多数は 1 バイ
   トか 2 バイトで表現できます。

5. バイトが欠落したり、失われた場合、次の UTF-8 でエンコードされたコー
   ドポイントの開始を決定し、再同期することができる可能性があります。
   同様の理由でランダムな 8-bit データは正当な UTF-8 とみなされにくく
   なっています。

6. UTF-8 はバイト単位のエンコーディングです。 各文字を、決まった 1 バ
   イト以上の並びで表すように定めています。 そのため、整数やワード単位
   のエンコーディングで生じ得るバイト順の問題を避けられます。 例えば
   UTF-16 や UTF-32 では、文字列をエンコードしたハードウェアによってバ
   イトの並びが変わります。


参考資料
--------

Unicode コンソーシアムのサイト には文字の図表、用語辞典、PDF 版の
Unicode 仕様があります。これ読むのはそれなりに難しいので覚悟してくださ
い。Unicode の起源と発展の 年表 もサイトにあります。

Computerphile の YouTube チャンネルでは、Tom Scott が Unicode と UTF-8
の歴史を簡潔に説明しています (9 分 36 秒)。

標準を理解する助けにするために、Jukka Korpela が Unicode 文字表を読む
ための 入門ガイド を書いています。

Joel Spolsky による別の 分かりやすい入門記事 もあります。 ここまでの説
明で理解できなかった場合は、先に進む前にそちらの記事を読んでみてくださ
い。

Wikipedia の記事はしばしば役に立ちます; 例えば、"character encoding"
や UTF-8 の記事を読んでみてください。


Python の Unicode サポート
==========================

ここまでで Unicode の基礎を学びました、ここから Python の Unicode 機能
に触れます。


文字列型
--------

Python 3.0 以降、"str" 型は Unicode 文字を格納します。 つまり、
""unicode rocks!""、"'unicode rocks!'"、または三重引用符の文字列構文で
作った文字列は、すべて Unicode として保存されます。

Python ソースコードのデフォルトエンコーディングは UTF-8 なので、文字列
リテラルの中に Unicode 文字をそのまま含めることができます:

   try:
       with open('/tmp/input.txt', 'r') as f:
           ...
   except OSError:
       # 「ファイルが見つからない」というエラーメッセージ。
       print("Fichier non trouvé")

追記: Python3 は Unicode 文字を使った識別子もサポートしています:

   répertoire = "/tmp/records.log"
   with open(répertoire, "w") as f:
       f.write("test\n")

エディターで特定の文字を入力できない場合や、何らかの理由でソースコード
を ASCII だけにしたい場合は、文字列リテラルでエスケープシーケンスを使
えます。 (システムによっては、u エスケープではなく、実際の大文字のデル
タのグリフが表示される場合があります。 )

   >>> "\N{GREEK CAPITAL LETTER DELTA}"  # 文字名を使う
   '\u0394'
   >>> "\u0394"                          # 16 ビットの 16 進数を使う
   '\u0394'
   >>> "\U00000394"                      # 32 ビットの 16 進数を使う
   '\u0394'

加えて、 "bytes" クラスの "decode()" メソッドを使って文字列を作ること
もできます。このメソッドは "UTF-8" のような値を *encoding* 引数に取り
、オプションで *errors* 引数を取ります。

*errors* 引数は、入力文字列に対しエンコーディングルールに従った変換が
できなかったときの対応方法を指定します。この引数に使える値は
"'strict'" ("UnicodeDecodeError" を送出する)、 "'replace'"
("REPLACEMENT CHARACTER" である "U+FFFD" を使う)、 "'ignore'" (結果と
なる Unicode から単に文字を除く) 、"'backslashreplace'" (エスケープシ
ーケンス "\xNN" を挿入する) です。次の例はこれらの違いを示しています:

   >>> b'\x80abc'.decode("utf-8", "strict")
   Traceback (most recent call last):
       ...
   UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0:
     invalid start byte
   >>> b'\x80abc'.decode("utf-8", "replace")
   '\ufffdabc'
   >>> b'\x80abc'.decode("utf-8", "backslashreplace")
   '\\x80abc'
   >>> b'\x80abc'.decode("utf-8", "ignore")
   'abc'

エンコーディングはエンコーディングの名前を含んだ文字列で指定されます。
Python はおよそ 100 の異なるエンコーディングに対応しています; 一覧は
Python ライブラリリファレンスの 標準エンコーディング を参照してくださ
い。いくつかのエンコーディングは複数の名前を持っています; 例えば、
"'latin-1'" と "'iso_8859_1'" と "'8859'" は全て同じエンコーディングの
別名です。

Unicode 文字列の一つの文字は "chr()" 組み込み関数で作成することができ
ます、この関数は整数を引数にとり、対応するコードポイントを含む長さ1の
Unicode 文字列を返します。逆の操作は "ord()" 組み込み関数です、この関
数は一文字の Unicode 文字列を引数にとり、コードポイント値を返します:

   >>> chr(57344)
   '\ue000'
   >>> ord('\ue000')
   57344


バイト列への変換
----------------

"bytes.decode()" とは処理が逆向きのメソッドが "str.encode()" です。こ
のメソッドは、 Unicode 文字列を指定された *encoding* でエンコードして
、 "bytes" による表現で返します。

*errors* 引数は "decode()" メソッドのパラメータと同じものですが、サポ
ートされているハンドラの数がもう少し多いです。 "'strict'" 、
"'ignore'" 、 "'replace'" (このメソッドでは、エンコードできなかった文
字の代わりに疑問符を挿入する) の他に、 "'xmlcharrefreplace'" (XML 文字
参照を挿入する) と "backslashreplace" (エスケープシーケンス "\uNNNN"
を挿入する)、 "namereplace" (エスケープシーケンス "\N{...}" を挿入する
) があります。

次の例では、それぞれの異なる処理結果が示されています:

   >>> u = chr(40960) + 'abcd' + chr(1972)
   >>> u.encode('utf-8')
   b'\xea\x80\x80abcd\xde\xb4'
   >>> u.encode('ascii')
   Traceback (most recent call last):
       ...
   UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
     position 0: ordinal not in range(128)
   >>> u.encode('ascii', 'ignore')
   b'abcd'
   >>> u.encode('ascii', 'replace')
   b'?abcd?'
   >>> u.encode('ascii', 'xmlcharrefreplace')
   b'&#40960;abcd&#1972;'
   >>> u.encode('ascii', 'backslashreplace')
   b'\\ua000abcd\\u07b4'
   >>> u.encode('ascii', 'namereplace')
   b'\\N{YI SYLLABLE IT}abcd\\u07b4'

利用可能なエンコーディングを登録したり、アクセスしたりする低レベルのル
ーチンは "codecs" モジュールにあります。新しいエンコーディングを実装す
るには、 "codecs" モジュールを理解していることも必要になります。しかし
、このモジュールのエンコードやデコードの関数は、使い勝手が良いというよ
り低レベルな関数で、新しいエンコーディングを書くのは特殊な作業なので、
この HOWTO では扱わないことにします。


Python ソースコード内の Unicode リテラル
----------------------------------------

Python のソースコード内では、特定のコードポイントはエスケープシーケン
ス "\u" を使い、続けてコードポイントを4桁の16進数を書きます。エスケー
プシーケンス "\U" も同様です、ただし4桁ではなく8桁の16進数を使います:

   >>> s = "a\xac\u1234\u20ac\U00008000"
   ... #     ^^^^ 2 桁の 16 進エスケープ
   ... #         ^^^^^^ 4 桁の Unicode エスケープ
   ... #                     ^^^^^^^^^^ 8 桁の Unicode エスケープ
   >>> [ord(c) for c in s]
   [97, 172, 4660, 8364, 32768]

127 より大きいコードポイントに対してエスケープシーケンスを使うのは、エ
スケープシーケンスがあまり多くないうちは有効ですが、フランス語等のアク
セントを使う言語でメッセージのような多くのアクセント文字を使う場合には
邪魔になります。文字を "chr()" 組み込み関数を使って組み上げることもで
きますが、それはさらに長くなってしまうでしょう。

理想的にはあなたの言語の自然なエンコーディングでリテラルを書くことでし
ょう。そうなれば、Python のソースコードをアクセント付きの文字を自然に
表示するお気に入りのエディタで編集し、実行時に正しい文字が得られます。

Python はデフォルトでは UTF-8 ソースコードを書くことができます、ただし
どのエンコーディングを使うかを宣言すればほとんどのエンコーディングを使
えます。それはソースファイルの一行目や二行目に特別なコメントを含めるこ
とによってできます:

   #!/usr/bin/env python
   # -*- coding: latin-1 -*-

   u = 'abcdé'
   print(ord(u[-1]))

この構文は Emacs のファイル固有の変数を指定する表記から影響を受けてい
ます。Emacs は様々な変数をサポートしていますが、Python がサポートして
いるのは 'coding' のみです。 "-*-" の記法は Emacs に対してコメントが特
別であることを示します。これは Python にとって意味はありませんが慣習で
使われています。 Python はコメント中に "coding: name" または
"coding=name" を探します。

このようなコメントを含んでいない場合、すでに述べた通り、使われるデフォ
ルトエンコーディングは UTF-8 になります。より詳しい情報は **PEP 263**
を参照してください。


Unicode プロパティ
------------------

Unicode の仕様には、コードポイントに関する情報のデータベースが含まれて
います。 定義済みのコードポイントごとに、文字名、カテゴリー、該当する
場合は数値 (ローマ数字や、3 分の 1、5 分の 4 などの分数といった、数の
概念を表す文字の場合) が記録されています。 双方向テキストでのコードポ
イントの使い方など、表示に関するプロパティもあります。

以下のプログラムはいくつかの文字に対する情報を表示し、特定の文字の数値
を印字します:

   import unicodedata

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

   for i, c in enumerate(u):
       print(i, '%04x' % ord(c), unicodedata.category(c), end=" ")
       print(unicodedata.name(c))

   # 2 番目の文字の数値を取得する
   print(unicodedata.numeric(u[1]))

実行すると、このように出力されます:

   0 00e9 Ll LATIN SMALL LETTER E WITH ACUTE
   1 0bf2 No TAMIL NUMBER ONE THOUSAND
   2 0f84 Mn TIBETAN MARK HALANTA
   3 1770 Lo TAGBANWA LETTER SA
   4 33af So SQUARE RAD OVER S SQUARED
   1000.0

カテゴリーコードは文字の性質を略記で表したものです。カテゴリーコードは
"Letter"、"Number"、"Punctuation"、"Symbol" などのカテゴリーに分類され
、さらにサブカテゴリーに細分化されます。上記の出力からコードを拾うと、
"'Ll'" は 'Letter, lowercase'、"'No'" は "Number, other"、"'Mn'" は
"Mark, nonspacing"、"'So'" は "Symbol, other" を意味しています。カテゴ
リーコードの一覧は Unicode Character Database 文書の General Category
Values 節 を参照してください。


文字列の比較
------------

Unicode では、同じ文字の並びを異なるコードポイント列で表せるため、文字
列の比較が少し複雑になります。 例えば「ê」は、一つのコードポイント
U+00EA でも、U+0065 U+0302 という並びでも表せます。 後者は「e」のコー
ドポイントの後に「COMBINING CIRCUMFLEX ACCENT」のコードポイントを置い
たものです。 表示すると同じ出力になりますが、一方は長さ 1、もう一方は
長さ 2 の文字列です。

大文字と小文字を区別しない比較に使える方法の一つが、文字列の
"casefold()" メソッドです。 Unicode 標準のアルゴリズムに従い、大文字と
小文字を区別しない形式に文字列を変換します。 このアルゴリズムは、ドイ
ツ語の「ß」(コードポイント U+00DF) などの文字を特別に扱い、この文字は
小文字二つの「ss」に変換されます。

   >>> street = 'Gürzenichstraße'
   >>> street.casefold()
   'gürzenichstrasse'

A second tool is the "unicodedata" module's "normalize()" function
that converts strings to one of several normal forms, where letters
followed by a combining character are replaced with single characters.
"normalize()" can be used to perform string comparisons that won't
falsely report inequality if two strings use combining characters
differently:

   import unicodedata

   def compare_strs(s1, s2):
       def NFD(s):
           return unicodedata.normalize('NFD', s)

       return NFD(s1) == NFD(s2)

   single_char = 'ê'
   multiple_chars = '\N{LATIN SMALL LETTER E}\N{COMBINING CIRCUMFLEX ACCENT}'
   print('length of first string=', len(single_char))
   print('length of second string=', len(multiple_chars))
   print(compare_strs(single_char, multiple_chars))

実行すると、このように出力されます:

   $ python compare-strs.py
   length of first string= 1
   length of second string= 2
   True

"normalize()" 関数の最初の引数は、目的の正規化形式を表す文字列です。
'NFC'、'NFKC'、'NFD'、'NFKD' のいずれかを指定できます。

Unicode 標準には、大文字と小文字を区別しない比較の方法も定められていま
す。

   import unicodedata

   def compare_caseless(s1, s2):
       def NFD(s):
           return unicodedata.normalize('NFD', s)

       return NFD(NFD(s1).casefold()) == NFD(NFD(s2).casefold())

   # 使用例
   single_char = 'ê'
   multiple_chars = '\N{LATIN CAPITAL LETTER E}\N{COMBINING CIRCUMFLEX ACCENT}'

   print(compare_caseless(single_char, multiple_chars))

この例は "True" を表示します。 ("NFD()" を 2 回呼び出すのはなぜでしょ
うか。 一部の文字では "casefold()" が正規化されていない文字列を返すた
め、結果をもう一度正規化する必要があるからです。 説明と例は Unicode 標
準の 3.13 節を参照してください。)


Unicode 正規表現
----------------

"re" モジュールがサポートしている正規表現はバイト列や文字列として与え
られます。 "\d" や "\w" などのいくつかの特殊な文字シーケンスは、そのパ
ターンがバイト列として与えられたのか文字列として与えられたのかによって
、異なる意味を持ちます。例えば、 "\d" はバイト列では "[0-9]" の範囲の
文字と一致しますが、文字列では "'Nd'" カテゴリーにある任意の文字と一致
します。

この例にある文字列には、タイ語の数字とアラビア数字の両方で数字の 57 が
書いてあります。

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

   s = "Over \u0e55\u0e57 57 flavours"
   m = p.search(s)
   print(repr(m.group()))

実行すると、 "\d+" はタイ語の数字と一致し、それを出力します。フラグ
"re.ASCII" を "compile()" に渡した場合、 "\d+" は先程とは違って部分文
字列 "57" に一致します。

同様に、"\w" は幅広い Unicode 文字に一致しますが、バイト列の場合や
"re.ASCII" を指定した場合には "[a-zA-Z0-9_]" だけに一致します。 "\s"
も同じ条件に応じて、Unicode の空白文字、または "[ \t\n\r\f\v]" に一致
します。


参考資料
--------

Python の Unicode サポートについての参考になる議論は以下の2つです:

* Nick Coghlan による Processing Text Files in Python 3

* Ned Batchelder による PyCon 2012 での発表 Pragmatic Unicode

"str" 型については Python ライブラリリファレンスの テキストシーケンス
型 --- str で解説されています。

"unicodedata" モジュールについてのドキュメント。

"codecs" モジュールについてのドキュメント。

Marc-André Lemburg は EuroPython 2002 で "Python and Unicode" というタ
イトルのプレゼンテーション (PDF スライド) を行いました。このスライドは
Python 2 の Unicode 機能 (Unicode 文字列型が "unicode" と呼ばれ、リテ
ラルは "u" で始まります) の設計について概観する素晴しい資料です。


Unicode データを読み書きする
============================

一旦 Unicode データに対してコードが動作するように書き終えたら、次の問
題は入出力です。プログラムは Unicode 文字列をどう受けとり、どう
Unicode を外部記憶装置や送受信装置に適した形式に変換するのでしょう?

入力元と出力先によっては、何もする必要がないかもしれません。 アプリケ
ーションで使っているライブラリが Unicode をそのまま扱えるか確認してく
ださい。 例えば、XML パーサーは多くの場合 Unicode データを返します。
多くのリレーショナルデータベースも Unicode 値の列をサポートし、SQL の
問い合わせに Unicode 値を返せます。

Unicode データは通常、ディスクに書いたりソケット経由で送ったりする前に
、特定のエンコーディングに変換されます。 すべてを自分で処理することも
できます。 ファイルを開き、8 ビットのバイトからなるオブジェクトを読み
取り、"bytes.decode(encoding)" でバイト列を変換します。 ただし、このよ
うに手動で処理する方法は推奨しません。

1つの問題はエンコーディングがマルチバイトに渡るという性質です; 1つの
Unicode 文字はいくつかのバイトで表現され得ます。任意のサイズのチャンク
(例えば、1024 もしくは 4096 バイト) にファイルの内容を読み込みたい場合
、ある1つの Unicode 文字をエンコードしたバイト列の一部だけがチャンクの
末尾まで読み込まれたケースに対応する、エラー処理コードを書く必要があり
ます。1つの解決策はファイル全体をメモリに読み込み、デコード処理を実行
することですが、こうしてしまうと非常に大きなファイルを処理するときの妨
げになります; 2 GiB のファイルを読み込む必要がある場合、2 GiB の RAM
が必要になります。(実際には、少なくともある瞬間では、エンコードされた
文字列と Unicode 文字列の両方をメモリに保持する必要があるため、より多
くのメモリが必要です。)

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 "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
"read()" and "write()".  This works through "open()"'s *encoding* and
*errors* parameters which are interpreted just like those in
"str.encode()" and "bytes.decode()".

そのためファイルから Unicode を読むのは単純です:

   with open('unicode.txt', encoding='utf-8') as f:
       for line in f:
           print(repr(line))

読み書きの両方ができる update モードでファイルを開くことも可能です:

   with open('test', encoding='utf-8', mode='w+') as f:
       f.write('\u4500 blah blah blah\n')
       f.seek(0)
       print(repr(f.readline()[:1]))

Unicode 文字 "U+FEFF" は byte-order mark (BOM) として使われ、ファイル
のバイト順の自動判定を支援するために、ファイルの最初の文字として書かれ
ます。UTF-16 のようないくつかのエンコーディングは、ファイルの先頭に
BOM があることを要求します; そのようなエンコーディングが使われるとき、
自動的に BOM が最初の文字として書かれ、ファイルを読むときに暗黙の内に
取り除かれます。これらのエンコーディングには、リトルエンディアン
(little-endian) 用の 'utf-16-le' やビッグエンディアン (big-endian) 用
の 'utf-16-be' というような変種があり、これらは特定の1つのバイト順を指
定していて BOM をスキップしません。

UTF-8 でエンコードされたファイルの先頭にも「BOM」を付ける慣習がある分
野があります。 UTF-8 はバイト順に依存しないため、この名前は紛らわしい
ものです。 このマークは、ファイルが UTF-8 でエンコードされていることを
示すだけです。 このようなファイルを読むときは、'utf-8-sig' コーデック
を使えば、マークがあった場合に自動的に読み飛ばせます。


Unicode ファイル名
------------------

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 *filesystem encoding*. if you've set the "LANG"
or "LC_CTYPE" environment variables; if you haven't, the default
encoding is again UTF-8.

"sys.getfilesystemencoding()" 関数は現在のシステムで利用するエンコーデ
ィングを返し、エンコーディングを手動で設定したい場合利用します、ただし
わざわざそうする積極的な理由はありません。読み書きのためにファイルを開
く時には、ファイル名を Unicode 文字列として渡すだけで正しいエンコーデ
ィングに自動的に変更されます:

   filename = 'filename\u4500abc'
   with open(filename, 'w') as f:
       f.write('blah\n')

"os.stat()" のような "os" モジュールの関数も Unicode のファイル名を受
け付けます。

"os.listdir()" 関数はファイル名を返しますが、ここで問題になるのは、フ
ァイル名を Unicode で返すべきか、エンコードしたバイト列で返すべきかと
いうことです。 "os.listdir()" は、ディレクトリのパスをバイト列と
Unicode 文字列のどちらで渡すかに応じて、両方に対応します。 パスを
Unicode 文字列で渡すと、ファイル名をファイルシステムのエンコーディング
でデコードし、Unicode 文字列のリストを返します。 バイト列でパスを渡す
と、ファイル名もバイト列で返します。 例えば、デフォルトの *ファイルシ
ステムエンコーディング* が UTF-8 の場合、次のプログラムを実行すると、

   fn = 'filename\u4500abc'
   f = open(fn, 'w')
   f.close()

   import os
   print(os.listdir(b'.'))
   print(os.listdir('.'))

以下の出力結果が生成されます:

   $ python listdir-test.py
   [b'filename\xe4\x94\x80abc', ...]
   ['filename\u4500abc', ...]

最初のリストは UTF-8 でエンコーディングされたファイル名を含み、第二の
リストは Unicode 版を含んでいます。

ほとんどの場合、これらの API では Unicode を使えば十分です。 バイト列
の API は、デコードできないファイル名が存在し得るシステムでのみ使うべ
きです。 現在では、ほぼ Unix システムに限られます。


Unicode 対応のプログラムを書くための Tips
-----------------------------------------

この章では Unicode を扱うプログラムを書くためのいくつかの提案を紹介し
ます。

最も重要な助言としては:

   ソフトウェアは内部では Unicode 文字列のみを利用し、入力データはでき
   るだけ早期にデコードし、出力の直前でエンコードすべきです。

Unicode 文字列とバイト列の両方を受け付ける処理関数を書こうとすると、こ
の二種類を組み合わせるあらゆる箇所でバグが生じやすくなります。 自動的
なエンコードやデコードは行われません。 例えば "str + bytes" を行うと
"TypeError" が送出されます。

web ブラウザから来るデータやその他の信頼できないところからのデータを利
用する場合、それらの文字列から生成したコマンド行の実行や、それらの文字
列をデータベースに蓄える前に文字列の中に不正な文字が含まれていないか確
認するのが一般的です。もしそういう状況になった場合には、エンコードされ
たバイトデータではなく、デコードされた文字列のチェックを入念に行なって
下さい; いくつかのエンコーディングは問題となる性質を持っています、例え
ば全単射でなかったり、完全に ASCII 互換でないなど。入力データがエンコ
ーディングを指定している場合でもそうして下さい、なぜなら攻撃者は巧みに
悪意あるテキストをエンコードした文字列の中に隠すことができるからです。


ファイルエンコーディングの変換
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

"StreamRecoder" クラスは、エンコーディング間の変換を透過的に行えます。
エンコーディング #1 でデータを返すストリームを受け取り、エンコーディン
グ #2 でデータを返すストリームとして動作します。

例えば、Latin-1 の入力ファイル "f" を "StreamRecoder" でラップすると、
UTF-8 でエンコードされたバイト列を返すようにできます。

   new_f = codecs.StreamRecoder(f,
       # エンコーダー/デコーダー: read() の結果のエンコードと
       # write() の入力のデコードに使う。
       codecs.getencoder('utf-8'), codecs.getdecoder('utf-8'),

       # リーダー/ライター: ストリームの読み書きに使う。
       codecs.getreader('latin-1'), codecs.getwriter('latin-1') )


不明なエンコーディングのファイル
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

ファイルを変更したいのに、そのエンコーディングが分からない場合はどうす
ればよいでしょうか。 ASCII 互換のエンコーディングだと分かっていて、
ASCII の部分だけを調べたり変更したりしたい場合は、"surrogateescape" エ
ラーハンドラーを指定してファイルを開けます。

   with open(fname, 'r', encoding="ascii", errors="surrogateescape") as f:
       data = f.read()

   # 文字列 'data' を変更する

   with open(fname + '.new', 'w',
             encoding="ascii", errors="surrogateescape") as f:
       f.write(data)

"surrogateescape" エラーハンドラーは、ASCII 以外のバイトを U+DC80 から
U+DCFF までの特別な範囲のコードポイントにデコードします。
"surrogateescape" エラーハンドラーを使ってデータをエンコードし、書き戻
すと、これらのコードポイントは元と同じバイトに戻ります。


参考資料
--------

David Beazley による PyCon 2010 の講演 Mastering Python 3 Input/Output
では、テキスト処理とバイナリデータの扱いを説明する節があります。

Marc-André Lemburg の講演 "Writing Unicode-aware Applications in
Python" の PDF スライド は、文字エンコーディングの問題に加え、アプリケ
ーションの国際化とローカライズの方法を説明しています。 このスライドは
Python 2.x だけを対象にしています。

The Guts of Unicode in Python は、Python 3.3 の Unicode の内部表現を解
説する、Benjamin Peterson による PyCon 2013 の講演です。


謝辞
====

このドキュメントの最初の草稿は Andrew Kuchling によって書かれました。
それからさらに Alexander Belopolsky, Georg Brandl, Andrew Kuchling,
Ezio Melotti らで改訂が重ねられています。

この記事中の誤りの指摘や提案を申し出てくれた以下の人々に感謝します:
É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.
