5. 組み込み型
*************

以下のセクションでは、インタプリタに組み込まれている標準型について記述
します。

注釈: これまでの (リリース 2.2 までの) Python の歴史では、組み込み型
  はオブ ジェクト指向における継承を行う際に雛型にできないという点で、
  ユーザ定 義型とは異なっていました。いまではこのような制限はなくなっ
  ています。

主要な組み込み型は数値型、シーケンス型、マッピング型、ファイル、クラス
、インスタンス型、および例外です。

演算によっては、複数の型でサポートされているものがあります; 特に、ほぼ
全てのオブジェクトについて、比較、真理値テスト、 (repr() 関数や、わず
かに異なる "str()" 関数による) 文字列への変換を行うことができます。オ
ブジェクトが "print()" 関数で印字されるとき、文字列に変換する関数が暗
黙に使われます。


5.1. 真理値判定
===============

どのオブジェクトも真理値を判定でき、 "if" や "while" 条件に、または以
下のブール演算の被演算子に使えます。以下の値は偽と見なされます:

* "None"

* "False"

* 数値型におけるゼロ。例えば "0", "0L", "0.0", "0j" 。

* 空のシーケンス。例えば "''", "()", "[]" 。

* 空のマッピング。例えば "{}" 。

* ユーザ定義クラスのインスタンスで、そのクラスが "__nonzero__()" ま
  た は "__len__()" メソッドを定義していれば、それらのメソッドが整数 0
  ま たは "bool" 値 "False" を返すとき。 [1]

それ以外の全ての値は真と見なされます --- 従って、多くの型のオブジェク
トは常に真です。

ブール値の結果を返す演算および組み込み関数は、特に注釈のない限り常に偽
値として "0" または "False" を返し、真値として "1" または "True" を返
します。 (重要な例外: ブール演算 "or" および "and" は常に被演算子のう
ちの一つを返します。)


5.2. ブール演算 --- "and", "or", "not"
======================================

以下にブール演算を、優先順位が低い順に示します:

+---------------+-----------------------------------+---------+
| 演算          | 結果                              | 注釈    |
+===============+===================================+=========+
| "x or y"      | *x* が偽なら *y*, そうでなければ  | (1)     |
|               | *x*                               |         |
+---------------+-----------------------------------+---------+
| "x and y"     | *x* が偽なら *x*, そうでなければ  | (2)     |
|               | *y*                               |         |
+---------------+-----------------------------------+---------+
| "not x"       | *x* が偽なら "True", そうでなけれ | (3)     |
|               | ば "False"                        |         |
+---------------+-----------------------------------+---------+

注釈:

1. この演算子は短絡評価されます。つまり第一引数が偽のときにのみ、第
   二 引数が評価されます。

2. この演算子は短絡評価されます。つまり第一引数が真のときにのみ、第
   二 引数が評価されます。

3. "not" は非ブール演算子よりも優先度が低いので、 "not a == b" は
   "not (a == b)" と解釈され、 "a == not b" は構文エラーです。


5.3. 比較
=========

比較演算は全てのオブジェクトでサポートされています。比較演算子は全て同
じ演算優先度を持っています (ブール演算より高い演算優先度です)。比較は
任意の形で連鎖させることができます; 例えば、 "x < y <= z" は "x < y
and y <= z" と等価で、違うのは *y* が一度だけしか評価されないというこ
とです (どちらの場合でも、 "x < y" が偽となった場合には *z* は評価され
ません)。

以下の表に比較演算をまとめます:

+--------------+---------------------------+---------+
| 演算         | 意味                      | 注釈    |
+==============+===========================+=========+
| "<"          | より小さい                |         |
+--------------+---------------------------+---------+
| "<="         | 以下                      |         |
+--------------+---------------------------+---------+
| ">"          | より大きい                |         |
+--------------+---------------------------+---------+
| ">="         | 以上                      |         |
+--------------+---------------------------+---------+
| "=="         | 等しい                    |         |
+--------------+---------------------------+---------+
| "!="         | 等しくない                | (1)     |
+--------------+---------------------------+---------+
| "is"         | 同一のオブジェクトである  |         |
+--------------+---------------------------+---------+
| "is not"     | 同一のオブジェクトでない  |         |
+--------------+---------------------------+---------+

注釈:

1. "!=" は "<>" とも書けますがこれは時代遅れの書き方で、後方互換性
   維持 のためだけに残されています。新しいコードでは常に "!=" を使うべ
   きで す。

数値型間の比較か文字列間の比較でないかぎり、異なる型のオブジェクトを比
較しても等価になることはありません; これらのオブジェクトの順番付けは一
貫してはいますが任意のものです (従って要素の型が一様でないシーケンスを
ソートした結果は一貫したものになります)。さらに、 (例えばファイルオブ
ジェクトのように) 型によっては、その型の 2 つのオブジェクトの不等性だ
けの、縮退した比較の概念しかサポートしないものもあります。繰り返します
が、そのようなオブジェクトも任意の順番付けをされていますが、それは一貫
したものです。被演算子が複素数の場合、演算子 "<", "<=", ">" および
">=" は例外 "TypeError" を送出します。

あるクラスの同一でないインスタンスは、通常等価でないとされますが、その
クラスが "__eq__()" メソッドか "__cmp__()" メソッドを定義している場合
は除きます。

クラスのインスタンスは、そのクラスが十分なだけの拡張比較メソッド
("__lt__()", "__le__()", "__gt__()", "__ge__()") または "__cmp__()" メ
ソッドを定義していない限り、同じクラスの別のインスタンスや他の型のオブ
ジェクトとは順序付けできません。

数値型を除き、異なる型のオブジェクトは型の名前で順番付けされます; 適当
な比較をサポートしていないある型のオブジェクトはアドレスによって順番付
けされます。

同じ優先度を持つ演算子としてさらに 2 つ、シーケンス型でのみ "in" およ
び "not in" がサポートされています (以下を参照)。


5.4. 数値型 "int", "float", "long", "complex"
=============================================

4 つの異なる数値型があります: *通常の整数型*, *長整数型*, *浮動小数点
型*, *複素数型* です。さらに、真偽値(Boolean)型も通常の整数型のサブタ
イプです。通常の整数 (単に *整数型* とも呼ばれます) は C言語の "long"
型を使って実装されており、少なくとも 32 ビットの精度があります
("sys.maxint" は常に通常の整数の各プラットフォームにおける最大値にセッ
トされており、最小値は "-sys.maxint - 1" になります)。長整数型には精度
の制限がありません。浮動小数点型はたいていは C の "double" を使って実
装されています; あなたのプログラムが動作するマシンでの浮動小数点型の精
度と内部表現は、 "sys.float_info" から利用できます。複素数型は実部と虚
部を持ち、それぞれ浮動小数点数です。複素数 *z* から実部および虚部を取
り出すには、 "z.real" および "z.imag" を使ってください。 (標準ライブラ
リには、追加の数値型、分数を保持する "fractions" や、ユーザ定義の精度
の浮動小数点数を保持する "decimal" があります。)

数値は、数値リテラルや組み込み関数や演算子の戻り値として生成されます。
修飾のない整数リテラル ( 2 進表現や、 16 進表現や 8 進表現の値も含みま
す) は、通常の整数値を表します。 値が通常の整数で表すには大きすぎる場
合、 "'L'" または "'l'" が末尾につく整数リテラルは長整数型を表します
("'L'" が望ましいです。というのは "1l" は 11 と非常に紛らわしいからで
す!)。 小数点または指数表記のある数値リテラルは浮動小数点数を表します
。 数値リテラルに "'j'" または "'J'" をつけると虚数 (実数部がゼロの複
素数) を表し、それと整数や浮動小数点数を足すと実部と虚部を持つ複素数が
得られます。

Python は型混合の演算を完全にサポートします: ある 2 項演算子が互いに異
なる数値型の被演算子を持つ場合、より "制限された" 型の被演算子は他方の
型に合わせて広げられます。ここで通常の整数は長整数より制限されており、
長整数は浮動小数点数より制限されており、浮動小数点は複素数より制限され
ています。型混合の数値間での比較も同じ規則に従います。 [2] コンストラ
クタ "int()", "long()", "float()", および "complex()" を使って、特定の
型の数を生成することができます。

全ての組み込み数値型は以下の演算をサポートします。演算子の優先度につい
ては、 べき乗演算 (power operator),および、あとのセクションを参照下さ
い。

+----------------------+-----------------------------------+----------+
| 演算                 | 結果                              | 注釈     |
+======================+===================================+==========+
| "x + y"              | *x* と *y* の和                   |          |
+----------------------+-----------------------------------+----------+
| "x - y"              | *x* と *y* の差                   |          |
+----------------------+-----------------------------------+----------+
| "x * y"              | *x* と *y* の積                   |          |
+----------------------+-----------------------------------+----------+
| "x / y"              | *x* と *y* の商                   | (1)      |
+----------------------+-----------------------------------+----------+
| "x // y"             | *x* と *y* の商 (を切り下げたもの | (4)(5)   |
|                      | )                                 |          |
+----------------------+-----------------------------------+----------+
| "x % y"              | "x / y" の剰余                    | (4)      |
+----------------------+-----------------------------------+----------+
| "-x"                 | *x* の符号反転                    |          |
+----------------------+-----------------------------------+----------+
| "+x"                 | *x* そのまま                      |          |
+----------------------+-----------------------------------+----------+
| "abs(x)"             | *x* の絶対値または大きさ          | (3)      |
+----------------------+-----------------------------------+----------+
| "int(x)"             | *x* の整数への変換                | (2)      |
+----------------------+-----------------------------------+----------+
| "long(x)"            | *x* の長整数への変換              | (2)      |
+----------------------+-----------------------------------+----------+
| "float(x)"           | *x* の浮動小数点数への変換        | (6)      |
+----------------------+-----------------------------------+----------+
| "complex(re,im)"     | 実部 *re*, 虚部 *im* の複素数。   |          |
|                      | *im* の既定値はゼロ。             |          |
+----------------------+-----------------------------------+----------+
| "c.conjugate()"      | 複素数 *c* の共役複素数 (実数に対 |          |
|                      | しては同じ値を返す)               |          |
+----------------------+-----------------------------------+----------+
| "divmod(x, y)"       | "(x // y, x % y)" からなるペア    | (3)(4)   |
+----------------------+-----------------------------------+----------+
| "pow(x, y)"          | *x* の *y* 乗                     | (3)(7)   |
+----------------------+-----------------------------------+----------+
| "x ** y"             | *x* の *y* 乗                     | (7)      |
+----------------------+-----------------------------------+----------+

注釈:

1. (通常および長) 整数の割り算では、結果は整数になります。この場合
   値は 常にマイナス無限大の方向に丸められます: つまり、1/2 は 0、
   (-1)/2 は -1、1/(-1) は -1、そして (-1)/(-2) は 0 になります。被演
   算子の両 方が長整数の場合、計算値に関わらず結果は長整数で返されるの
   で注意し てください。

2. 浮動小数点数から "int()",または、 "long()" を使った変換では、関
   連す る関数、 "math.trunc()" のようにゼロ方向へ丸められます。下方向
   への 丸めには "math.floor()" を使い、上方向への丸めには
   "math.ceil()" を 使って下さい。

3. 完全な記述については、 組み込み関数,を参照してください。

4. バージョン 2.3 で非推奨: 切り捨て除算演算子、モジュロ演算子、お
   よび "divmod()" 関数は、複素数に対してはもはや定義されていません。
   目的に 合うならば、代わりに "abs()" を使って浮動小数点に変換してく
   ださい。

5. 整数の除算とも呼ばれます。結果の型は整数型とは限りませんが、結果
   の 値は整数です。

6. 浮動小数点数は、文字列 "nan" と "inf" を、必要なら接頭辞 "+" ま
   たは "-" と共に、非数 (Not a Number (NaN)) や正、負の無限大として受
   け付 けます。

   バージョン 2.6 で追加.

7. Python は、プログラム言語一般でそうであるように、 "pow(0, 0)" お
   よ び "0 ** 0" を "1" と定義します。

全ての "numbers.Real" 型 ("int", "long",および、 "float") は以下の演算
を含みます。 :

+----------------------+-----------------------------------------------+
| 演算                 | 結果                                          |
+======================+===============================================+
| "math.trunc(x)"      | *x* を "Integral" (整数) に切り捨てます       |
+----------------------+-----------------------------------------------+
| "round(x[, n])"      | *x* を *n* 桁に丸めます。丸め方は四捨五入です |
|                      | 。 *n* が省略されれば 0 がデフォルトとなりま  |
|                      | す。(--訳注: Python 3 と仕様が違うので注意し  |
|                      | てくだ さい。1.5 と 2.5 の round は、Python 2 |
|                      | ではそれぞれ 2、3 となり、 Python 3 では 2、2 |
|                      | となります。後者の丸めは .5 を丸める際に偶数  |
|                      | になる 方へ丸めるので、「偶数丸め」と言います |
|                      | 。--)                                         |
+----------------------+-----------------------------------------------+
| "math.floor(x)"      | *x* 以下の最大の整数を浮動小数点数として返し  |
|                      | ます                                          |
+----------------------+-----------------------------------------------+
| "math.ceil(x)"       | *x* 以上の最小の整数を浮動小数点数として返し  |
|                      | ます                                          |
+----------------------+-----------------------------------------------+


5.4.1. 整数型におけるビット単位演算
-----------------------------------

ビット単位演算は、整数に対してのみ意味があります。負の数は、その 2 の
補数の値として扱われます (演算中にオーバフローが起こらないように十分な
ビット数があるものと仮定します) 。

二項ビット単位演算の優先順位は全て、数値演算よりも低く、比較よりも高い
です; 単項演算 "~" の優先順位は他の単項数値演算 ("+" および "-") と同
じです。

以下の表では、ビット単位演算を優先順位が低い順に並べています:

+--------------+----------------------------------+------------+
| 演算         | 結果                             | 注釈       |
+==============+==================================+============+
| "x | y"      | *x* と *y* のビット単位 *論理和* |            |
+--------------+----------------------------------+------------+
| "x ^ y"      | *x* と *y* のビット単位 *排他的  |            |
|              | 論理和*                          |            |
+--------------+----------------------------------+------------+
| "x & y"      | *x* と *y* のビット単位 *論理積* |            |
+--------------+----------------------------------+------------+
| "x << n"     | *x* の *n* ビット左シフト        | (1)(2)     |
+--------------+----------------------------------+------------+
| "x >> n"     | *x* の *n* ビット右シフト        | (1)(3)     |
+--------------+----------------------------------+------------+
| "~x"         | *x* のビット反転                 |            |
+--------------+----------------------------------+------------+

注釈:

1. 負値のシフト数は不正であり、 "ValueError" が送出されます。

2. *n* ビットの左シフトは、 "pow(2, n)" による乗算と等価です。通常
   整数 の範囲を超える結果になる場合は長整数で返されます。

3. *n* ビットの右シフトは、 "pow(2, n)" による除算と等価です。


5.4.2. 整数型における追加のメソッド
-----------------------------------

整数型は "numbers.Integral" *abstract base class* を実装します。さらに
、追加のメソッドを一つ提供します。

int.bit_length()

long.bit_length()

   整数を、符号と先頭の 0 は除いて二進法で表すために必要なビットの数を
   返します:

      >>> n = -37
      >>> bin(n)
      '-0b100101'
      >>> n.bit_length()
      6

   正確には、 "x" が非 0 なら、 "x.bit_length()" は "2**(k-1) <=
   abs(x) < 2**k" を満たす唯一の正の整数 "k" です。同様に、 "abs(x)"
   が十分小さくて対数を適切に丸められるとき、 "k = 1 + int(log(abs(x),
   2))" です。 "x" が 0 なら、 "x.bit_length()" は "0" を返します。

   次と等価です:

      def bit_length(self):
          s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
          s = s.lstrip('-0b') # remove leading zeros and minus sign
          return len(s)       # len('100101') --> 6

   バージョン 2.7 で追加.


5.4.3. 浮動小数点数に対する追加のメソッド
-----------------------------------------

浮動小数点数型は、 "numbers.Real" 抽象基底クラス (*abstract base
class*) を実装しています。浮動小数点型はまた、以下の追加のメソッドを持
ちます。

float.as_integer_ratio()

   比が元の浮動小数点数とちょうど同じで分母が正である、一対の整数を返
   します。無限大に対しては "OverflowError" を、非数 (NaN) に対しては
   "ValueError" を送出します。

   バージョン 2.6 で追加.

float.is_integer()

   浮動小数点数インスタンスが有限の整数値なら "True" を、そうでなけれ
   ば "False" を返します:

      >>> (-2.0).is_integer()
      True
      >>> (3.2).is_integer()
      False

   バージョン 2.6 で追加.

16 進表記の文字列へ、または、 16 進表記からの変換をサポートする二つの
メソッドがあります。 Python の浮動小数点数は内部的には2進数で保持され
るので、浮動小数点数の *10進数* へまたは *10進数* から変換には若干の丸
め誤差があります。それに対し、16 進表記では、浮動小数点数を正確に表現
できます。これはデバッグのときや、数学的な用途 (numerical work) に便利
でしょう。

float.hex()

   浮動小数点数の 16 進文字列表現を返します。有限の浮動小数点数に対し
   、この表現は常に "0x" で始まり "p" と指数が続きます。

   バージョン 2.6 で追加.

float.fromhex(s)

   16 進文字列表現 *s* で表される、浮動小数点数を返すクラスメソッドで
   す。文字列 *s* は、前や後にホワイトスペースを含んでいても構いません
   。

   バージョン 2.6 で追加.

"float.fromhex()" はクラスメソッドですが、 "float.hex()" はインスタン
スメソッドであることに注意して下さい。

16 進文字列表現は以下の書式となります:

   [sign] ['0x'] integer ['.' fraction] ['p' exponent]

"sign" は必須ではなく、 "+" と "-" のどちらかです。 "integer" と
"fraction" は 16 進数の文字列で、 "exponent" は 10 進数で符号もつけら
れます。大文字・小文字は区別されず、最低でも 1 つの 16 進数文字を整数
部もしくは小数部に含む必要があります。この制限は C99 規格のセクション
6.4.4.2 で規定されていて、 Java 1.5 以降でも使われています。特に、
"float.hex()" の出力は C や Java コード中で、浮動小数点数の 16 進表記
として役に立つでしょう。また、 C の "%a" 書式や、 Java の
"Double.toHexString" で書きだされた文字列は "float.fromhex()" で受け付
けられます。

なお、指数部は 16 進数ではなく 10 進数で書かれ、係数に掛けられる 2 の
累乗を与えます。例えば、16 進文字列 "0x3.a7p10" は浮動小数点数 "(3 +
10./16 + 7./16**2) * 2.0**10" すなわち "3740.0" を表します:

   >>> float.fromhex('0x3.a7p10')
   3740.0

逆変換を "3740.0" に適用すると、同じ数を表す異なる 16 進文字列表現を返
します:

   >>> float.hex(3740.0)
   '0x1.d380000000000p+11'


5.5. イテレータ型
=================

バージョン 2.2 で追加.

Python はコンテナでの反復処理の概念をサポートしています。この概念は 2
つの別々のメソッドを使って実装されています; これらのメソッドを使ってユ
ーザ定義のクラスで反復を行えるようにできます。後に詳しく述べるシーケン
スは、必ず反復処理メソッドをサポートしています。

コンテナオブジェクトに反復処理をサポートさせるためには、以下のメソッド
を定義しなければなりません:

container.__iter__()

   イテレータオブジェクトを返します。オブジェクトは後述するイテレータ
   プロトコルをサポートする必要があります。もしコンテナが異なる型の反
   復処理をサポートするなら、それらの反復処理毎に追加のメソッドを提供
   しても構いません (複数の形式の反復処理を提供するオブジェクトの例と
   して、幅優先探索と深さ優先探索をサポートする木構造が挙げられます)。
   このメソッドは Python/C API での Python オブジェクトの型構造体の
   "tp_iter" スロットに対応します。

イテレータオブジェクト自体は以下の 2 のメソッドをサポートする必要があ
ります。これらのメソッドは 2 つ合わせて *イテレータプロトコル* を成し
ます:

iterator.__iter__()

   イテレータオブジェクト自体を返します。このメソッドはコンテナとイテ
   レータの両方を "for" および "in" 文で使えるように するために必要で
   す。このメソッドは Python/C API において Python オ ブジェクトを表す
   型構造体の "tp_iter" スロットに対応します。

iterator.next()

   コンテナの次のアイテムを返します。もしそれ以上アイテム無ければ
   "StopIteration" 例外を送出します。 このメソッドは Python/C APIでの
   Pythonオブジェクトの型構造体の "tp_iternext" スロットに対応します。

Python では、いくつかのイテレータオブジェクトを定義しています。これら
は一般のおよび特殊なシーケンス型、辞書型、そして他のさらに特殊化された
形式に渡る反復をサポートします。特殊型は、イテレータプロトコルの実装以
外は重要ではありません。

このプロトコルでは、イテレータの "next()" メソッドが一旦
"StopIteration" を送出したなら、以降の呼び出しでも例外を送出し続けるこ
とを期待します。この特性に従わない実装は壊れているとみなされます。(こ
の制約は Python 2.3 で追加されました。Python 2.2 では色々なイテレータ
が、このルールによれば壊れています。)


5.5.1. ジェネレータ型
---------------------

Python における *generator* (ジェネレータ) は、イテレータプロトコルを
実装する便利な方法を提供します。コンテナオブジェクトの "__iter__()" メ
ソッドがジェネレータとして実装されていれば、そのメソッドは
"__iter__()" および "next()" メソッドを提供するイテレータオブジェクト
(厳密にはジェネレータオブジェクト) を自動的に返します。ジェネレータに
関する詳細な情報は、 yield 式のドキュメント にあります。


5.6. シーケンス型 --- "str", "unicode", "list", "tuple", "bytearray", "buffer", "xrange"
========================================================================================

シーケンス型には 7 つあります: 文字列、Unicode 文字列、リスト、タプル
、、バイト配列 (bytearray)、バッファ、そして xrange オブジェクトです。

他のコンテナ型については、組み込みクラスの "dict" および "set" を参照
下さい。

文字列リテラルは "'xyzzy'" , ""frobozz"" といったように、単引用符また
は二重引用符の中に書かれます。文字列リテラルについての詳細は、 文字列
リテラル を参照下さい。 Unicode 文字列はほとんど文字列と同じですが、
"u'abc'" , "u"def"" といったように先頭に文字 "'u'" を付けて指定します
。リストは "[a, b, c]" のように要素をコンマで区切り角括弧で囲って生成
します。タプルは "a, b, c" のようにコンマ演算子で区切って生成します (
角括弧の中には入れません)。丸括弧で囲っても囲わなくてもかまいませんが
、空のタプルは "()" のように丸括弧で囲わなければなりません。要素が一つ
のタプルでは、例えば "(d,)" のように、要素の後ろにコンマをつけなければ
なりません。

バイト配列は、組み込み関数 "bytearray()" で構成されます。

バッファオブジェクトは Python の構文上では直接サポートされていませんが
、組み込み関数 "buffer()" で生成することができます。バッファオブジェク
トは結合や反復をサポートしていません。

xrange オブジェクトは、オブジェクトを生成するための特殊な構文がない点
でバッファに似ていて、関数 "xrange()" で生成します。 xrange オブジェク
トはスライス、結合、反復をサポートせず、 "in" , "not in" , "min()" ま
たは "max()" は効率的ではありません。

ほとんどのシーケンス型は以下の演算操作をサポートします。 "in" および
"not in" は比較演算とおなじ優先度を持っています。 "+" および "*" は対
応する数値演算とおなじ優先度です。 [3] ミュータブルなシーケンス型 で追
加のメソッドが提供されています。

以下のテーブルはシーケンス型の演算を優先度の低いものから順に挙げたもの
です。テーブル内の *s* および *t* は同じ型のシーケンスです; *n* , *i*
および *j* は整数です:

+--------------------+----------------------------------+------------+
| 演算               | 結果                             | 注釈       |
+====================+==================================+============+
| "x in s"           | *s* のある要素が *x* と等しけれ  | (1)        |
|                    | ば "True" , そうでなければ       |            |
|                    | "False"                          |            |
+--------------------+----------------------------------+------------+
| "x not in s"       | *s* のある要素が *x* と等しけれ  | (1)        |
|                    | ば "False", そうでなければ       |            |
|                    | "True"                           |            |
+--------------------+----------------------------------+------------+
| "s + t"            | *s* と *t* の結合                | (6)        |
+--------------------+----------------------------------+------------+
| "s * n" または "n  | *s* 自身を *n* 回足すのと同じ    | (2)        |
| * s"               |                                  |            |
+--------------------+----------------------------------+------------+
| "s[i]"             | *s* の 0 から数えて *i* 番目の要 | (3)        |
|                    | 素                               |            |
+--------------------+----------------------------------+------------+
| "s[i:j]"           | *s* の *i* から *j* までのスライ | (3)(4)     |
|                    | ス                               |            |
+--------------------+----------------------------------+------------+
| "s[i:j:k]"         | *s* の *i* から *j* まで、 *k*   | (3)(5)     |
|                    | 毎のスライス                     |            |
+--------------------+----------------------------------+------------+
| "len(s)"           | *s* の長さ                       |            |
+--------------------+----------------------------------+------------+
| "min(s)"           | *s* の最小の要素                 |            |
+--------------------+----------------------------------+------------+
| "max(s)"           | *s* の最大の要素                 |            |
+--------------------+----------------------------------+------------+
| "s.index(x)"       | *s* 中で *x* が最初に出現するイ  |            |
|                    | ンデックス                       |            |
+--------------------+----------------------------------+------------+
| "s.count(x)"       | *s* 中に *x* が出現する回数      |            |
+--------------------+----------------------------------+------------+

シーケンス型は比較演算子もサポートします。特にタプルとリストは相当する
要素による辞書編集方式的に比較されます。つまり、等しいということは、ふ
たつのシーケンスの長さ、型が同じであり、全ての要素が等しいということで
す (詳細は言語リファレンスの 比較 を参照下さい) 。

注釈:

1. *s* が文字列または Unicode 文字列の場合、演算操作 "in" および
   "not in" は部分文字列の一致テストと同じように動作します。バージョン
   2.3 以前の Python では、 *x* は長さ 1 の文字列である必要がありまし
   た。 Python 2.3 以降では、 *x* はどんな長さでも構いません。

2. *n* が "0" 以下の値の場合、 "0" として扱われます (これは *s* と
   同じ 型の空のシーケンスを表します)。シーケンス *s* の要素はコピーさ
   れな いので注意してください; コピーではなく要素に対する参照カウント
   が増 えます。これは Python に慣れていないプログラマをよく悩ませます
   。例 えば以下のコードを考えます:

   >>> lists = [[]] * 3
   >>> lists
   [[], [], []]
   >>> lists[0].append(3)
   >>> lists
   [[3], [3], [3]]

   ここで、"[[]]" が空リストを含む 1 要素のリストなので、"[[]] * 3" の
   3 要素はこの一つの空リストへの参照です。"lists" のいずれかの要素を
   変更すると、その一つのリストが変更されます。別々のリストのリストを
   作るにはこうします:

   >>> lists = [[] for i in range(3)]
   >>> lists[0].append(3)
   >>> lists[1].append(5)
   >>> lists[2].append(7)
   >>> lists
   [[3], [5], [7]]

   別の説明が FAQ エントリ 多次元のリストを作るにはどうしますか？ にあ
   ります。

3. *i* または *j* が負の数の場合、インデクスはシーケンスの末端から
   の相 対インデクスになります: "len(s) + i" または "len(s) + j" が代
   わりに 使われます。 ただし "-0" はやはり "0" であることに注意してく
   ださい 。

4. *s* の *i* から *j* へのスライスは "i <= k < j" となるようなイン
   デ クス *k* を持つ要素からなるシーケンスとして定義されます。 *i* ま
   た は *j* が "len(s)" よりも大きい場合、 "len(s)" を使います。 *i*
   が 省略されるか "None" だった場合、 "0" を使います。 *j* が省略され
   る か "None" だった場合、 "len(s)" を使います。 *i* が *j* 以上の場
   合 、スライスは空のシーケンスになります。

5. *s* の「 *i* から *j* まででステップが *k* のスライス」は、イン
   デッ クス "x = i + n*k" （ただし n は "0 <= n < (j-i)/k" を満たす任
   意の 整数）を持つ要素からなるシーケンスとして定義されます。言い換え
   ると インデックスは "i", "i+k", "i+2*k", "i+3*k" と続き、 *j* に達
   したと ころでストップします (ただし *j* は含みません)。 *k* が正の
   数である 場合、 *i* または *j* が "len(s)" より大きければ "len(s)"
   を代わり に使用します。 *k* が負の数である場合、 *i* または *j* が
   "len(s) - 1" より大きければ "len(s) - 1" を代わりに使用します。 *i*
   または *j* を省略または "None" を指定すると、 "端" (どちらの端かは
   *k* の 符号に依存) の値を代わりに使用します。なお *k* はゼロにでき
   ないので 注意してください。また *k* に "None" を指定すると、 "1" が
   指定され たものとして扱われます。

6. *s* と *t* の両者が文字列であるとき、 CPython のようないくつかの
   Python 実装では、 "s = s + t" や "s += t" という書式で代入をするの
   に in-place optimization が働きます。このような時、最適化は二乗の実
   行時間の低減をもたらします。この最適化はバージョンや実装に依存しま
   す。実行効率が必要なコードでは、バージョンと実装が変わっても、連結
   の線形的実行効率を保証する "str.join()" を使うのがより望ましいでし
   ょう。

   バージョン 2.4 で変更: 以前、文字列の連結はin-placeで再帰されません
   でした.


5.6.1. 文字列メソッド
---------------------

8-bit 文字列と Unicode オブジェクトは、どちらも以下に挙げるメソッドに
対応しています。この中には、 "bytearray" オブジェクトで使えるものもあ
ります。

さらに、 Python の文字列は シーケンス型 --- str, unicode, list, tuple,
bytearray, buffer, xrange に記載されるシーケンス型のメソッドもサポート
します。書式指定して文字列を出力するためには、テンプレート文字列を使う
か、 文字列フォーマット操作 に記載される "%" 演算子を使います。正規表
現に基づく文字列操作関数については、 "re" モジュールを参照下さい。

str.capitalize()

   最初の文字を大文字にし、残りを小文字にした文字列のコピーを返します
   。

   8ビット文字列では、メソッドはロケール依存になります。

str.center(width[, fillchar])

   *width* の長さをもつ中央寄せされた文字列を返します。パディングには
   *fillchar* で指定された値 (デフォルトではスペース) が使われます。

   バージョン 2.4 で変更: 引数 *fillchar* に対応.

str.count(sub[, start[, end]])

   [*start*, *end*] の範囲に、部分文字列 *sub* が重複せず出現する回数
   を返します。オプション引数 *start* および *end* はスライス表記と同
   じように解釈されます。

str.decode([encoding[, errors]])

   codec に登録された文字コード系 *encoding* を使って文字列をデコード
   します。 *encoding* は標準でデフォルトの文字列エンコーディングにな
   ります。標準とは異なるエラー処理を行うために *errors* を与えること
   ができます。標準のエラー処理は "'strict'" で、エンコードに関するエ
   ラーは "UnicodeError" を送出します。他に利用できる値は "'ignore'",
   "'replace'" および関数 "codecs.register_error()" によって登録された
   名前です。これについてはセクション Codec 基底クラス 節を参照してく
   ださい。

   バージョン 2.2 で追加.

   バージョン 2.3 で変更: その他のエラーハンドリングスキーマがサポート
   されました.

   バージョン 2.7 で変更: キーワード引数のサポートが追加されました。

str.encode([encoding[, errors]])

   文字列のエンコードされたバージョンを返します。デフォルトのエンコー
   ディングは現在の文字列エンコーディングのデフォルトです。標準とは異
   なるエラー処理を行うために *errors* を与えることができます。標準の
   エラー処理は "'strict'" で、エンコードに関するエラーは
   "UnicodeError" を送出します。他に利用できる値は "'ignore'",
   "'replace'", "'xmlcharrefreplace'", "'backslashreplace'" および関数
   "codecs.register_error()" によって登録された名前です。これについて
   はセクション Codec 基底クラス を参照してください。利用可能なエンコ
   ーディングの一覧は、セクション 標準エンコーディング を参照してくだ
   さい。

   バージョン 2.0 で追加.

   バージョン 2.3 で変更: "'xmlcharrefreplace'", "'backslashreplace'"
   およびその他のエラーハンドリングスキーマがサポートされました.

   バージョン 2.7 で変更: キーワード引数のサポートが追加されました。

str.endswith(suffix[, start[, end]])

   文字列が指定された *suffix* で終わるなら "True" を、そうでなければ
   "False" を返します。 *suffix* は見つけたい複数の接尾語のタプルでも
   構いません。オプションの *start* があれば、その位置から判定を始めま
   す。オプションの *end* があれば、その位置で比較を止めます。

   バージョン 2.5 で変更: *suffix* でタプルを受け付けるようになりまし
   た.

str.expandtabs([tabsize])

   文字列内の全てのタブ文字が 1 つ以上のスペースで置換された、文字列の
   コピーを返します。スペースの数は現在の桁 (column) 位置と *tabsize*
   に依存します。タブ位置は *tabsize* 文字毎に存在します (デフォルト値
   である 8 の場合、タブ位置は 0, 8, 16 などになります)。文字列を展開
   するため、まず現桁位置がゼロにセットされ、文字列が 1 文字ずつ調べら
   れます。文字がタブ文字 ("\t") であれば、現桁位置が次のタブ位置と一
   致するまで、1 つ以上のスペースが結果の文字列に挿入されます。(タブ文
   字自体はコピーされません。) 文字が改行文字 ("\n" もしくは "\r") の
   場合、文字がコピーされ、現桁位置は 0 にリセットされます。その他の文
   字は変更されずにコピーされ、現桁位置は、その文字の表示のされ方 (訳
   注: 全角、半角など) に関係なく、1 ずつ増加します。

   >>> '01\t012\t0123\t01234'.expandtabs()
   '01      012     0123    01234'
   >>> '01\t012\t0123\t01234'.expandtabs(4)
   '01  012 0123    01234'

str.find(sub[, start[, end]])

   文字列のスライス "s[start:end]" に部分文字列 *sub* が含まれる場合、
   その最小のインデックスを返します。オプション引数 *start* および
   *end* はスライス表記と同様に解釈されます。 *sub* が見つからなかった
   場合 "-1" を返します。

   注釈: "find()" メソッドは、 *sub* の位置を知りたいときにのみ使う
     べきで す。 *sub* が部分文字列であるかどうかのみを調べるには、
     "in" 演算 子を使ってください:

        >>> 'Py' in 'Python'
        True

str.format(*args, **kwargs)

   文字列の書式化操作を行います。このメソッドを呼び出す文字列は通常の
   文字、または、 "{}" で区切られた置換フィールドを含みます。それぞれ
   の置換フィールドは位置引数のインデックスナンバー、または、キーワー
   ド引数の名前を含みます。返り値は、それぞれの置換フィールドが対応す
   る引数の文字列値で置換された文字列のコピーです。

   >>> "The sum of 1 + 2 is {0}".format(1+2)
   'The sum of 1 + 2 is 3'

   書式指定のオプションについては、書式指定文字列を規定する 書式指定文
   字列の文法 を参照下さい。

   この文字列書式指定のメソッドは Python 3 での新しい標準であり、新し
   いコードでは、 文字列フォーマット操作 で規定される "%" を使った書式
   指定より好ましい書き方です。

   バージョン 2.6 で追加.

str.index(sub[, start[, end]])

   "find()" と同様ですが、 *sub* が見つからなかった場合 "ValueError"
   を送出します。

str.isalnum()

   文字列中の全ての文字が英数文字で、かつ 1 文字以上ある場合には真を返
   し、そうでない場合は偽を返します。

   8ビット文字列では、メソッドはロケール依存になります。

str.isalpha()

   文字列中の全ての文字が英文字で、かつ 1 文字以上ある場合には真を返し
   、そうでない場合は偽を返します。

   8ビット文字列では、メソッドはロケール依存になります。

str.isdigit()

   文字列中に数字しかない場合には真を返し、その他の場合は偽を返します
   。

   8ビット文字列では、メソッドはロケール依存になります。

str.islower()

   文字列中の大小文字の区別のある文字 [4] 全てが小文字で、かつ大小文字
   の区別のある文字が 1 文字以上あるなら真を、そうでなければ偽を返しま
   す。

   8ビット文字列では、メソッドはロケール依存になります。

str.isspace()

   文字列が空白文字だけからなり、かつ 1 文字以上ある場合には真を返し、
   そうでない場合は偽を返します。

   8ビット文字列では、メソッドはロケール依存になります。

str.istitle()

   文字列がタイトルケース文字列であり、かつ 1 文字以上ある場合、例えば
   大文字は大小文字の区別のない文字の後にのみ続き、小文字は大小文字の
   区別のある文字の後ろにのみ続く場合には真を返します。そうでない場合
   は偽を返します。

   8ビット文字列では、メソッドはロケール依存になります。

str.isupper()

   文字列中の大小文字の区別のある文字 [4] 全てが大文字で、かつ大小文字
   の区別のある文字が 1 文字以上あるなら真を、そうでなければ偽を返しま
   す。

   8ビット文字列では、メソッドはロケール依存になります。

str.join(iterable)

   *イテラブル* 中の文字列を結合した文字列オブジェクトを返します。
   *iterable* に Unicode オブジェクトがある場合は、代わりに Unicode を
   返します。 文字列でないあるいは Unicode オブジェクトでない値が存在
   する場合は、 "TypeError" が送出されます。 要素間の区切り文字列は、
   このメソッドを提供する文字列です。

str.ljust(width[, fillchar])

   長さ *width* の左揃えした文字列を返します。パディングは指定された
   *fillchar* (デフォルトではスペース) を使って行われます。 *width* が
   "len(s)" 以下ならば、元の文字列が返されます。

   バージョン 2.4 で変更: 引数 *fillchar* に対応.

str.lower()

   全ての大小文字の区別のある文字 [4] が小文字に変換された、文字列のコ
   ピーを返します。

   8ビット文字列では、メソッドはロケール依存になります。

str.lstrip([chars])

   文字列の先頭の文字を除去したコピーを返します。引数 *chars* は除去さ
   れる文字の集合を指定する文字列です。 *chars* が省略されるか "None"
   の場合、空白文字が除去されます。 *chars* 文字列は接頭辞ではなく、そ
   の値に含まれる文字の組み合わせ全てがはぎ取られます。 :

   >>> '   spacious   '.lstrip()
   'spacious   '
   >>> 'www.example.com'.lstrip('cmowz.')
   'example.com'

   バージョン 2.2.2 で変更: 引数 *chars* をサポートしました.

str.partition(sep)

   文字列を *sep* の最初の出現位置で区切り、 3 要素のタプルを返します
   。タプルの内容は、区切りの前の部分、区切り文字列そのもの、そして区
   切りの後ろの部分です。もし区切れなければ、タプルには元の文字列その
   ものとその後ろに二つの空文字列が入ります。

   バージョン 2.5 で追加.

str.replace(old, new[, count])

   文字列をコピーし、現れる部分文字列 *old* 全てを *new* に置換して返
   します。オプション引数 *count* が与えられている場合、先頭から
   *count* 個の *old* だけを置換します。

str.rfind(sub[, start[, end]])

   文字列中の領域 "s[start:end]" に *sub* が含まれる場合、その最大のイ
   ンデクスを返します。オプション引数 *start* および *end* はスライス
   表記と同様に解釈されます。 *sub* が見つからなかった場合 "-1"  を返
   します。

str.rindex(sub[, start[, end]])

   "rfind()" と同様ですが、 *sub* が見つからなかった場合 "ValueError"
   を送出します。

str.rjust(width[, fillchar])

   *width* の長さをもつ右寄せした文字列を返します。パディングには
   *fillchar* で指定された文字(デフォルトではスペース)が使われます。
   *width* が "len(s)" 以下の場合、元の文字列が返されます。

   バージョン 2.4 で変更: 引数 *fillchar* に対応.

str.rpartition(sep)

   文字列を *sep* の最後の出現位置で区切り、 3 要素のタプルを返します
   。タプルの内容は、区切りの前の部分、区切り文字列そのもの、そして区
   切りの後ろの部分です。もし区切れなければ、タプルには二つの空文字列
   とその後ろに元の文字列そのものが入ります。

   バージョン 2.5 で追加.

str.rsplit([sep[, maxsplit]])

   *sep* を区切り文字とした、文字列中の単語のリストを返します。
   *maxsplit* が与えられた場合、文字列の *右端* から最大 *maxsplit* 回
   分割を行います。*sep* が指定されていない、あるいは "None" のとき、
   全ての空白文字が区切り文字となります。右から分割していくことを除け
   ば、 "rsplit()" は後ほど詳しく述べる "split()" と同様に振る舞います
   。

   バージョン 2.4 で追加.

str.rstrip([chars])

   文字列の末尾部分を除去したコピーを返します。引数 *chars* は除去され
   る文字集合を指定する文字列です。 *chars* が省略されるか "None" の場
   合、空白文字が除去されます。 *chars* 文字列は接尾語ではなく、そこに
   含まれる文字の組み合わせ全てがはぎ取られます:

   >>> '   spacious   '.rstrip()
   '   spacious'
   >>> 'mississippi'.rstrip('ipz')
   'mississ'

   バージョン 2.2.2 で変更: 引数 *chars* をサポートしました.

str.split([sep[, maxsplit]])

   文字列を *sep* をデリミタ文字列として区切った単語のリストを返します
   。*maxsplit* が与えられていれば、最大で *maxsplit* 回分割されます (
   つまり、リストは最大 "maxsplit+1" 要素になります)。 *maxsplit* が与
   えられないか "-1" なら、分割の回数に制限はありません (可能なだけ分
   割されます)。

   *sep* が与えられた場合、連続した区切り文字はまとめられず、空の文字
   列を区切っていると判断されます(例えば "'1,,2'.split(',')" は "['1',
   '', '2']" を返します)。引数 *sep* は複数の文字にもできます (例えば
   "'1<>2<>3'.split('<>')" は "['1', '2', '3']" を返します)。区切り文
   字を指定して空の文字列を分割すると、 "['']" を返します。

   *sep* が指定されていないか "None" であれば、異なる分割アルゴリズム
   が適用されます。 : 連続する空白文字はひとつのデリミタとみなされます
   。また、文字列の先頭や末尾に空白があっても、結果の最初や最後に空文
   字列は含まれません。よって、空文字列や空白だけの文字列を "None" デ
   リミタで分割すると "[]" が返されます。

   例えば、 "' 1  2   3  '.split()" は "['1', '2', '3']" を返し、 "'
   1  2   3  '.split(None, 1)" は "['1', '2   3  ']" を返します。

str.splitlines([keepends])

   文字列を改行部分で分解し、各行からなるリストを返します。 このメソッ
   ドは、行の分割に *universal newlines* アプローチを使います。
   *keepends* に真が与えらない限り、返されるリストに改行は含まれません
   。

   Python は ""\r"", ""\n"", ""\r\n"" を 8-bit 文字列の行の境界として
   認識します。

   例えば:

      >>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
      ['ab c', '', 'de fg', 'kl']
      >>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
      ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

   "split()" とは違って、デリミタ文字列 *sep* が与えられたとき、このメ
   ソッドは空文字列に空リストを返し、終末の改行は結果に行を追加しませ
   ん:

      >>> "".splitlines()
      []
      >>> "One line\n".splitlines()
      ['One line']

   比較のために "split('\n')" は以下のようになります:

      >>> ''.split('\n')
      ['']
      >>> 'Two lines\n'.split('\n')
      ['Two lines', '']

unicode.splitlines([keepends])

   "str.splitlines()" のように、文字列を行のリストにして返します。 た
   だし Unicode のメソッドでは、8-bit 文字列の行の境界として認識される
   *universal newlines* よりも多くの次に挙げる行の境界で分割します。

   +-------------------------+-------------------------------+
   | 表現                    | 説明                          |
   +=========================+===============================+
   | "\n"                    | 改行                          |
   +-------------------------+-------------------------------+
   | "\r"                    | 復帰                          |
   +-------------------------+-------------------------------+
   | "\r\n"                  | 改行 + 復帰                   |
   +-------------------------+-------------------------------+
   | "\v" or "\x0b"          | 垂直タブ                      |
   +-------------------------+-------------------------------+
   | "\f" or "\x0c"          | 改ページ                      |
   +-------------------------+-------------------------------+
   | "\x1c"                  | ファイル区切り                |
   +-------------------------+-------------------------------+
   | "\x1d"                  | グループ区切り                |
   +-------------------------+-------------------------------+
   | "\x1e"                  | レコード区切り                |
   +-------------------------+-------------------------------+
   | "\x85"                  | 改行 (C1 制御コード)          |
   +-------------------------+-------------------------------+
   | "\u2028"                | 行区切り                      |
   +-------------------------+-------------------------------+
   | "\u2029"                | 段落区切り                    |
   +-------------------------+-------------------------------+

   バージョン 2.7 で変更: "\v" と "\f" が行境界のリストに追加されまし
   た。

str.startswith(prefix[, start[, end]])

   文字列が指定された *prefix* で始まるなら "True" を、そうでなければ
   "False" を返します。 *prefix* は見つけたい複数の接頭語のタプルでも
   構いません。オプションの *start* があれば、その位置から判定を始めま
   す。オプションの *end* があれば、その位置で比較を止めます。

   バージョン 2.5 で変更: *prefix* でタプルを受け付けるようになりまし
   た.

str.strip([chars])

   文字列の先頭および末尾部分を除去したコピーを返します。引数 *chars*
   は除去される文字集合を指定する文字列です。 *chars* が省略されるか
   "None" の場合、空白文字が除去されます。 *chars* 文字列は接頭語でも
   接尾語でもなく、そこに含まれる文字の組み合わせ全てがはぎ取られます
   。 :

   >>> '   spacious   '.strip()
   'spacious'
   >>> 'www.example.com'.strip('cmowz.')
   'example'

   バージョン 2.2.2 で変更: 引数 *chars* をサポートしました.

str.swapcase()

   文字列をコピーし、大文字は小文字に、小文字は大文字に変換して返しま
   す。

   8ビット文字列では、メソッドはロケール依存になります。

str.title()

   文字列を、単語ごとに大文字から始まり、残りの文字のうち大小文字の区
   別があるものは全て小文字にする、タイトルケースにして返します。

   このアルゴリズムは、連続した文字の集まりという、言語から独立した単
   純な単語の定義を使います。この定義は多くの状況ではうまく機能します
   が、短縮形や所有格のアポストロフィが単語の境界になってしまい、望み
   の結果を得られない場合があります:

      >>> "they're bill's friends from the UK".title()
      "They'Re Bill'S Friends From The Uk"

   正規表現を使うことでアポストロフィに対応できます:

      >>> import re
      >>> def titlecase(s):
      ...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
      ...                   lambda mo: mo.group(0)[0].upper() +
      ...                              mo.group(0)[1:].lower(),
      ...                   s)
      ...
      >>> titlecase("they're bill's friends.")
      "They're Bill's Friends."

   8ビット文字列では、メソッドはロケール依存になります。

str.translate(table[, deletechars])

   文字列をコピーし、オプション引数の文字列 *deletechars* の中に含まれ
   る文字を全て除去します。その後、残った文字を変換テーブル *table* に
   従ってマップして返します。変換テーブルは長さ 256 の文字列でなければ
   なりません。

   トランスレーションテーブル作成のために、 "string" モジュールの
   "maketrans()" 補助関数を使うこともできます。文字列型オブジェクトに
   対しては、 *table* 引数に "None" を与えることで、文字の削除だけを実
   施します。:

   >>> 'read this short text'.translate(None, 'aeiou')
   'rd ths shrt txt'

   バージョン 2.6 で追加: "None" の *table* 引数をサポートしました。

   Unicode オブジェクトの場合、 "translate()" メソッドはオプションの
   *deletechars* 引数を受理しません。その代わり、メソッドはすべての文
   字が与えられた変換テーブルで対応付けされている *s* のコピーを返しま
   す。この変換テーブルは Unicode 順 (ordinal) から Unicode 順、
   Unicode 文字列、または "None" への対応付けでなくてはなりません。対
   応付けされていない文字は何もせず放置されます。 "None" に対応付けら
   れた文字は削除されます。ちなみに、より柔軟性のあるアプローチは、自
   作の文字対応付けを行う codec を "codecs" モジュールを使って作成する
   ことです (例えば "encodings.cp1251" を参照してください。)

str.upper()

   全ての大小文字の区別のある文字 [4] が大文字に変換された、文字列のコ
   ピーを返します。なお "s.upper().isupper()" は、 "s" が大小文字の区
   別のある文字を含まなかったり、結果の文字の Unicode カテゴリが "Lu"
   ではなく例えば "Lt" (Letter, titlecase) などであったら、 "False" に
   なりえます。

   8ビット文字列では、メソッドはロケール依存になります。

str.zfill(width)

   数値文字列の左側をゼロ詰めし、幅 *width* の文字列で返します。符号接
   頭辞も正しく扱われます。 *width* が "len(s)" 以下の場合もとの文字列
   自体が返されます。

   バージョン 2.2.2 で追加.

以下のメソッドは、 Unicode オブジェクトにのみ実装されます:

unicode.isnumeric()

   数字を表す文字のみで構成される場合、 "True" を返します。それ以外の
   場合は "False" を返します。数字を表す文字には、 0 から 9 までの数字
   と、 Unicode の数字プロパティを持つ全ての文字が含まれます。 (e.g.
   U+2155, VULGAR FRACTION ONE FIFTH)

unicode.isdecimal()

   10 進数文字のみで構成される場合、 "True" を返します。それ以外の場合
   は、 "False" を返します。 10 進数文字には 0 から 9 までの数字と、
   10 進基数表記に使われる全ての文字が含まれます。 (e.g. U+0660,
   ARABIC-INDIC DIGIT ZERO)


5.6.2. 文字列フォーマット操作
-----------------------------

文字列および Unicode オブジェクトには固有の操作: "%" 演算子 (モジュロ)
があります。この演算子は文字列 *フォーマット化* または *補間* 演算とし
ても知られています。 "format % values" (*format* は文字列または
Unicode オブジェクト) とすると、 *format* 中の "%" 変換指定は *values*
中のゼロ個またはそれ以上の要素で置換されます。この動作は C 言語におけ
る "sprintf()" に似ています。 *format* が Unicode オブジェクトであるか
、または "%s" 変換を使って Unicode オブジェクトが変換される場合、その
結果も Unicode オブジェクトになります。

*format* が単一の引数しか要求しない場合、 *values* はタプルでない単一
のオブジェクトでもかまいません。 [5] それ以外の場合、 *values* はフォ
ーマット文字列中で指定された項目と正確に同じ数の要素からなるタプルか、
単一のマップオブジェクトでなければなりません。

一つの変換指定子は 2 またはそれ以上の文字を含み、その構成要素は以下か
らなりますが、示した順に出現しなければなりません:

1. 指定子の開始を示す文字 "'%'" 。

2. マップキー (オプション)。丸括弧で囲った文字列からなります (例え
   ば "(somename)") 。

3. 変換フラグ (オプション)。一部の変換型の結果に影響します。

4. 最小のフィールド幅 (オプション)。 "'*'" (アスタリスク) を指定し
   た場 合、実際の文字列幅が *values* タプルの次の要素から読み出されま
   す。 タプルには最小フィールド幅やオプションの精度指定の後に変換した
   いオ ブジェクトがくるようにします。

5. 精度 (オプション)。 "'.'" (ドット) とその後に続く精度で与えられ
   ます 。 "'*'" (アスタリスク) を指定した場合、精度の桁数は *values*
   タプ ルの次の要素から読み出されます。タプルには精度指定の後に変換し
   たい 値がくるようにします。

6. 精度長変換子 (オプション)。

7. 変換型。

"%" 演算子の右側の引数が辞書の場合 (またはその他のマップ型の場合), 文
字列中のフォーマットには、辞書に挿入されているキーを丸括弧で囲い、文字
"'%'" の直後にくるようにしたものが含まれていなければ *なりません* 。マ
ップキーはフォーマット化したい値をマップから選び出します。例えば:

>>> print '%(language)s has %(number)03d quote types.' % \
...       {"language": "Python", "number": 2}
Python has 002 quote types.

この場合、 "*" 指定子をフォーマットに含めてはいけません ("*" 指定子は
順番付けされたパラメタのリストが必要だからです)。

変換フラグ文字を以下に示します:

+-----------+-----------------------------------------------------------------------+
| フラグ    | 意味                                                                  |
+===========+=======================================================================+
| "'#'"     | 値の変換に (下で定義されている) "別の形式" を使います。               |
+-----------+-----------------------------------------------------------------------+
| "'0'"     | 数値型に対してゼロによるパディングを行います。                        |
+-----------+-----------------------------------------------------------------------+
| "'-'"     | 変換された値を左寄せにします ("'0'" と同時に与えた場合、 "'0'" を上書 |
|           | きします) 。                                                          |
+-----------+-----------------------------------------------------------------------+
| "' '"     | (スペース) 符号付きの変換で正の数の場合、前に一つスペースを空けます ( |
|           | そうでない場合は空文字になります) 。                                  |
+-----------+-----------------------------------------------------------------------+
| "'+'"     | 変換の先頭に符号文字 ("'+'" または "'-'") を付けます("スペース" フラ  |
|           | グ を上書きします) 。                                                 |
+-----------+-----------------------------------------------------------------------+

精度長変換子("h", "l",または "L") を使うことができますが、 Python では
必要ないため無視されます。 -- つまり、例えば "%ld" は "%d" と等価です
。

変換型を以下に示します:

+--------------+-------------------------------------------------------+---------+
| 変換         | 意味                                                  | 注釈    |
+==============+=======================================================+=========+
| "'d'"        | 符号付き 10 進整数。                                  |         |
+--------------+-------------------------------------------------------+---------+
| "'i'"        | 符号付き 10 進整数。                                  |         |
+--------------+-------------------------------------------------------+---------+
| "'o'"        | 符号付き 8 進数。                                     | (1)     |
+--------------+-------------------------------------------------------+---------+
| "'u'"        | 旧式の型 -- "'d'" と同じです。                        | (7)     |
+--------------+-------------------------------------------------------+---------+
| "'x'"        | 符号付き 16 進数 (小文字)。                           | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'X'"        | 符号付き 16 進数 (大文字)。                           | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'e'"        | 指数表記の浮動小数点数 (小文字)。                     | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'E'"        | 指数表記の浮動小数点数 (大文字)。                     | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'f'"        | 10 進浮動小数点数。                                   | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'F'"        | 10 進浮動小数点数。                                   | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'g'"        | 浮動小数点数。指数部が -4 以上または精度以下の場合に  | (4)     |
|              | は小文字指数表記、 それ以外の場合には10進表記。       |         |
+--------------+-------------------------------------------------------+---------+
| "'G'"        | 浮動小数点数。指数部が -4 以上または精度以下の場合に  | (4)     |
|              | は大文字指数表記、 それ以外の場合には10進表記。       |         |
+--------------+-------------------------------------------------------+---------+
| "'c'"        | 文字一文字 (整数または一文字からなる文字列を受理しま  |         |
|              | す)。                                                 |         |
+--------------+-------------------------------------------------------+---------+
| "'r'"        | 文字列 (Python オブジェクトを repr() で変換します)。  | (5)     |
+--------------+-------------------------------------------------------+---------+
| "'s'"        | 文字列 (Python オブジェクトを "str()" で変換します)。 | (6)     |
+--------------+-------------------------------------------------------+---------+
| "'%'"        | 引数を変換せず、返される文字列中では文字 "'%'" になり |         |
|              | ます。                                                |         |
+--------------+-------------------------------------------------------+---------+

注釈:

1. この形式の出力にした場合、変換結果の先頭の数字がゼロ ("'0'") で
   ない ときには、数字の先頭と左側のパディングとの間にゼロを挿入します
   。

2. 別の形式を指定（訳注: 変換フラグ "#" を使用）すると 16 進数を表
   す接 頭辞 "'0x'" または "'0X'" (使用するフォーマット文字が "'x'" か
   "'X'" に依存します) が最初の数字の前に挿入されます。

3. この形式にした場合、変換結果には常に小数点が含まれ、それはその後
   ろ に数字が続かない場合にも適用されます。

   指定精度は小数点の後の桁数を決定し、そのデフォルトは 6 です。

4. この形式にした場合、変換結果には常に小数点が含まれ他の形式とは違
   っ て末尾の 0 は取り除かれません。

   指定精度は小数点の前後の有効桁数を決定し、そのデフォルトは 6 です。

5. "%r" 変換は Python 2.0 で追加されました。

   指定精度は最大文字数を決定します。

6. オブジェクトや与えられた書式が "unicode" 文字列の場合、変換後の
   文字 列も "unicode" になります。

   指定精度は最大文字数を決定します。

7. **PEP 237** を参照してください。

Python 文字列には明示的な長さ情報があるので、 "%s" 変換において "'\0'"
を文字列の末端と仮定したりはしません。

バージョン 2.7 で変更: 絶対値が 1e50 を超える数値の "%f" 変換が "%g"
変換に置き換えられなくなりました。

その他の文字列操作は標準モジュール "string" および "re" で定義されてい
ます。


5.6.3. XRange 型
----------------

"xrange" 型は値の変更不能なシーケンスで、広範なループ処理に使われてい
ます。 "xrange" 型の利点は、 "xrange" オブジェクトは表現する値域の大き
さにかかわらず常に同じ量のメモリしか占めないということです。はっきりし
たパフォーマンス上の利点はありません。

XRange オブジェクトは非常に限られた振る舞い、すなわち、インデクス検索
、反復、 "len()" 関数のみをサポートしています。


5.6.4. ミュータブルなシーケンス型
---------------------------------

リストとバイト配列 ("bytearray") オブジェクトは、オブジェクトをインプ
レースに変更できるようにする追加の操作をサポートします。他のミュータブ
ルなシーケンス型 (を言語に追加するとき) も、それらの操作をサポートする
べきです。文字列およびタプルはイミュータブルなシーケンス型です: これら
のオブジェクトは一度生成されたら変更できません。ミュータブルなシーケン
ス型では以下の操作が定義されています (ここで *x* は任意のオブジェクト
とします)。

+--------------------------------+----------------------------------+-----------------------+
| 演算                           | 結果                             | 注釈                  |
+================================+==================================+=======================+
| "s[i] = x"                     | *s* の要素 *i* を *x* と入れ替え |                       |
|                                | ます                             |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s[i:j] = t"                   | *s* の *i* から *j* 番目までのス |                       |
|                                | ライスをイテラブル *t* の内容に  |                       |
|                                | 入れ替 えます                    |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i:j]"                   | "s[i:j] = []" と同じです         |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s[i:j:k] = t"                 | "s[i:j:k]" の要素を *t* の要素と | (1)                   |
|                                | 入れ替えます                     |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i:j:k]"                 | リストから "s[i:j:k]" の要素を削 |                       |
|                                | 除します                         |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.append(x)"                  | "s[len(s):len(s)] = [x]" と同じ  | (2)                   |
|                                | です                             |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.extend(t)" または "s += t"  | "s[len(s):len(s)] = t" とほとん  | (3)                   |
|                                | ど同じです                       |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s *= n"                       | *s* をその内容を *n*  回繰り返し | (11)                  |
|                                | たもので更新                     |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.count(x)"                   | "s[i] == x" となる *i* の個数を  |                       |
|                                | 返します                         |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.index(x[, i[, j]])"         | "s[k] == x" かつ "i <= k < j" と | (4)                   |
|                                | なる最小の *k* を返します        |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.insert(i, x)"               | "s[i:i] = [x]" と同じです        | (5)                   |
+--------------------------------+----------------------------------+-----------------------+
| "s.pop([i])"                   | "x = s[i]; del s[i]; return x"   | (6)                   |
|                                | と同じです                       |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.remove(x)"                  | "del s[s.index(x)]" と同じです   | (4)                   |
+--------------------------------+----------------------------------+-----------------------+
| "s.reverse()"                  | *s* をインプレースに逆転させます | (7)                   |
+--------------------------------+----------------------------------+-----------------------+
| "s.sort([cmp[, key[,           | *s* の要素をインプレースに並べ替 | (7)(8)(9)(10)         |
| reverse]]])"                   | えます                           |                       |
+--------------------------------+----------------------------------+-----------------------+

注釈:

1. *t* は置き換えるスライスと同じ長さでなければいけません。

2. かつての Python の C 実装では、複数パラメタを受理し、暗黙にそれ
   らを タプルに結合していました。この間違った機能は Python 1.4 で撤廃
   され 、 Python 2.0 の導入とともにエラーにするようになりました。

3. *x* は任意のイテラブルオブジェクトにできます。

4. *x* が *s* 中に見つからなかった場合 "ValueError" を送出します。
   負の インデクスが二番目または三番目のパラメタとして "index()" メソ
   ッドに 渡されると、これらの値にはスライスのインデクスと同様にリスト
   の長さ が加算されます。加算後もまだ負の場合、その値はスライスのイン
   デクス と同様にゼロに切り詰められます。

   バージョン 2.3 で変更: 以前は "index()" には開始と終了位置を指定す
   る引数がありませんでした。

5. "insert()" の最初のパラメタとして負のインデクスが渡された場合、
   スラ イスのインデクスと同じく、リストの長さが加算されます。それでも
   負の 値を取る場合、スライスのインデクスと同じく、 0 に丸められます
   。

   バージョン 2.3 で変更: 以前は、すべての負値は 0 に丸められていまし
   た。

6. "pop()" メソッドのオプションの引数 *i* は標準で "-1" なので、標
   準で は最後の要素をリストから除去して返します。

7. "sort()" および "reverse()" メソッドは大きなリストを並べ替えたり
   反 転したりする際、容量の節約のためにリストを直接変更します。副作用
   が あることをユーザに思い出させるために、これらの操作は並べ替えまた
   は 反転されたリストを返しません。

8. "sort()" メソッドは、比較を制御するためにオプションの引数をとり
   ます 。

   *cmp* は2つの引数 (リストの要素) からなるカスタムの比較関数を指定し
   ます。 これは始めの引数が 2 つ目の引数に比べて小さい、等しい、大き
   いかに応じて負数、ゼロ、正数を返します。 "cmp=lambda x,y:
   cmp(x.lower(), y.lower())" 。デフォルト値は "None" です。

   *key* は 1 つの引数からなる関数を指定します。これはリストの各要素か
   ら比較のキーを取り出すのに使われます: "key=str.lower"。デフォルト値
   は "None" です。

   *reverse* はブール値です。"True" に設定された場合、リストの要素は各
   比較が反転したように並び替えられます。

   一般的に、 *key* および *reverse* の変換プロセスは同等の *cmp* 関数
   を指定するより早く動作します。これは *key* および *reverse* がそれ
   ぞれの要素に一度だけ触れる間に、 *cmp* はリストのそれぞれの要素に対
   して複数回呼ばれることによるものです。旧式の *cmp* 関数を *key* 関
   数に変換するには "functools.cmp_to_key()" を使用してください。

   バージョン 2.3 で変更: "None" を渡すのと、 *cmp* を省略した場合とで
   、同等に扱うサポートを追加.

   バージョン 2.4 で変更: *key* および *reverse* のサポートを追加.

9. Python 2.3 より、 "sort()" メソッドは安定していることが保証され
   てい ます。ソートは、等しい要素の相対順序が変更されないことが保証さ
   れて いれば、安定しています --- これは複合的なパスでソートを行なう
   （例え ば部署でソートして、それから給与の等級でソートする）のに役立
   ちます 。

10. リストがソートされている間、または変更しようとする試みの影響中
    、あ るいは検査中でさえ、リストは未定義です。Python 2.3 とそれ以降
    の C 実装では、それらが続いている間、リストは空として出力され、リ
    ストが ソート中に変更されていることを検知できたら "ValueError" を
    送出しま す。

11. 値 *n* は整数または "__index__()" を実装したオブジェクトです。
    *n* にゼロや負数を与えると、シーケンスをクリアします。シーケンス内
    の要 素はコピーされません; コピーではなく要素に対する参照カウント
    が増え ます。 "s * n" について シーケンス型 --- str, unicode,
    list, tuple, bytearray, buffer, xrange で説明したとおりです。


5.7. set（集合）型 --- "set", "frozenset"
=========================================

*set* オブジェクトは順序付けされていない *hashable* (ハッシュ可能な)
オブジェクトのコレクションです。よくある使い方には、メンバーシップのテ
スト、数列から重複を削除する、そして論理積、論理和、差集合、対称差など
数学的演算の計算が含まれます。 (他のコンテナ型については、組み込みクラ
スの "dict", "list", "tuple",および、モジュール "collections" を参照下
さい)

バージョン 2.4 で追加.

集合は、他のコレクションと同様、 "x in set", "len(set)", "for x in
set" をサポートします。コレクションには順序がないので、集合は挿入の順
序や要素の位置を記録しません。従って、集合はインデクシング、スライシン
グ、その他のシーケンス的な振舞いをサポートしません。

"set" および "frozenset" という、2つの組み込みの集合型があります。
"set" はミュータブルで、"add()" や "remove()" のようなメソッドを使って
内容を変更できます。ミュータブルなため、ハッシュ値を持たず、また辞書の
キーや他の集合の要素として用いることができません。一方、"frozenset" 型
はイミュータブルで、*ハッシュ可能* です。作成後に内容を改変できないた
め、辞書のキーや他の集合の要素として用いることができます。

Python 2.7 では、空でない set (frozenset ではない) は、 "set" コンスト
ラクタに加え、要素を波カッコ中にカンマで区切って列挙することでも生成で
きます。例: "{'jack', 'sjoerd'}".

どちらのクラスのコンストラクタも同様に働きます:

class set([iterable])
class frozenset([iterable])

   *iterable* から要素を取り込んだ、新しい "set" もしくは "frozenset"
   オブジェクトを返します。 集合の要素は *ハッシュ可能* なものでなくて
   はなりません。集合の集合を表現するためには、内側の集合は
   "frozenset" オブジェクトでなくてはなりません。*iterable* が指定され
   ない場合、新しい空の集合が返されます。

   "set" および "frozenset" のインスタンスは以下の操作を提供します:

   len(s)

      集合 *s* の要素数 (*s* の濃度) を返します。

   x in s

      *x* が *s* のメンバーに含まれるか判定します。

   x not in s

      *x* が *s* のメンバーに含まれていないことを判定します。

   isdisjoint(other)

      集合が *other* と共通の要素を持たないとき、"True" を返します。集
      合はそれらの積集合が空集合となるときのみ、互いに素 (disjoint) と
      なります。

      バージョン 2.6 で追加.

   issubset(other)
   set <= other

      set の全ての要素が *other* に含まれるか判定します。

   set < other

      set が *other* の真部分集合であるかを判定します。つまり、 "set
      <= other and set != other" と等価です。

   issuperset(other)
   set >= other

      *other* の全ての要素が set に含まれるか判定します。

   set > other

      set が *other* の真上位集合であるかを判定します。つまり、 "set
      >= other and set != other" と等価です。

   union(*others)
   set | other | ...

      set と全ての other の要素からなる新しい集合を返します。

      バージョン 2.6 で変更: 複数のイテラブルからの入力を受け入れるよ
      うになりました。

   intersection(*others)
   set & other & ...

      set と全ての other に共通する要素を持つ、新しい集合を返します。

      バージョン 2.6 で変更: 複数のイテラブルからの入力を受け入れるよ
      うになりました。

   difference(*others)
   set - other - ...

      set に含まれて、かつ、全ての other に含まれない要素を持つ、新し
      い集合を返します。

      バージョン 2.6 で変更: 複数のイテラブルからの入力を受け入れるよ
      うになりました。

   symmetric_difference(other)
   set ^ other

      set と *other* のいずれか一方だけに含まれる要素を持つ新しい集合
      を返します。

   copy()

      *s* の浅いコピーを新しい集合として返します。

   なお、演算子でない版の "union()", "intersection()", "difference()",
   "symmetric_difference()", "issubset()", "issuperset()" メソッドは、
   任意のイテラブルを引数として受け付けます。対して、演算子を使う版で
   は、引数は集合でなくてはなりません。これは、"set('abc') & 'cbs'" の
   ような誤りがちな構文を予防し、より読みやすい
   "set('abc').intersection('cbs')" を支持します。

   "set" と "frozenset" のどちらも、集合同士の比較をサポートします。二
   つの集合は、それぞれの集合の要素全てが他方にも含まれている (互いに
   他方の部分集合である) とき、かつそのときに限り等しいです。一方の集
   合が他方の集合の真部分集合である (部分集合であるが等しくない) とき
   、かつそのときに限り一方の集合は他方の集合より小さいです。一方の集
   合が他方の集合の真上位集合である (上位集合であるが等しくない) とき
   、かつそのときに限り一方の集合は他方の集合より大きいです。

   "set" のインスタンスは、 "frozenset" のインスタンスと、要素に基づい
   て比較されます。例えば、 "set('abc') == frozenset('abc')" や
   "set('abc') in set([frozenset('abc')])" は "True" を返します。

   部分集合と等価性の比較は全順序付けを行う関数へと一般化することはで
   きません。例えば、互いに素である二つの非空集合は、等しくなく、他方
   の部分集合でもありませんから、以下の *すべて* に "False" を返します
   : "a<b", "a==b", そして "a>b" 。そのため、 set は "__cmp__()" メソ
   ッドを実装しません。

   集合は半順序（部分集合関係）しか定義しないので、集合のリストにおけ
   る "list.sort()" メソッドの出力は未定義です。

   集合の要素は、辞書のキーのように、ハッシュ可能 (*hashable*) でなけ
   ればなりません。

   "set" インスタンスと "frozenset" インスタンスを取り混ぜての二項演算
   は、第一被演算子の型を返します。例えば: "frozenset('ab') |
   set('bc')" は "frozenset" インスタンスを返します。

   以下の表に挙げる演算は "set" に適用されますが、"frozenset" のイミュ
   ータブルなインスタンスには適用されません:

   update(*others)
   set |= other | ...

      全ての other の要素を追加し、 set を更新します。

      バージョン 2.6 で変更: 複数のイテラブルからの入力を受け入れるよ
      うになりました。

   intersection_update(*others)
   set &= other & ...

      元の set と全ての other に共通する要素だけを残して set を更新し
      ます。

      バージョン 2.6 で変更: 複数のイテラブルからの入力を受け入れるよ
      うになりました。

   difference_update(*others)
   set -= other | ...

      *other* に含まれる要素を取り除き、 set を更新します。

      バージョン 2.6 で変更: 複数のイテラブルからの入力を受け入れるよ
      うになりました。

   symmetric_difference_update(other)
   set ^= other

      どちらかにのみ含まれて、共通には持たない要素のみで set を更新し
      ます。

   add(elem)

      要素 *elem* を set に追加します。

   remove(elem)

      要素 *elem* を set から取り除きます。*elem* が set に含まれてい
      なければ "KeyError" を送出します。

   discard(elem)

      要素 *elem* が set に含まれていれば、取り除きます。

   pop()

      任意に要素をから返し、それを set から取り除きます。set が空であ
      れば、 "KeyError" を送出します。

   clear()

      set の全ての要素を取り除きます。

   なお、演算子でない版の "update()", "intersection_update()",
   "difference_update()", および "symmetric_difference_update()" メソ
   ッドは、任意のイテラブルを引数として受け付けます。

   "__contains__()", "remove()", "discard()" メソッドの引数 *elem* は
   集合かもしれないことに注意してください。 その集合と等価な
   "frozenset" の検索をサポートするために、 *elem* から一時的な
   frozenset を作成します。

参考:

  組み込み set 型との比較
     "sets" モジュールと組み込み set 型の違い


5.8. マッピング型 --- "dict"
============================

マッピング (*mapping*) オブジェクトは、ハッシュ可能 (*hashable*) な値
を任意のオブジェクトに対応付けます。マッピングはミュータブルなオブジェ
クトです。現在、標準マッピング型は辞書 (*dictionary*) だけです。 (他の
コンテナについては組み込みの "list", "set", および "tuple" クラスと、
"collections" モジュールを参照下さい。)

辞書のキーは *ほぼ* 任意の値です。ハッシュ可能 (*hashable*) でない値、
つまり、リストや辞書その他のミュータブルな型 (オブジェクトの同一性では
なく値で比較されるもの) はキーとして使用できません。キーとして使われる
数値型は通常の数値比較のルールに従います: もしふたつの数値が (例えば
"1" と "1.0" のように) 等しければ、同じ辞書の項目として互換的に使用で
きます。 (ただし、コンピュータは浮動小数点数を近似値として保管するので
、辞書型のキーとして使用するのはたいてい賢くありません。)

辞書は "key: value" 対のカンマ区切りのリストを波括弧でくくることで作成
できます。例えば: "{'jack': 4098, 'sjoerd': 4127}" あるいは "{4098:
'jack', 4127: 'sjoerd'}" 。あるいは、 "dict" コンストラクタでも作成で
きます。

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

   オプションの位置引数と空集合の可能性もあるキーワード引数から初期化
   された新しい辞書を返します。

   位置引数が何も与えられなかった場合、空の辞書が作成されます。位置引
   数が与えられ、それがマッピングオブジェクトだった場合、そのマッピン
   グオブジェクトと同じキーと値のペアを持つ辞書が作成されます。それ以
   外の場合、位置引数は *iterable* オブジェクトでなければなりません。
   iterable のそれぞれの要素自身は、ちょうど 2 個のオブジェクトを持つ
   イテラブルでなければなりません。それぞれの要素の最初のオブジェクト
   は新しい辞書のキーになり、2 番目のオブジェクトはそれに対応する値に
   なります。同一のキーが 2 回以上現れた場合は、そのキーの最後の値が新
   しい辞書での対応する値になります。

   キーワード引数が与えられた場合、キーワード引数とその値が位置引数か
   ら作られた辞書に追加されます。既に存在しているキーが追加された場合
   、キーワード引数の値は位置引数の値を置き換えます。

   例を出すと、次の例は全て "{"one": 1, "two": 2, "three": 3}" に等し
   い辞書を返します:

      >>> a = dict(one=1, two=2, three=3)
      >>> b = {'one': 1, 'two': 2, 'three': 3}
      >>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
      >>> d = dict([('two', 2), ('one', 1), ('three', 3)])
      >>> e = dict({'three': 3, 'one': 1, 'two': 2})
      >>> a == b == c == d == e
      True

   最初の例のようにキーワード引数を与える方法では、キーは有効な Python
   の識別子でなければなりません。それ以外の方法では、辞書のキーとして
   有効などんなキーでも使えます。

   バージョン 2.2 で追加.

   バージョン 2.3 で変更: キーワード引数からの辞書型の作成のサポートが
   追加されました。

   以下は辞書型がサポートする操作です (それゆえ、カスタムのマップ型も
   これらの操作をサポートするべきです):

   len(d)

      辞書 *d* の項目数を返します。

   d[key]

      *d* のキー *key* の項目を返します。マップに *key* が存在しなけれ
      ば、 "KeyError" を送出します。

      辞書のサブクラスが "__missing__()" メソッドを定義しておらず、
      *key* が存在しないなら、 "d[key]" 演算はこのメソッドをキー *key*
      を引数として呼び出します。結果として、 "d[key]" 演算は、キーが存
      在しなければ、 "__missing__(key)" の呼び出しによって返されまたは
      送出されたものを何でも、返しまたは送出します。他の演算やメソッド
      は "__missing__()" を呼び出しません。 "__missing__()" が定義され
      ていなければ、 "KeyError" が送出されます。 "__missing__()" はメ
      ソッドでなければならず、インスタンス変数であってはなりません:

         >>> class Counter(dict):
         ...     def __missing__(self, key):
         ...         return 0
         >>> c = Counter()
         >>> c['red']
         0
         >>> c['red'] += 1
         >>> c['red']
         1

      ここでお見せした例は "collections.Counter" 実装の一部です。これ
      とは違った "__missing__" が:class:*collections.defaultdict* で使
      われています。

      バージョン 2.5 で追加: 辞書のサブクラスで __missing__ メソッドを
      認識するようになりました。

   d[key] = value

      "d[key]" に *value* を設定します。

   del d[key]

      *d* から "d[key]" を削除します。マップに *key* が存在しなければ
      、 "KeyError" を送出します。

   key in d

      *d* がキー *key* を持っていれば "True" を、そうでなければ、
      "False" を返します。

      バージョン 2.2 で追加.

   key not in d

      "not key in d" と等価です。

      バージョン 2.2 で追加.

   iter(d)

      辞書のキーに渡るイテレータを返します。これは  "iterkeys()" への
      ショートカットです。

   clear()

      辞書の全ての項目を消去します。

   copy()

      辞書の浅いコピーを返します。

   fromkeys(seq[, value])

      *seq* からキーを取り、値を *value* に設定した、新しい辞書を作成
      します。

      "fromkeys()" は新しい辞書を返すクラスメソッドです。 *value* のデ
      フォルト値は "None" です。

      バージョン 2.3 で追加.

   get(key[, default])

      *key* が辞書にあれば *key* に対する値を、そうでなければ
      *default* を返します。 *default* が与えられなかった場合、デフォ
      ルトでは "None" となります。そのため、このメソッドは "KeyError"
      を送出することはありません。

   has_key(key)

      辞書に *key* が存在するかを確認します。 "key in d" が可能になっ
      ているので、 "has_key()" は廃れた用法です。

   items()

      辞書のコピーを "(key, value)" の対のリストとして返します。

      キーと値のリストは任意の順序で返されますが、ランダムではなく、
      Python の実装と、辞書への挿入、および、削除操作の来歴によって決
      まります。

      "items()", "keys()", "values()", "iteritems()", "iterkeys()" お
      よび "itervalues()" は辞書に干渉して更新しなければ、返却順は直接
      対応関係にあります。つまり "(value, key)" の対を "zip()" を使っ
      て生成するとができます: "pairs = zip(d.values(), d.keys())" 。
      "iterkeys()" と "itervalues()" でも同じです: "pairs =
      zip(d.itervalues(), d.iterkeys())" は先と同じ値を返します。同じ
      リストを得るには "pairs = [(v, k) for (k, v) in d.iteritems()]"
      としても出来ます。

   iteritems()

      辞書の "(key, value)" の対をイテレータで返します。
      "dict.items()" の記述も参照下さい。

      "iteritems()" を辞書の項目の追加や削除と同時に行うと、
      "RuntimeError" を送出されるか全ての項目に対する反復に失敗するこ
      とになります。

      バージョン 2.2 で追加.

   iterkeys()

      辞書のキーをイテレータで返します。 "dict.items()" の記述も参照下
      さい。

      "iterkeys()" を辞書の項目の追加や削除と同時に行うと、
      "RuntimeError" を送出されるか全ての項目に対する反復に失敗するこ
      とになります。

      バージョン 2.2 で追加.

   itervalues()

      辞書の値をイテレータで返します。 "dict.items()" の記述も参照下さ
      い。

      "itervalues()" を辞書の項目の追加や削除と同時に行うと、
      "RuntimeError" を送出されるか全ての項目に対する反復に失敗するこ
      とになります。

      バージョン 2.2 で追加.

   keys()

      辞書のキーのリストのコピーを返します。 "dict.items()" の記述も参
      照下さい。

   pop(key[, default])

      *key* が辞書に存在すればその値を辞書から消去して返し、そうでなけ
      れば *default* を返します。 *default* が与えらず、かつ *key* が
      辞書に存在しなければ "KeyError" を送出します。

      バージョン 2.3 で追加.

   popitem()

      任意の "(key, value)" 対を辞書から消去して返します。

      集合のアルゴリズムで使われるのと同じように、 "popitem()" は辞書
      を破壊的にイテレートするのに便利です。辞書が空であれば、
      "popitem()" の呼び出しは "KeyError" を送出します。

   setdefault(key[, default])

      もし、 *key* が辞書に存在すれば、その値を返します。そうでなけれ
      ば、値を *default* として *key* を挿入し、 *default* を返します
      。 *default* のデフォルトは "None" です。

   update([other])

      辞書の内容を *other* のキーと値で更新します。既存のキーは上書き
      されます。返り値は "None" です。

      "update()" は、他の辞書オブジェクトでもキー/値の対のイテラブル (
      タプル、もしくは、長さが2のイテラブル) でも、どちらでも受け付け
      ます。キーワード引数が指定されれば、そのキー/値の対で辞書を更新
      します: "d.update(red=1, blue=2)"。

      バージョン 2.4 で変更: キーと値の対のイテラブル、および、キーワ
      ード引数を引数として与えることができるようになりました。

   values()

      辞書の値のリストのコピーを返します。 "dict.items()" の記述も参照
      下さい。

   viewitems()

      辞書のアイテム ("(key, value)" のペア) の新しいビューを返します
      。ビューオブジェクトについては下に説明があります。

      バージョン 2.7 で追加.

   viewkeys()

      辞書のキーの新しいビューを返します。ビューオブジェクトについては
      下に説明があります。

      バージョン 2.7 で追加.

   viewvalues()

      辞書の値の新しいビューを返します。ビューオブジェクトについては下
      に説明があります。

      バージョン 2.7 で追加.

   辞書は、同じ "(key, value)" の対を持つときのみ等しくなります。


5.8.1. 辞書ビューオブジェクト
-----------------------------

"dict.viewkeys()", "dict.viewvalues()", "dict.viewitems()" によって返
されるオブジェクトは、 *ビューオブジェクト* です。これらは、辞書の項目
の動的なビューを提供し、辞書が変更された時、ビューはその変更を反映しま
す。

辞書ビューは、イテレートすることで対応するデータを yield できます。ま
た、帰属判定をサポートします:

len(dictview)

   辞書の項目数を返します。

iter(dictview)

   辞書のキー、値、または ("(key, value)" のタプルとして表される) 項目
   に渡るイテレータを返します。

   キーと値のリストはある任意の順序でイテレートされますが、ランダムで
   はなく、 Python の実装によって変わり、辞書への挿入や削除の履歴に依
   存します。キー、値、要素のビューを通して、辞書の変更を挟まずにイテ
   レートされたら、その要素の順序は完全に一致します。これにより、
   "(value, key)" の対を "zip()" で作成できます: "pairs =
   zip(d.values(), d.keys())" 。同じリストを作成する他の方法は、
   "pairs = [(v, k) for (k, v) in d.items()]" です。

   辞書の項目の追加や削除中にビューをイテレートすると、 "RuntimeError"
   を送出したり、すべての項目に渡ってイテレートできなかったりします。

x in dictview

   *x* が下にある辞書のキー、値、または項目 (項目の場合、 *x* は
   "(key, value)" タプルであるべきです) にあるとき "True" を返します。

キーのビューは、項目が一意的でハッシュ可能であるという点で、集合に似て
います。すべての値がハッシュ可能なら、 "(key, value)" 対も一意的でハッ
シュ可能なので、要素のビューも集合に似ています。(値のビューは、要素が
一般に一意的でないことから、集合に似ているとは考えられません。) これに
よりこれらへの集合演算が利用出来ます ("other" はもう一つのビューか集合
です):

dictview & other

   辞書ビューと別のオブジェクトの共通部分を新しい集合として返します。

dictview | other

   辞書ビューと別のオブジェクトの合併集合を新しい集合として返します。

dictview - other

   辞書ビューと別のオブジェクトの差集合 (*dictview* に属して *other*
   に属さないすべての要素) を新しい集合として返します。

dictview ^ other

   辞書ビューと別のオブジェクトの対称差 (*dictview* と *other* のどち
   らかに属すが両方には属さないすべての要素) を新しい集合として返しま
   す。

辞書ビューの使用法の例:

   >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
   >>> keys = dishes.viewkeys()
   >>> values = dishes.viewvalues()

   >>> # iteration
   >>> n = 0
   >>> for val in values:
   ...     n += val
   >>> print(n)
   504

   >>> # keys and values are iterated over in the same order
   >>> list(keys)
   ['eggs', 'bacon', 'sausage', 'spam']
   >>> list(values)
   [2, 1, 1, 500]

   >>> # view objects are dynamic and reflect dict changes
   >>> del dishes['eggs']
   >>> del dishes['sausage']
   >>> list(keys)
   ['spam', 'bacon']

   >>> # set operations
   >>> keys & {'eggs', 'bacon', 'salad'}
   {'bacon'}


5.9. ファイルオブジェクト
=========================

ファイルオブジェクトは C の "stdio" パッケージを使って実装されており、
組み込み関数の "open()" で生成することができます。ファイルオブジェクト
はまた、 "os.popen()" や "os.fdopen()", ソケットオブジェクトの
"makefile()" メソッドのような、他の組み込み関数およびメソッドによって
も返されます。一時ファイルは "tempfile" モジュールを使って生成でき、フ
ァイルやディレクトリのコピー、移動、消去などの高次の操作は "shutil" モ
ジュールで行えます。

ファイル操作が I/O 関連の理由で失敗した場合例外 "IOError" が送出されま
す。この理由には例えば "seek()" を端末デバイスに行ったり、読み出し専用
で開いたファイルに書き込みを行うといった、何らかの理由によってそのファ
イルで定義されていない操作を行ったような場合も含まれます。

ファイルは以下のメソッドを持ちます:

file.close()

   ファイルを閉じます。閉じられたファイルはそれ以後読み書きすることは
   できません。ファイルが開かれていることが必要な操作は、ファイルが閉
   じられた後はすべて "ValueError" を送出します。 "close()" を一度以上
   呼び出してもかまいません。

   Python 2.5 から "with" 文を使えばこのメソッドを直接呼び出す必要はな
   くなりました。たとえば、以下のコードは *f* を "with" ブロックを抜け
   る際に自動的に閉じます。

      from __future__ import with_statement # This isn't required in Python 2.6

      with open("hello.txt") as f:
          for line in f:
              print line,

   古いバージョンの Python では同じ効果を得るために次のようにしなけれ
   ばいけませんでした。

      f = open("hello.txt")
      try:
          for line in f:
              print line,
      finally:
          f.close()

   注釈: 全ての Python の "ファイル的" 型が "with" 文用のコンテキス
     トマネ ージャとして使えるわけではありません。もし、全てのファイル
     的オブ ジェクトで動くようにコードを書きたいのならば、オブジェクト
     を直接 使うのではなく "contextlib" にある "contextlib.closing()"
     関数を 使うと良いでしょう。

file.flush()

   "stdio" の "fflush()" のように、内部バッファをフラッシュします。フ
   ァイル類似のオブジェクトによっては、この操作は何も行いません。

   注釈: "flush()" は必ずしもファイルのデータをディスクに書き込むと
     は限り ません。そのような挙動を保証するには "flush()" の後に
     "os.fsync()" を使って下さい。

file.fileno()

   背後にある実装系がオペレーティングシステムに I/O 操作を要求するため
   に用いる、整数の "ファイル記述子" (ファイルデスクリプタ) を返します
   。この値は他の用途として、 "fcntl" モジュールや "os.read()" やその
   仲間のような、ファイル記述子を必要とする低レベルのインタフェースで
   役に立ちます。

   注釈: 本物のファイルデスクリプタを持たないファイル類似のオブジェ
     クトは 、このメソッドを提供すべきでは *ありません* 。

file.isatty()

   ファイルが tty (または類似の) デバイスに接続されている場合 "True"
   を返し、そうでない場合 "False" を返します。

   注釈: ファイル類似のオブジェクトが実際のファイルに関連付けられて
     いない 場合、このメソッドを実装すべきでは *ありません* 。

file.next()

   ファイルオブジェクトはそれ自身がイテレータです。すなわち、
   "iter(f)" は (*f* が閉じられていない限り) *f* を返します。 "for" ル
   ープ (例えば "for line in f: print line.strip()") のようにファイル
   がイテレータとして使われた場合、 "next()" メソッドが繰り返し呼び出
   されます。ファイルが読み込みのために開かれている場合、このメソッド
   は次の入力行を返すか、または、 EOF に到達したときに "StopIteration"
   を送出します (ファイルが書き込みモードで開かれている場合、動作は未
   定義です) 。ファイル内の各行に対する "for" ループ (非常によくある操
   作です) を効率的な方法で行うために、 "next()" メソッドは隠蔽された
   先読みバッファを使います。先読みバッファを使った結果として、
   ("readline()" のような) 他のファイルメソッドと "next()" を組み合わ
   せて使うとうまく動作しません。しかし、 "seek()" を使ってファイル位
   置を絶対指定しなおすと、先読みバッファは消去されます。

   バージョン 2.3 で追加.

file.read([size])

   最大で *size* バイトをファイルから読み込みます (*size* バイトを取得
   する前に EOF に到達した場合、それ以下の長さになります) 。 *size* 引
   数が負であるか省略された場合、 EOF に到達するまでの全てのデータを読
   み込みます。読み出されたバイト列は文字列オブジェクトとして返されま
   す。直後に EOF に到達した場合、空の文字列が返されます。 (端末のよう
   なある種のファイルでは、 EOF に到達した後でファイルを読みつづけるこ
   とにも意味があります) 。このメソッドは、 *size* バイトに可能な限り
   近くデータを取得するために、背後の C 関数 "fread()" を 1 度以上呼び
   出すかもしれないので注意してください。また、非ブロック・モードでは
   、 *size* パラメータが与えられなくても、要求されたよりも少ないデー
   タが返される場合があることに注意してください。

   注釈: この関数は単純に、背後の C 関数 "fread()" のラッパーです。
     そのた め、 EOF が予期せず検出されたりされなかったりといった個別
     の事情が あっても同じように振舞うだけです。

file.readline([size])

   ファイルから一行全部を読み込みます。行末の改行文字は文字列に残りま
   す (だだし、ファイルが不完全な行で終わっていたら、存在しないかもし
   れません)。 [6] *size* 引数が与えられ、負でなければ、それが (行末の
   改行文字を含む) 最大バイト数となり、不完全な行でも返されます。
   *size* が 0 でなければ、空の文字列が返されるのは、即座に EOF に到達
   したとき *だけ* です。

   注釈: C "stdio" の "fgets()" と違い、入力中にヌル文字 ("'\0'") が
     含まれ ていれば、ヌル文字を含んだ文字列が返されます。

file.readlines([sizehint])

   "readline()" を使ってに到達するまで読み出し、 EOF 読み出された行を
   含むリストを返します。オプションの *sizehint* 引数が存在すれば、
   EOF まで読み出す代わりに完全な行を全体で大体 *sizehint* バイトにな
   るように (おそらく内部バッファサイズを切り詰めて) 読み出します。フ
   ァイル類似のインタフェースを実装しているオブジェクトは、 *sizehint*
   を実装できないか効率的に実装できない場合には無視してもかまいません
   。

file.xreadlines()

   このメソッドは "iter(f)" と同じ結果を返します。

   バージョン 2.1 で追加.

   バージョン 2.3 で非推奨: 代わりに "for line in file" を使ってくださ
   い。

file.seek(offset[, whence])

   C "stdio" の "fseek()" が行うように、ファイルの現在位置を設定します
   。 *whence* 引数はオプションで、標準の値は "os.SEEK_SET" もしくは
   "0" (絶対位置指定) です; 他に取り得る値は "os.SEEK_CUR" もしくは
   "1" (現在のファイル位置から相対的に seek する) および "os.SEEK_END"
   もしくは "2" (ファイルの末端から相対的に seek する) です。戻り値は
   ありません。

   例えば、 "f.seek(2, os.SEEK_CUR)" 位置を2つ進めます。 "f.seek(-3,
   os.SEEK_END)" では終端の3つ手前に設定します。

   ファイルを追記モード (モード "'a'" または "'a+'") で開いた場合、書
   き込みを行うまでに行った "seek()" 操作はすべて元に戻されるので注意
   してください。ファイルが追記のみの書き込みモード ("'a'") で開かれた
   場合、このメソッドは実質何も行いませんが、読み込みが可能な追記モー
   ド ("'a+'") で開かれたファイルでは役に立ちます。ファイルをテキスト
   モードで ("'b'" なしで) 開いた場合、 "tell()" が返すオフセットのみ
   が正しい値になります。他のオフセット値を使った場合、その振る舞いは
   未定義です。

   全てのファイルオブジェクトが seek できるとは限らないので注意してく
   ださい。

   バージョン 2.6 で変更: オフセットに浮動小数点数を渡すことは非推奨と
   なりました。

file.tell()

   C の "stdio" の "ftell()" のように、ファイルの現在位置を返します。

   注釈: Windows では、("fgets()" の後で) Unix スタイルの改行のファ
     イルを 読むときに "tell()" が不正な値を返すことがあります。この問
     題に遭 遇しないためにはバイナリーモード ("'rb'") を使うようにして
     くださ い。

file.truncate([size])

   ファイルのサイズを切り詰めます。オプションの *size* が存在すれば、
   ファイルは (最大で) 指定されたサイズに切り詰められます。標準設定の
   サイズの値は、現在のファイル位置までのファイルサイズです。現在のフ
   ァイル位置は変更されません。指定されたサイズがファイルの現在のサイ
   ズを越える場合、その結果はプラットフォーム依存なので注意してくださ
   い: 可能性としては、ファイルは変更されないか、指定されたサイズまで
   ゼロで埋められるか、指定されたサイズまで未定義の新たな内容で埋めら
   れるか、があります。利用可能な環境: Windows, 多くの Unix 系。

file.write(str)

   文字列をファイルに書き込みます。戻り値はありません。バッファリング
   によって、 "flush()" または "close()" が呼び出されるまで実際にファ
   イル中に文字列が書き込まれないこともあります。

file.writelines(sequence)

   文字列からなるシーケンスをファイルに書き込みます。シーケンスは文字
   列を生成する反復可能なオブジェクトなら何でもかまいません。よくある
   のは文字列からなるリストです。戻り値はありません。 (関数の名前は
   "readlines()" と対応づけてつけられました; "writelines()" は行間の区
   切りを追加しません。)

ファイルはイテレータプロトコルをサポートします。各反復操作では
"readline()" と同じ結果を返し、反復は "readline()" メソッドが空文字列
を返した際に終了します。

ファイルオブジェクトはまた、多くの興味深い属性を提供します。これらはフ
ァイル類似オブジェクトでは必要ではありませんが、特定のオブジェクトにと
って意味を持たせたいなら実装しなければなりません。

file.closed

   現在のファイルオブジェクトの状態を示すブール値です。この値は読み出
   し専用の属性です; "close()" メソッドがこの値を変更します。全てのフ
   ァイル類似オブジェクトで利用可能とは限りません。

file.encoding

   このファイルが使っているエンコーディングです。 Unicode 文字列がファ
   イルに書き込まれる際、 Unicode 文字列はこのエンコーディングを使って
   バイト文字列に変換されます。さらに、ファイルが端末に接続されている
   場合、この属性は端末が使っているとおぼしきエンコーディング (この情
   報は端末がうまく設定されていない場合には不正確なこともあります) を
   与えます。この属性は読み出し専用で、すべてのファイル類似オブジェク
   トにあるとは限りません。またこの値は "None" のこともあり、この場合
   、ファイルは Unicode 文字列の変換のためにシステムのデフォルトエンコ
   ーディングを使います。

   バージョン 2.3 で追加.

file.errors

   エンコーディングに用いられる、 Unicode エラーハンドラです。

   バージョン 2.6 で追加.

file.mode

   ファイルの I/O モードです。ファイルが組み込み関数 "open()" で作成さ
   れた場合、この値は引数 *mode* の値になります。この値は読み出し専用
   の属性で、全てのファイル類似オブジェクトに存在するとは限りません。

file.name

   ファイルオブジェクトが "open()" を使って生成された場合は、そのファ
   イル名です。そうでなければ、ファイルオブジェクト生成の起源を示す何
   らかの文字列になり、 "<...>" の形式をとります。この値は読み出し専用
   の属性で、全てのファイル類似オブジェクトに存在するとは限りません。

file.newlines

   Python が *universal newlines* を (デフォルトどおり) 有効にしてビル
   ドされているなら、この読み込み専用属性が存在し、ファイルが
   universal newlines で開かれたファイルで、ファイルの読み込み中にあっ
   た改行の種類を記録します。取り得る値は "'\r'", "'\n'", "'\r\n'",
   "None" (不明であるか、まだ改行を読み込んでいない)、または、複数の改
   行方式の種類が存在したことを表す、見つかったすべての改行の種類を含
   むタプルです。 universal newlines で開かれたのでないファイルに対し
   ては、この属性の値は "None" になります。

file.softspace

   "print" 文を使った場合、他の値を出力する前にスペース文字を出力する
   必要があるかどうかを示すブール値です。ファイルオブジェクトをシミュ
   レート仕様とするクラスは書き込み可能な "softspace" 属性を持たなけれ
   ばならず、この値はゼロに初期化されなければなりません。この値は
   Python で実装されているほとんどのクラスで自動的に初期化されます (属
   性へのアクセス手段を上書きするようなオブジェクトでは注意が必要です
   ); C で実装された型では、書き込み可能な "softspace" 属性を提供しな
   ければなりません。

   注釈: この属性は "print" 文を制御するために用いられるのではなく、
     "print" の実装にその内部状態を追跡させるためにあります。


5.10. メモリビュー型
====================

バージョン 2.7 で追加.

"memoryview" オブジェクトは、Python コードが、バッファプロトコルをサポ
ートするオブジェクトの内部データへ、コピーすることなくアクセスすること
を可能にします。メモリは通常、単純なバイト列として解釈されます。

class memoryview(obj)

   *obj* を参照する "memoryview" を作成します。 *obj* はバッファプロト
   コルをサポートしていなければなりません。バッファプロトコルをサポー
   トする組み込みオブジェクトには、 "str" 、 "bytearray" などがありま
   す (ただし、 "unicode" は違います)。

   "memoryview" には *要素* の概念があり、それが起源のオブジェクト
   *obj* によって扱われる原子的なメモリの単位になります。多くの単純な
   型、例えば "str" や "bytearray" では、要素は単バイトになりますが、
   他のサードパーティの型では、要素はより大きくなりえます。

   "len(view)" は、メモリビュー *view* の要素の総数を返します。
   "itemsize" 属性で一つの要素内のバイト数を取得できます。

   "memoryview" はスライスしてデータを晒すことに対応しています。一つの
   インデクスを渡すと一つの要素を "str" オブジェクトとして返します。完
   全なスライシングは部分ビューになります:

      >>> v = memoryview('abcefg')
      >>> v[1]
      'b'
      >>> v[-1]
      'g'
      >>> v[1:4]
      <memory at 0x77ab28>
      >>> v[1:4].tobytes()
      'bce'

   メモリビューが基にしているオブジェクトがデータの変更に対応していれ
   ば、メモリビューはスライス代入に対応します:

      >>> data = bytearray('abcefg')
      >>> v = memoryview(data)
      >>> v.readonly
      False
      >>> v[0] = 'z'
      >>> data
      bytearray(b'zbcefg')
      >>> v[1:4] = '123'
      >>> data
      bytearray(b'z123fg')
      >>> v[2] = 'spam'
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      ValueError: cannot modify size of memoryview object

   この通り、メモリビューオブジェクトの長さは変えられません。

   "memoryview" には 2 つのメソッドがあります。

   tobytes()

      バッファ中のデータをバイト文字列 (クラス "str" のオブジェクト)
      として返します:

         >>> m = memoryview("abc")
         >>> m.tobytes()
         'abc'

   tolist()

      バッファ中のデータを整数のリストとして返します:

         >>> memoryview("abc").tolist()
         [97, 98, 99]

   読み込み専用の属性もいくつか使えます:

   format

      ビューのそれぞれの要素に対する、("struct" モジュールのスタイルで
      の) フォーマットを含む文字列です。デフォルトは "'B'" で、単純な
      バイト文字列です。

   itemsize

      メモリビューのそれぞれの要素のバイト数です。

   shape

      メモリの形状を N 次元配列として与える、長さ "ndim" の整数のタプ
      ルです。

   ndim

      メモリが表す多次元配列が何次元かを示す整数です。

   strides

      配列のそれぞれの次元に対して、それぞれの要素にアクセスするのに必
      要なバイト数を表す、長さ "ndim" の整数のタプルです。

   readonly

      メモリが読み込み専用かを表すブールです。


5.11. コンテキストマネージャ型
==============================

バージョン 2.5 で追加.

Python の "with" 文は、コンテキストマネージャによって定義される実行時
コンテキストの概念をサポートします。これは、ユーザ定義クラスが文の本体
が実行される前に進入し文の終わりで脱出する実行時コンテキストを定義でき
るようにする一対のメソッドを使って実装されます:

*コンテキスト管理プロトコル* (*context management protocol*) は実行時
コンテキストを定義するコンテキストマネージャオブジェクトが提供すべき一
対のメソッドから成ります:

contextmanager.__enter__()

   実行時コンテキストに入り、このオブジェクトまたは他の実行時コンテキ
   ストに関連したオブジェクトを返します。このメソッドが返す値はこのコ
   ンテキストマネージャを使う "with" 文の "as" 節の識別子に束縛されま
   す。

   自分自身を返すコンテキストマネージャの例としてファイルオブジェクト
   があります。ファイルオブジェクトは "__enter__()" から自分自身を返し
   て "open()" が "with" 文のコンテキスト式として使われるようにします
   。

   関連オブジェクトを返すコンテキストマネージャの例としては
   "decimal.localcontext()" が返すものがあります。このマネージャはアク
   ティブな10進数コンテキストをオリジナルのコンテキストのコピーにセッ
   トしてそのコピーを返します。こうすることで, "with" 文の本体の内部で
   、外側のコードに影響を与えずに、 10進数コンテキストを変更できます。

contextmanager.__exit__(exc_type, exc_val, exc_tb)

   実行時コンテキストから抜け、例外 (がもし起こっていたとしても) を抑
   制することを示すブール値フラグを返します。 "with" 文の本体を実行中
   に例外が起こったならば、引数にはその例外の型と値とトレースバック情
   報を渡します。そうでなければ、引数は全て "None" です。

   このメソッドから真値が返されると "with" 文は例外の発生を抑え、
   "with" 文の直後の文に実行を続けます。そうでなければ、このメソッドの
   実行を終えると例外の伝播が続きます。このメソッドの実行中に起きた例
   外は "with" 文の本体の実行中に起こった例外を置き換えてしまいます。

   渡された例外を明示的に再送出すべきではありません。その代わりに、こ
   のメソッドが偽の値を返すことでメソッドの正常終了と送出された例外を
   抑制しないことを伝えるべきです。このようにすれば
   ("contextlib.nested" のような) コンテキストマネージャは
   "__exit__()" メソッド自体が失敗したのかどうかを簡単に見分けることが
   できます。

Python は幾つかのコンテキストマネージャを、易しいスレッド同期・ファイ
ルなどのオブジェクトの即時クローズ・単純化されたアクティブな10進算術コ
ンテキストのサポートのために用意しています。各型はコンテキスト管理プロ
トコルを実装しているという以上の特別の取り扱いを受けるわけではありませ
ん。例については "contextlib" モジュールを参照下さい。

Python のジェネレータ (*generator*) と "contextlib.contextmanager" デ
コレータ (*decorator*) はこのプロトコルの簡便な実装方法を提供します。
ジェネレータ関数を "contextlib.contextmanager" でデコレートすると、デ
コレートしなければ返されるイテレータを返す代わりに、必要な
"__enter__()" および "__exit__()" メソッドを実装したコンテキストマネー
ジャを返すようになります。

これらのメソッドのために Python/C API の中の Python オブジェクトの型構
造体に特別なスロットが作られたわけではないことに注意してください。これ
らのメソッドを定義したい拡張型はこれらを通常の Python からアクセスでき
るメソッドとして提供しなければなりません。実行時コンテキストを準備する
オーバーヘッドに比べたら、一回のクラス辞書の探索のオーバーヘッドは無視
できます。


5.12. その他の組み込み型
========================

インタプリタは、その他いくつかの種類のオブジェクトをサポートします。こ
れらのほとんどは 1 または 2 つの演算だけをサポートします。


5.12.1. モジュール
------------------

モジュールに対する唯一の特殊な演算は属性アクセス: "m.name" です。ここ
で *m* はモジュールで、 *name* は *m* のシンボルテーブル上に定義された
名前にアクセスします。モジュール属性に代入することもできます。 (なお、
"import" 文は、厳密にいえば、モジュールオブジェクトに対する演算ではあ
りません; "import foo" は *foo* と名づけられたモジュールオブジェクトの
存在を必要とはせず、*foo* と名づけられたモジュールの (外部の) *定義*
を必要とします。)

全てのモジュールにある特殊属性が "__dict__" です。これはモジュールのシ
ンボルテーブルを含む辞書です。この辞書を書き換えると実際にモジュールの
シンボルテーブルを変更することができますが、"__dict__" 属性を直接代入
することはできません ("m.__dict__['a'] = 1" と書いて "m.a" を "1" に定
義することはできますが、"m.__dict__ = {}" と書くことはできません)。
"__dict__" を直接書き換えることは推奨されません。

インタプリタ内に組み込まれたモジュールは、 "<module 'sys' (built-in)>"
のように書かれます。ファイルから読み出された場合、 "<module 'os' from
'/usr/local/lib/pythonX.Y/os.pyc'>" と書かれます。


5.12.2. クラスおよびクラスインスタンス
--------------------------------------

これらについては オブジェクト、値、および型 および クラス定義 を参照下
さい。


5.12.3. 関数
------------

関数オブジェクトは関数定義によって生成されます。関数オブジェクトに対す
る唯一の操作は、それを呼び出すことです: "func(argument-list)" 。

関数オブジェクトには実際には二種類あります: 組み込み関数とユーザ定義関
数です。どちらも同じ操作 (関数の呼び出し) をサポートしますが、実装は異
なるので、オブジェクトの型も異なります。

詳細は、 関数定義 を参照下さい。


5.12.4. メソッド
----------------

メソッドは属性表記を使って呼び出される関数です。メソッドには二種類あり
ます: (リストの "append()" のような) 組み込みメソッドと、クラスインス
タンスのメソッドです。組み込みメソッドは、それをサポートする型と一緒に
記述されています。

実装では、クラスインスタンスのメソッドに 2 つの読み込み専用の属性を追
加しています: "m.im_self" はメソッドが操作するオブジェクトで、
"m.im_func" はメソッドを実装している関数です。 "m(arg-1, arg-2, ...,
arg-n)" の呼び出しは、 "m.im_func(m.im_self, arg-1, arg-2, ...,
arg-n)" の呼び出しと完全に等価です。

クラスインスタンスメソッドには、メソッドがインスタンスからアクセスされ
るかクラスからアクセスされるかによって、それぞれ *バインド* (束縛) ま
たは *非バインド* (非束縛) があります。メソッドが非バインドメソッドの
場合、 "im_self" 属性は "None" になるため、呼び出す際には "self" オブ
ジェクトを明示的に第一引数として指定しなければなりません。この場合、
"self" は非バインドメソッドのクラス (またはそのサブクラス) のインスタ
ンスでなければならず、そうでなければ "TypeError" が送出されます。

関数オブジェクトと同じく、メソッドオブジェクトは任意の属性を取得できま
す。しかし、メソッド属性は実際には背後の関数オブジェクト
("meth.im_func") に記憶されているので、バインドメソッド、非バインドメ
ソッドへのメソッド属性の設定は許されていません。メソッドへの属性の設定
を試みると "AttributeError" が送出されます。メソッド属性を設定するため
には、その背後の関数オブジェクトで明示的にセットする必要があります:

   >>> class C:
   ...     def method(self):
   ...         pass
   ...
   >>> c = C()
   >>> c.method.whoami = 'my name is method'  # can't set on the method
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   AttributeError: 'instancemethod' object has no attribute 'whoami'
   >>> c.method.im_func.whoami = 'my name is method'
   >>> c.method.whoami
   'my name is method'

詳細は、 標準型の階層 を参照下さい。


5.12.5. コードオブジェクト
--------------------------

コードオブジェクトは、関数本体のような "擬似コンパイルされた" Python
の実行可能コードを表すために実装系によって使われます。コードオブジェク
トはグローバルな実行環境への参照を持たない点で関数オブジェクトとは異な
ります。コードオブジェクトは組み込み関数 "compile()" によって返され、
また関数オブジェクトの "func_code" 属性として取り出せます。 "code" モ
ジュールも参照下さい。

コードオブジェクトは、 "exec()" 文や組み込み関数 "eval()" に (ソース文
字列の代わりに) 渡すことで、実行や評価できます。

詳細は、 標準型の階層 を参照下さい。


5.12.6. 型オブジェクト
----------------------

型オブジェクトは様々なオブジェクト型を表します。オブジェクトの型は組み
込み関数 "type()" でアクセスされます。型オブジェクトには特有の操作はあ
りません。標準モジュール "types" には全ての組み込み型名が定義されてい
ます。

型はこのように書き表されます: "<type 'int'>" 。


5.12.7. ヌルオブジェクト
------------------------

このオブジェクトは明示的に値を返さない関数によって返されます。このオブ
ジェクトには特有の操作はありません。ヌルオブジェクトは一つだけで、
"None" (組み込み名) と名づけられています。

"None" と書き表されます。


5.12.8. Ellipsis オブジェクト
-----------------------------

このオブジェクトは拡張スライス表記によって使われます (スライス表記
(slicing) を参照下さい)。特殊な操作は何もサポートしていません。省略表
記オブジェクトは一つだけで、その名前は "Ellipsis" (組み込み名) です。

"Ellipsis" と書き表されます。添え字として使う場合 "..." とも書けます。
例えば "seq[...]" のように。


5.12.9. NotImplemented オブジェクト
-----------------------------------

このオブジェクトは、対応していない型の演算を求められたとき、比較や二項
演算から返されます。詳細は 比較 を参照してください。

"NotImplemented" と書き表されます。


5.12.10. ブール値
-----------------

ブール値は二つの定数オブジェクト "False" および "True" です。これらは
真理値を表すのに使われます (ただし他の値も偽や真とみなされます)。 数値
処理のコンテキスト (例えば算術演算子の引数として使われた場合) では、こ
れらはそれぞれ 0 および 1 と同様に振舞います。任意の値に対して、真理値
と解釈できる場合、組み込み関数 "bool()" は値をブール値に変換するのに使
われます (上述の 真理値判定 の節を参照してください)。

それぞれ "False" および "True" と書き表されます。


5.12.11. 内部オブジェクト
-------------------------

この情報は 標準型の階層 を参照下さい。スタックフレームオブジェクト、ト
レースバックオブジェクト、スライスオブジェクトについて記述されています
。


5.13. 特殊属性
==============

実装は、いくつかのオブジェクト型に対して、適切な場合には特殊な読み出し
専用の属性を追加します。そのうちいくつかは "dir()" 組込み関数で報告さ
れません。

object.__dict__

   オブジェクトの (書き込み可能な) 属性を保存するために使われる辞書ま
   たはその他のマッピングオブジェクトです。

object.__methods__

   バージョン 2.2 で非推奨: オブジェクトの属性からなるリストを取得する
   には、組み込み関数 "dir()" を使ってください。この属性はもう利用でき
   ません。

object.__members__

   バージョン 2.2 で非推奨: オブジェクトの属性からなるリストを取得する
   には、組み込み関数 "dir()" を使ってください。この属性はもう利用でき
   ません。

instance.__class__

   クラスインスタンスが属しているクラスです。

class.__bases__

   クラスオブジェクトの基底クラスのタプルです。

definition.__name__

   クラス、型、関数、メソッド、デスクリプタ、ジェネレータインスタンス
   の名前です。

以下の属性は、新スタイルクラス (*new-style class*) でのみサポートされ
ます。

class.__mro__

   この属性はメソッドの解決時に基底クラスを探索するときに考慮されるク
   ラスのタプルです。

class.mro()

   このメソッドは、メタクラスによって、そのインスタンスのメソッド解決
   の順序をカスタマイズするために、上書きされるかも知れません。このメ
   ソッドはクラスのインスタンス化時に呼ばれ、その結果は "__mro__" に格
   納されます。

class.__subclasses__()

   それぞれの新スタイルクラスは、それ自身の直接のサブクラスへの弱参照
   を保持します。このメソッドはそれらの参照のうち、生存しているものの
   リストを返します。例:

      >>> int.__subclasses__()
      [<type 'bool'>]

-[ 注記 ]-

[1] これらの特殊なメソッドのさらなる情報は、 Python リファレンスマ
    ニュ アル (基本的なカスタマイズ) を参照下さい。

[2] この結果として、リスト "[1, 2]" は "[1.0, 2.0]" と等しいと見な
    され ます。タプルの場合も同様です。

[3] パーザが演算対象の型を識別できるようにするために、このような優
    先順 位でなければならないのです。

[4] 大小文字の区別のある文字とは、一般カテゴリプロパティが "Lu"
    (Letter, uppercase (大文字))、 "Ll" (Letter, lowercase (小文字))、
    "Lt" (Letter、titlecase (先頭が大文字)) のいずれかであるものです。

[5] 従って、一個のタプルだけをフォーマット出力したい場合には出力し
    たい タプルを唯一の要素とする単一のタプルを *values* に与えなくて
    はなり ません。

[6] 改行を残す利点は、空の文字列が返ると EOF を示し、紛らわしくな
    くな るからです。また、ファイルの最後の行が改行で終わっているかそ
    うでな い (ありえることです!) か (例えば、ファイルを行単位で読みな
    がらそ の完全なコピーを作成した場合には問題になります) を調べるこ
    とができ ます。
