2. 組み込み関数
***************

Python インタプリタは数多くの組み込み関数を持っていて、いつでも利用す
ることができます。それらの関数をアルファベット順に挙げます。

+---------------------+-------------------+--------------------+-------------------+----------------------+
|                     |                   | 組み込み関数       |                   |                      |
+=====================+===================+====================+===================+======================+
| "abs()"             | "divmod()"        | "input()"          | "open()"          | "staticmethod()"     |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "all()"             | "enumerate()"     | "int()"            | "ord()"           | "str()"              |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "any()"             | "eval()"          | "isinstance()"     | "pow()"           | "sum()"              |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "basestring()"      | "execfile()"      | "issubclass()"     | "print()"         | "super()"            |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "bin()"             | "file()"          | "iter()"           | "property()"      | "tuple()"            |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "bool()"            | "filter()"        | "len()"            | "range()"         | "type()"             |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "bytearray()"       | "float()"         | "list()"           | "raw_input()"     | "unichr()"           |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "callable()"        | "format()"        | "locals()"         | "reduce()"        | "unicode()"          |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "chr()"             | "frozenset()"     | "long()"           | "reload()"        | "vars()"             |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "classmethod()"     | "getattr()"       | "map()"            | "repr()"          | "xrange()"           |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "cmp()"             | "globals()"       | "max()"            | "reversed()"      | "zip()"              |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "compile()"         | "hasattr()"       | "memoryview()"     | "round()"         | "__import__()"       |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "complex()"         | "hash()"          | "min()"            | "set()"           |                      |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "delattr()"         | "help()"          | "next()"           | "setattr()"       |                      |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "dict()"            | "hex()"           | "object()"         | "slice()"         |                      |
+---------------------+-------------------+--------------------+-------------------+----------------------+
| "dir()"             | "id()"            | "oct()"            | "sorted()"        |                      |
+---------------------+-------------------+--------------------+-------------------+----------------------+

これらに加えて、今では不可欠なものとは考えることがなくなった 4 つの組
み込み関数があります: "apply()", "buffer()", "coerce()", "intern()" で
す。これらは 非必須組み込み関数 (Non-essential Built-in Functions)  セ
クションで説明しています。

abs(x)

   数値の絶対値を返します。引数として通常の整数、長整数、浮動小数点数
   をとることができます。引数が複素数の場合、その大きさ (magnitude) が
   返されます。

all(iterable)

   *iterable* の全ての要素が真ならば (もしくは *iterable* が空ならば)
   "True" を返します。以下のコードと等価です:

      def all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

   バージョン 2.5 で追加.

any(iterable)

   *iterable* のいずれかの要素が真ならば "True" を返します。*iterable*
   が空なら "False" を返します。以下のコードと等価です:

      def any(iterable):
          for element in iterable:
              if element:
                  return True
          return False

   バージョン 2.5 で追加.

basestring()

   この抽象型は、 "str" および "unicode" の スーパークラスです。 この
   型は呼び出したりインスタンス化したりはできませんが、オブジェクトが
   "str" や "unicode" の インスタンスであるかどうかを調べる際に利用で
   きます。 "isinstance(obj, basestring)" は "isinstance(obj, (str,
   unicode))" と等価です。

   バージョン 2.3 で追加.

bin(x)

   整数を二進文字列に変換します。結果は Python の式としても使える形式
   になります。 *x* が Python の "int" オブジェクトでない場合、整数値
   を返す "__index__()" メソッドが定義されていなければなりません。

   バージョン 2.6 で追加.

class bool([x])

   ブール値、即ち "True" または "False" のどちらかを返します。 *x* は
   標準の 真理値判定プロシージャ を用いて変換されます。 *x* が偽または
   省略されている場合、この関数は "False" を返します。それ以外の場合、
   "True" を返します。 "bool" クラスは "int" クラスの派生クラスです。
   "bool"  からさらに派生することはできません。ブール値のインスタンス
   は "False" と "True" のみです。

   バージョン 2.2.1 で追加.

   バージョン 2.3 で変更: 引数が与えられなかった場合、この関数は
   "False" を返します。

class bytearray([source[, encoding[, errors]]])

   新しいバイト配列を返します。 "bytearray" クラスは0 <= x < 256の範囲
   の整数からなる *mutable* なシーケンスです。 ミュータブルなシーケン
   ス型 に記述されている  *mutable*  なシーケンスに対する普通のメソッ
   ドの大半を備えています。また、 "str" 型が持つメソッドの大半も備えて
   います（文字列メソッド 参照）。

   オプションの *source* パラメタは、配列を異なる方法で初期化するのに
   使われます:

   * それが *unicode* なら、 *encoding* (と、オプションの *errors*)
     パ ラメタも与えなければなりません。このとき "bytearray()" は
     unicode を "unicode.encode()" でバイトに変換して返します。

   * これが *整数* なら、配列はそのサイズになり、null バイトで初期化
     さ れます。

   * これが *バッファ* インタフェースに適合するオブジェクトなら、そ
     の オブジェクトの読み込み専用バッファがバイト配列の初期化に使われ
     ま す。

   * これが *イテラブル* なら、それは範囲 "0 <= x < 256" 内の整数の
     イ テラブルであることが必要で、それらが配列の初期の内容になります
     。

   引数がなければ、長さ 0 の配列が生成されます。

   バージョン 2.6 で追加.

callable(object)

   引数 *object* が呼び出し可能オブジェクトであれば、 "True" を返しま
   す。そうでなければ、 "False" を返します。この関数が真を返しても
   *object* の呼び出しは失敗する可能性がありますが、偽を返した場合は決
   して成功することはありません。クラスは呼び 出し可能 (クラスを呼び出
   すと新しいインスタンスを返します) なことと、クラスのインスタンスが
   メソッド "__call__()" を持つ場合には呼び出しが可能なことに注意して
   ください。

chr(i)

   ASCII コードが整数 *i* となるような文字 1 字からなる文字列を返しま
   す。例えば、 "chr(97)" は文字列 "'a'" を返します。この関数は
   "ord()" の逆です。引数は [0..255] の両端を含む範囲内に収まらなけれ
   ばなりません; *i* が範囲外の値のときには "ValueError" が送出されま
   す。 "unichr()" も参照下さい。

classmethod(function)

   *function* のクラスメソッドを返します。

   クラスメソッドは、インスタンスメソッドが暗黙の第一引数としてインス
   タンスをとるように、第一引数としてクラスをとります。クラスメソッド
   を宣言するには、以下のイディオムを使います:

      class C(object):
          @classmethod
          def f(cls, arg1, arg2, ...):
              ...

   The "@classmethod" form is a function *decorator* -- see 関数定義
   for details.

   A class method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()").  The instance is ignored
   except for its class. If a class method is called for a derived
   class, the derived class object is passed as the implied first
   argument.

   Class methods are different than C++ or Java static methods. If you
   want those, see "staticmethod()".

   For more information on class methods, see 標準型の階層.

   バージョン 2.2 で追加.

   バージョン 2.4 で変更: 関数デコレータ構文を追加しました.

cmp(x, y)

   二つのオブジェクト *x* および *y* を比較し、その結果に従って整数を
   返します。戻り値は "x" < "y" のときには負、 "x == y" の時にはゼロ、
   "x > y" には厳密に正の値になります。

compile(source, filename, mode[, flags[, dont_inherit]])

   *source* をコードオブジェクト、もしくは、 AST オブジェクトにコンパ
   イルします。 コードオブジェクトは "exec" 文で実行したり、 "eval()"
   呼び出しで評価できます。 *source* は Unicode 文字列、 *Latin-1*  エ
   ンコードのバイト列、 AST オブジェクトのいずれでもかまいません。 AST
   オブジェクトへの、また、 AST オブジェクトからのコンパイルの方法は、
   "ast" モジュールのドキュメントを参照してください。

   *filename* 引数には、コードの読み出し元のファイルを与えなければなり
   ません; ファイルから読み出されるのでなければ、認識可能な値を渡して
   下さい ("'<string>'" が一般的に使われます)。

   *mode* 引数は、コンパイルされるコードの種類を指定します; *source*
   が一連の文から成るなら "'exec'" 、単一の式から成るなら "'eval'" 、
   単一の対話的文の場合 "'single'" です。(後者の場合、評価が "None" 以
   外である式文が印字されます)。

   オプション引数 *flags* および *dont_inherit* は、 *source* のコンパ
   イルにどの future 文 (**PEP 236** 参照) を作用させるかを制御します
   。どちらも与えらていない (または両方ともゼロ) ならば、 "compile()"
   を呼び出している側のコードで有効な future 文を有効にしてコードをコ
   ンパイルします。 *flags* が与えられていて、*dont_inherit* は与えら
   れていない (またはゼロ) ならば、それに加えて *flags* に指定された
   future 文が使われます。 *dont_inherit* がゼロでない整数ならば、
   *flags* の値そのものが使われ、コンパイルの呼び出して周辺で有効な
   future 文は無視されます。

   future 文はビットフィールドで指定されます。ビットフィールドはビット
   単位の OR を取ることで複数の文を指定することができます。特定の機能
   を指定するために必要なビットフィールドは、"__future__" モジュールの
   "_Feature" インスタンスにおける "compiler_flag" 属性で得られます。

   この関数は、コンパイルするソースが不正である場合 "SyntaxError" を、
   ソースがヌルバイトを含む場合 "TypeError" を送出します。

   Python コードをパースしてその AST 表現を得たいのであれば、
   "ast.parse()" を参照してください。

   注釈: 複数行に渡るコードの文字列を "'single'" や "'eval'" モード
     でコン パイルするとき、入力は一つ以上の改行文字で終端されなければ
     なりま せん。これは、 "code" モジュールで不完全な文と完全な文を検
     知しや すくするためです。

   バージョン 2.3 で変更: *flags* と *dont_inherit* 引数が追加されまし
   た。

   バージョン 2.6 で変更: AST オブジェクトのコンパイルをサポートしまし
   た。

   バージョン 2.7 で変更: Windows や Mac の改行文字を使えるようになり
   ました。また、 "'exec'" モードで改行文字は必要なくなりました。
   *optimize* パラメタを追加しました。

class complex([real[, imag]])

   値 *real* + *imag**1j の複素数を生成するか、文字列や数を複素数に変
   換します。第一引数が文字列なら、それが複素数と解釈され、この関数は
   第二引数無しで呼び出されなければなりません。第二引数は文字列であっ
   てはなりません。それぞれの引数は (複素数を含む) 任意の数値型です。
   *imag* が省略された場合、標準の値はゼロで、この関数は "int()",
   "long()" や "float()" のような数値変換関数としてはたらきます。両方
   の引数が省略された場合、 "0j" を返します。

   注釈: 文字列から変換するとき、その文字列は中央の "+" や "-" 演算
     子の周 りに空白を含んではなりません。例えば、"complex('1+2j')" は
     いいで すが、"complex('1 + 2j')" は "ValueError" を送出します。

   複素数型については 数値型 int, float, long, complex に説明がありま
   す。

delattr(object, name)

   "setattr()" の親戚です。引数はオブジェクトと文字列です。文字列はオ
   ブジェクトの属性のうち一つの名前でなければなりません。この関数は、
   オブジェクトが許すなら、指名された属性を削除します。例えば、
   "delattr(x, 'foobar')" は "del x.foobar" と等価です。

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

   新しい辞書を作成します。 "dict" オブジェクトは辞書クラスです。この
   クラスに関するドキュメンテーションは "dict" と マッピング型 ---
   dict を参照してください。

   他のコンテナについては、 ビルトインの "list", "set", "tuple" クラス
   および "collections" モジュールを参照してください。

dir([object])

   引数がない場合、現在のローカルスコープにある名前のリストを返します
   。引数がある場合、そのオブジェクトの有効な属性のリストを返そうと試
   みます。

   オブジェクトが "__dir__()" という名のメソッドを持つなら、そのメソッ
   ドが呼び出され、属性のリストを返さなければなりません。これにより、
   カスタムの "__getattr__()" や "__getattribute__()" 関数を実装するオ
   ブジェクトは、"dir()" が属性を報告するやり方をカスタマイズできます
   。

   オブジェクトが "__dir__()" を提供していない場合、定義されていればオ
   ブジェクトの "__dict__" 属性から、そして型オブジェクトから、情報を
   収集しようと試みます。結果のリストは完全であるとは限らず、また、カ
   スタムの "__getattr__()" を持つ場合、不正確になるかもしれません。

   デフォルトの "dir()" メカニズムは、完全というより最重要な情報を作成
   しようとするため、異なる型のオブジェクトでは異なって振る舞います:

   * オブジェクトがモジュールオブジェクトの場合、リストにはモジュー
     ル の属性の名前が含まれます。

   * オブジェクトが型オブジェクトやクラスオブジェクトの場合、リスト
     に はその属性と、再帰的にたどったその基底クラスの属性が含まれます
     。

   * それ以外の場合には、リストにはオブジェクトの属性名、クラス属性
     名 、再帰的にたどった基底クラスの属性名が含まれます。

   返されるリストはアルファベット順に並べられています。例えば:

   >>> import struct
   >>> dir()   # show the names in the module namespace
   ['__builtins__', '__doc__', '__name__', 'struct']
   >>> dir(struct)   # show the names in the struct module
   ['Struct', '__builtins__', '__doc__', '__file__', '__name__',
    '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
    'unpack', 'unpack_from']
   >>> class Shape(object):
           def __dir__(self):
               return ['area', 'perimeter', 'location']
   >>> s = Shape()
   >>> dir(s)
   ['area', 'perimeter', 'location']

   注釈: "dir()" は主に対話プロンプトでの使用に便利なように提供され
     ている ので、厳密性や一貫性を重視して定義された名前のセットという
     よりも 、むしろ興味を引くような名前のセットを返そうとします。また
     、この 関数の細かい動作はリリース間で変わる可能性があります。例え
     ば、引 数がクラスであるとき、メタクラス属性は結果のリストに含まれ
     ません 。

divmod(a, b)

   2 つの (複素数でない) 数値を引数として取り、整数の除法を行ったとき
   の商と剰余からなるペアを返します。被演算子が型混合である場合、 2 進
   算術演算子での規則が適用されます。通常の整数と長整数の場合、結果は
   "(a // b, a % b)" と同じです。浮動小数点数の場合、結果は "(q, a %
   b)" であり、 *q* は通常 "math.floor(a / b)" ですが、そうではなく 1
   になることもあります。いずれにせよ、 "q * b + a % b" は *a* に非常
   に近い値になり、 "a % b" がゼロでない値の場合、その符号は *b* と同
   じで、 "0 <= abs(a % b) < abs(b)" になります。

   バージョン 2.3 で変更: 複素数に対する "divmod()" の使用は廃用されま
   した。

enumerate(sequence, start=0)

   列挙オブジェクトを返します。 *sequence* はシーケンス型、イテレータ
   型、反復をサポートする他のオブジェクト型のいずれかでなければなりま
   せん。 "enumerate()" が返すイテレータの "next()" メソッドは、 (ゼロ
   から始まる) カウント値と、値だけ *sequence* を反復操作して得ら れる
   、対応するオブジェクトを含むタプルを返します。 "enumerate()" はイン
   デクス付けされた値の列: "(0, seq[0])", "(1, seq[1])", "(2,
   seq[2])", ... を得るのに便利です。 例

      >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
      >>> list(enumerate(seasons))
      [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
      >>> list(enumerate(seasons, start=1))
      [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

   次と等価です:

      def enumerate(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

   バージョン 2.3 で追加.

   バージョン 2.6 で変更: *start* 引数が追加されました。

eval(expression[, globals[, locals]])

   引数には、Unicode 文字列または *Latin-1*  エンコードのバイト文字列
   と、オプションの引数 *globals* 、 *locals* をとります。 *globals*
   を与える場合は辞書でなくてはなりません。 *locals* を与える場合は任
   意のマッピングオブジェクトにできます。

   バージョン 2.4 で変更: 以前は *locals* も辞書でなければなりませんで
   した.

   引数 *expression* は Python の表現式 (技術的にいうと、条件のリスト
   です) として構文解釈され、評価されます。このとき辞書 *globals* およ
   び *locals* はそれぞれグローバルおよびローカルな名前空間として使わ
   れます。 *global* 辞書が存在するが、 '__builtins__' が欠けている場
   合、 *expression* を解析する前に現在のグローバル変数を *globals* に
   コピーします。このことから、 *expression* は通常、標準の
   "__builtin__" モジュールへの完全なアクセスを有し、制限された環境が
   伝播するようになっています。 *locals* 辞書が省略された場合、標 準の
   値として *globals* に設定されます。辞書が両方とも省略された場合、
   表現式は "eval()" が呼び出されている環境の下で実行されます。 構文エ
   ラーは例外として報告されます。以下に例を示します :

   >>> x = 1
   >>> print eval('x+1')
   2

   この関数は ("compile()" で生成されるような) 任意のコードオブジェク
   トを実行するのにも利用できます。この場合、文字列の代わりにコードオ
   ブジェクトを渡します。このコードオブジェクトが、引数 *mode* を
   "'exec'" としてコンパイルされている場合、 "eval()" が返す値は
   "None" になります。

   ヒント: 文の動的な実行は "exec" 文でサポートされています。 ファイル
   からの文の実行は関数 "execfile()" でサポートされています。関数
   "globals()" および "locals()" は、それぞれ現在のグローバルおよびロ
   ーカルな辞書を返すので、 "eval()" や "execfile()" で使うことができ
   ます。

   リテラルだけを含む式の文字列を安全に評価できる関数、
   "ast.literal_eval()" も参照してください。

execfile(filename[, globals[, locals]])

   この関数は "exec" 文に似ていますが、文字列の代わりにファイルに対し
   て構文解釈を行います。 "import" 文と違って、モジュー ル管理機構を使
   いません --- この関数はファイルを無条件に読み込み、新 たなモジュー
   ルを生成しません。 [1]

   引数は、ファイル名と、2 つのオプショナルな辞書です。ファイルはパー
   スされて、(モジュールに対してそうするのと同じように) Python ステー
   トメントのシーケンスとして評価されます。この際 *globals* と
   *locals* がそれぞれグローバル名前空間、ローカル名前空間として使われ
   ます。 *locals* を指定する場合は何らかのマップ型オブジェクトでなけ
   ればなりません。モジュールレベルではグローバルとローカルは同じ辞書
   であることを忘れないで下さい。 *globals* と *locals* として別々にオ
   ブジェクトを渡す場合、コードはクラス定義に埋め込まれたかのように実
   行されます。

   バージョン 2.4 で変更: 以前は *locals* も辞書でなければなりませんで
   した.

   *locals* 辞書が省略された場合、標準の値として *globals* に設定され
   ます。辞書が両方とも省略された場合、表現式は "execfiles()" が呼び出
   されている環境の下で実行されます。戻り値は "None" です。

   注釈: 標準では *locals* は後に述べる関数 "locals()" のように動作
     します: 標準の *locals* 辞書に対する変更を試みてはいけません。
     "execfile()" の呼び出しが返る時にコードが *locals* に与える影響を
     知りたいなら、明示的に *loacals* 辞書を渡してください。
     "execfile()" は関数のローカルを変更するための信頼性のある方法とし
     て使うことはできません。

file(name[, mode[, buffering]])

   "file" 型のコンストラクタです。詳しくは ファイルオブジェクト 節を参
   照してください。コンストラクタの引数 は後述の "open()" 組み込み関数
   と同じです。

   ファイルを開くときは、このコンストラクタを直接呼ばずに "open()" を
   呼び出すのが望ましい方法です。 "file" は型テストにより適し ています
   (たとえば "isinstance(f, file)" と書くような)。

   バージョン 2.2 で追加.

filter(function, iterable)

   *iterable* のうち、 *function* が真を返すような要素からなるリストを
   構築します。 *iterable* はシーケンスか、反復をサポートするコンテナ
   か、イテレータです。 *iterable* が文字列型かタプル型の場合、結果も
   同じ型になります。そうでない場合はリストとなります。 *function* が
   "None" の場合、恒等関数を仮定します。すなわち、 *iterable* の偽とな
   る要素は除去されます。

   function が "None" ではない場合、 "filter(function, iterable)" は
   "[item for item in iterable if function(item)]" と同等です。
   function が "None" の場合 "[item for item in iterable if item]" と
   同等です。

   この関数のイテレータ版である "itertools.ifilter()" と
   "itertools.ifilterfalse()" についても参照して下さい、 変種として
   *function* が false を返す場合に要素を返す変種も含んでいます。

class float([x])

   数または文字列 *x* から生成された浮動小数点数を返します。

   引数が文字列の場合、十進の数または浮動小数点数を含んでいなければな
   りません。符号が付いていてもかまいません。また、空白文字中に埋め込
   まれていてもかまいません。引数は [+|-]nan 、 [+|-]inf であっても構
   いません。それ以外の場合、引数は通常整数、長整数、または浮動小数点
   数をとることができ、同じ値の浮動小数点数が (Python の浮動小数点精度
   で) 返されます。引数が指定されなかった場合、 0.0 を返します。

   注釈: 文字列で値を渡す際、背後の C ライブラリによって NaN および
     Infinity が返されるかもしれません。 float は文字列、 nan 、 inf
     、および -inf を、それぞれ、 NaN 、正の無限大、負の無限大として
     解釈します。大文字小文字の違い、 + 記号、および、 nan に対する -
     記号は無視されます。

   浮動小数点数型については、 数値型 int, float, long, complex も参照
   下さい。

format(value[, format_spec])

   *value* を *format_spec* で制御される "フォーマット化" 表現に変換し
   ます。 *format_spec* の解釈は *value* 引数の型に依存しますが、ほと
   んどの組み込み型で使われる標準的な構文が存在します: 書式指定ミニ言
   語仕様 。

   注釈: "format(value, format_spec)" は単に
     "value.__format__(format_spec)" を呼び出すだけです。

   バージョン 2.6 で追加.

class frozenset([iterable])

   新しい "frozenset" オブジェクトを返します。オプションで *iterable*
   から得られた要素を含みます。 "frozenset" はビルトインクラスです。こ
   のクラスに関するドキュメントは "frozenset" と set（集合）型 ---
   set, frozenset を参照してください。

   他のコンテナについては、ビルトインクラス "set", "list", "tuple",
   "dict" や "collections" モジュールを見てください。

   バージョン 2.4 で追加.

getattr(object, name[, default])

   *object* の指名された属性の値を返します。 *name* は文字列でなくては
   なりません。文字列がオブジェクトの属性の一つの名前であった場合、戻
   り値はその属性の値になります。例えば、 "getattr(x, 'foobar')" は
   "x.foobar" と等価です。指名された属性が存在しない場合、 *default*
   が与えられていればそれが返され、そうでない場合には "AttributeError"
   が送出されます。

globals()

   現在のグローバルシンボルテーブルを表す辞書を返します。これは常に現
   在のモジュール (関数やメソッドの中では、それを呼び出したモジュール
   ではなく、それを定義しているモジュール) の辞書です。

hasattr(object, name)

   引数はオブジェクトと文字列です。文字列がオブジェクトの属性名の一つ
   であった場合 "True" を、そうでない場合 "False" を返します (この 関
   数は "getattr(object, name)" を呼び出し、例外を送出するかどうか を
   調べることで実装されています)。

hash(object)

   オブジェクトのハッシュ値を (存在すれれば) 返します。ハッシュ値は整
   数です。これらは辞書を検索する際に辞書のキーを高速に比較するために
   使われます。等しい値となる数値は等しいハッシュ値を持ちます (1 と
   1.0 のように型が異なっていてもです)。

help([object])

   組み込みヘルプシステムを起動します。(この関数は対話的な使用のための
   ものです)。引数が与えられていない場合、対話的ヘルプシステムはインタ
   プリタコンソール上で起動します。引数が文字列の場合、文字列はモジュ
   ール、関数、クラス、メソッド、キーワード、またはドキュメントの項目
   名として検索され、ヘルプページがコンソール上に印字されます。引数が
   その他のオブジェクトの場合、そのオブジェクトに関するヘルプページが
   生成されます。

   この関数は、 "site" モジュールから、組み込みの名前空間に移されまし
   た。

   バージョン 2.2 で追加.

hex(x)

   (任意のサイズの) 整数を、先頭に "0x" が付いた小文字の16進数文字列に
   変換します。例えば:

   >>> hex(255)
   '0xff'
   >>> hex(-42)
   '-0x2a'
   >>> hex(1L)
   '0x1L'

   x が Python の "int" オブジェクトでも "long" オブジェクトでもない場
   合、文字列を返す "__hex__()" メソッドを定義していなければなりません
   。

   16を底として16進数文字列を整数に変換するには "int()" も参照してくだ
   さい。

   注釈: 浮動小数点数の16進文字列表記を得たい場合には、
     "float.hex()" メソ ッドを使って下さい。

   バージョン 2.4 で変更: 以前は符号なしのリテラルしか返しませんでした
   .

id(object)

   オブジェクトの "識別値" を返します。この値は整数 (または長整数) で
   、 このオブジェクトの有効期間は一意かつ定数であることが保証されてい
   ま す。 オブジェクトの有効期間が重ならない 2 つのオブジェクトは同じ
   "id()" 値を持つかもしれません。

   **CPython implementation detail:** This is the address of the
   object in memory.

input([prompt])

   "eval(raw_input(prompt))" と同じです。

   この関数はユーザエラーを捕捉しません。入力が構文的に正しくない場合
   、 "SyntaxError" が送出されます。式を評価する際にエラーが生じた場合
   、他の例外も送出されるかもしれません。

   "readline" モジュールが読み込まれていれば、 "input()" はそれを使っ
   て精緻な行編集やヒストリ機能を提供します。

   一般的なユーザからの入力のための関数としては "raw_input()" を使うこ
   とを検討してください。

class int(x=0)
class int(x, base=10)

   数値または文字列 *x* から生成された整数を返します。引数が与えられな
   い場合には "0" を返します。  *x* が数値である場合は、通常整数、長整
   数、または浮動小数点数を返します。浮動小数点数については、これは 0
   に向かう方向へ切り詰めます。引数が整数で通常整数の範囲外であれば、
   長整数を代わりに返します。

   *x* が数値でない場合、あるいは *base* が与えられた場合、 *x* は基数
   *base* の integer literal で表された、バイト文字列または Unicode 文
   字列、 のインスタンスでなければなりません。オプションで、リテラルの
   前に "+" あるいは "-" を (中間のスペースなしで) 付けることができま
   す。また、リテラルは余白で囲むことができます。基数 n のリテラルの各
   桁は 0 から n-1 の数を、値 10-35 を持つ "a" から "z" (または "A" か
   ら "Z") を含んで表現します。デフォルトの *base* は 10 です。許され
   る値は 0 と 2-36 です。基数 2, 8, 16 のリテラルは、オプションでコー
   ド中の整数リテラルのように  "0b"/"0B", "0o"/"0O"/"0", "0x"/"0X" を
   前に付けることができます。基数 0 を渡すと、文字列を、実際の基数 2,
   8, 10, 16 のどれかで整数リテラルとして正確に解釈します。

   整数型については、 数値型 int, float, long, complex も参照下さい。

isinstance(object, classinfo)

   引数 *object* が引数 *classinfo* のインスタンスであるか、 (直接また
   は間接的な、もしくは *virtual* の) サブクラスのインスタンスの場合に
   真を返します。また、 *classinfo* が型オブジェクト (新スタイルクラス
   ) であり、 *object* がその型のオブジェクトであるか、または、 (直接
   または間接的な、もしくは *virtual* の) サブクラスの場合にも真を返し
   ます。 *object* がクラスインスタンスや与えられた型のオブジェクトで
   ない場合、この関数は常に偽を返します。*classinfo* がクラスや型オブ
   ジェクトのタプル (あるいはそういったタプルを再帰的に含むタプル) の
   場合、 *object* がそれらクラスや型のいずれかのインスタンスであれば
   真を返します。 *classinfo* がクラス、型、クラスや型からなるタプル、
   そういったタプルが再帰構造をとっているタプルのいずれでもない場合、
   例外 "TypeError" が送出されます。

   バージョン 2.2 で変更: 型情報からなるタプルへのサポートが追加されま
   した。

issubclass(class, classinfo)

   *class* が *classinfo* の (直接または間接的な、あるいは *virtual*)
   サブクラスである場合に真を返します。クラスはそれ自身のサブクラスと
   みなされます。 *classinfo* はクラスオブジェクトからなるタプルでもよ
   く、この場合には *classinfo* のすべてのエントリが調べられます。その
   他の場合では、例外 "TypeError" が送出されます。

   バージョン 2.3 で変更: 型情報からなるタプルへのサポートが追加されま
   した。

iter(o[, sentinel])

   *iterator* (イテレータ)オブジェクトを返します。 2 つ目の引数がある
   かどうかで、最初の引数の解釈は非常に異なります。 2 つ目の引数 がな
   い場合、 *o* は反復プロトコル ("__iter__()" メソッド) か、シーケン
   ス型プロトコル (引数が "0" から開始する "__getitem__()" メソッド)
   をサポートする集合オブジェクトでなければなりません。これらのプロト
   コルが両方ともサポートされていない場 合、 "TypeError" が送出されま
   す。 2 つ目の引数 *sentinel* が与えられていれば、 *o* は呼び出し可
   能なオ ブジェクトでなければなりません。この場合に生成されるイテレー
   タは、 "next()" を呼ぶ毎に *o* を引数無しで呼び出します。返された値
   が *sentinel* と等しければ、 "StopIteration" が送出されます。そう
   でない場合、戻り値がそのまま返されます。

   "iter()" の2つめの形式の便利な使用法の一つは、ファイルの行を特定の
   行まで読み進めることです。以下の例では "readline()" が空文字列を返
   すまでファイルを読み進めます:

      with open('mydata.txt') as fp:
          for line in iter(fp.readline, ''):
              process_line(line)

   バージョン 2.2 で追加.

len(s)

   オブジェクトの長さ (要素の数) を返します。引数はシーケンス (文字列
   、バイト列、タプル、リスト、range 等) かコレクション (辞書、集合、
   凍結集合等) です。

class list([iterable])

   *iterable* の要素と同じ要素をもち、かつ順番も同じなリストを返します
   。 *iterable* はシーケンス、反復処理をサポートするコンテナ、あるい
   はイテレータオブジェクトです。 *sequence* がすでにリストの場合、
   "iterable[:]" と同様にコピーを作成して返します。 例えば、
   "list('abc')" は "['a', 'b', 'c']" および "list((1, 2, 3))" は "[1,
   2, 3]" を返します。引数が与えられなかった場合、新 しい空のリスト
   "[]" を返します。

   "list" は変更可能なシーケンス型であり、 シーケンス型 --- str,
   unicode, list, tuple, bytearray, buffer, xrange に記 述があります。
   他のコンテナ型については組み込み型の "dict", "set", および "tuple"
   クラスと、 "collections" モジュールを参照下さい。

locals()

   現在のローカルシンボルテーブルを表す辞書を更新して返します。関数ブ
   ロックで "locals()" を呼び出した場合自由変数が返されます、クラスブ
   ロックでは返されません。

   注釈: この辞書の内容は変更してはいけません; 変更しても、インタプ
     リタが 使うローカル変数や自由変数の値には影響しません。

class long(x=0)
class long(x, base=10)

   文字列または数値 *x* から長整数オブジェクトを構築して返します。引数
   が文字列の場合は、任意サイズの符号付の数を表していなければなりませ
   ん。空白で囲まれていても構いません。 *base* 引数は "int()" のものと
   同じように解釈され、また、 *x* が文字列の時だけ与えることができます
   。文字列以外の引数では通常整数、長整数、浮動小数点数を与えることが
   出来、同じ値としての長整数を返します。浮動小数点数から整数への変換
   では、(ゼロに向かう方向へ) 切り詰められます。引数が与えられなければ
   "0L" を返します。

   長整数型については、 数値型 int, float, long, complex も参照下さい
   。

map(function, iterable, ...)

   *function* を *iterable* の全ての要素に適用し、返された値からなるリ
   ストを返します。追加の *iterable* 引数を与えた場合、 *function* は
   それらを引数として取らなければならず、関数はそのリストの全ての要素
   について個別に適用されます; 他のリストより短いリストがある場合、要
   素 "None" で延長されます。 *function* が "None" の場合、恒等関 数で
   あると仮定されます; すなわち、複数のリスト引数が存在する場合、
   "map()" は全てのリスト引数に対し、対応する要素からなるタプルか らな
   るリストを返します (転置操作のようなものです)。 *list* 引数はど の
   ようなシーケンス型でもかまいません; 結果は常にリストになります。

max(iterable[, key])
max(arg1, arg2, *args[, key])

   iterable の中で最大の要素、または2つ以上の引数の中で最大のものを返
   します。

   キーワード無しの引数が 1 つだけ与えられた場合、 *iterable* は空でな
   い  (文字列、タプル、リストなどの) iterable でなくてはいけません。
   iterable の最大の要素が返されます。 2 つ以上のキーワード無しの引数
   が与えられた場合、その引数の中で最大のものが返されます。

   オプションの *key* 引数には "list.sort()" で使われるのと同じような
   1 引数の順序付け関数を指定します。 *key* を指定する場合はキーワード
   形式でなければなりません (たとえば "max(a,b,c,key=func)")。

   バージョン 2.5 で変更: オプションの *key* 引数が追加されました.

memoryview(obj)

   与えられたオブジェクトから作られた "メモリビュー" オブジェクトを返
   します。詳しくは メモリビュー型 を参照してください。

min(iterable[, key])
min(arg1, arg2, *args[, key])

   iterable の中で最小の要素、または2つ以上の引数の中で最小のものを返
   します。

   キーワード無しの引数が1つだけ与えられた場合、 *iterable* は空でない
   (文字列、タプル、リストなどの) iterable でなくてはいけません。
   iterable の最小の要素が返されます。 2 つ以上のキーワード無しの引数
   が与えられた場合、その引数の中で最小のものが返されます。

   オプションの *key* 引数には "list.sort()" で使われるのと同じような
   1 引数の順序付け関数を指定します。 *key* を指定する場合はキーワード
   形式でなければなりません (たとえば "min(a,b,c,key=func)")。

   バージョン 2.5 で変更: オプションの *key* 引数が追加されました.

next(iterator[, default])

   *iterator* から、 "next()" メソッドにより、次の要素を取得します。
   もし、 *default* が与えられると、イテレータが空である場合に、それが
   返されます。それ以外の場合は、 "StopIteration" が送出されます。

   バージョン 2.6 で追加.

class object

   ユーザ定義の属性やメソッドを持たない、新しいオブジェクトを返します
   。 "object()" は新スタイルのクラスの、基底クラスです。これは、新ス
   タイルのクラスのインスタンスに共通のメソッド群を持ちます。

   バージョン 2.2 で追加.

   バージョン 2.3 で変更: この関数はいかなる引数も受け付けません。以前
   は、引数を受理しましたが無視していました。

oct(x)

   (任意のサイズの) 整数を 8 進の文字列に変換します。結果は Python の
   式としても使える形式になります。

   バージョン 2.4 で変更: 以前は符号なしのリテラルしか返しませんでした
   .

open(name[, mode[, buffering]])

   ファイルを開いて、  ファイルオブジェクト にて説明される、 "file" オ
   ブジェクトを返します。もし、ファイルが開けないなら、 "IOError" が送
   出されます。ファイルを開くときは "file" のコンストラクタを直接呼ば
   ずに "open()" を使うのが望ましい方法です。

   最初の 2 つの引数は "stdio" の "fopen()" と同じです: *filename* は
   開きたいファイルの名前で、 *mode* はファイルをどのようにして開くか
   を指定します。

   最もよく使われる *mode* の値は、読み出しの "'r'" 、書き込み (ファイ
   ルがすでに存在すれば切り詰められます) の "'w'" 、追記書き込みの
   "'a'" です ( *いくつかの* Unix システムでは、 *全て* の書き込みが
   現在のファイルシーク位置に関係なくファイルの末尾に追加されます)。
   *mode* が省略された場合、標準の値は "'r'" になります。デフォルトで
   はテキストモードでファイルを開きます。 "'\n'" 文字は、プラットフォ
   ームでの改行の表現に変換されます。移植性を高めるために、バイナ リフ
   ァイルを開くときには、 *mode* の値に "'b'" を追加しなければなりませ
   ん。(バイナリファイルとテキストファイルを区別なく扱うようなシステム
   でも、ドキュメンテーションの代わりになるので便利です。) 他に *mode*
   に与えられる可能性のある値については後述します。

   オプションの *buffering* 引数は、ファイルのために必要とするバッファ
   のサイズを指定します: 0 は非バッファリング、1 は行単位バッファリン
   グ、その他の正の値は指定した値 (の近似値) の (バイト)サイズをもつバ
   ッファを使用することを意味します。 *buffering* の値が負の場合、シス
   テムの標準を使います。通常、tty 端末は行単位のバッファリングであり
   、その他のファイルは完全なバッファリングです。省略された場合、シス
   テムの標準の値が使われます。 [2]

   "'r+'", "'w+'", および "'a+'" はファイルを更新のために開きます (開
   いて読み書きします); "'w+'" はファイルがすでに存在すれば切り詰める
   ので注意してください。バイナリとテキストファイルを区別するシステム
   では、ファイルをバイナリモードで開くためには "'b'" を追加してくださ
   い; 区別しないシステムでは "'b'" は無視されます。

   標準の "fopen()" における *mode* の値に加えて、 "'U'" または "'rU'"
   を使うことができます。Python が *universal newlines* サポートを行っ
   ている (標準ではしています) 場合、ファイルがテキストファイルで開か
   れますが、行末文字として Unix における慣行である "'\n'" 、Macintosh
   における慣行である "'\r'" 、 Windows における慣行である "'\r\n'" の
   いずれを使うこともできます。これらの改行文字の外部表現はどれも、
   Python プログラムからは "'\n'" に見えます。 Python が *universal
   newlines* サポートなしで構築されている場合、 *mode* "'U'" は通常の
   テキストモードと同様になります。開かれたファイルオブジェクトはまた
   、 "newlines" と呼ばれる属性を持っており、その値は "None" (改行が見
   つからなかった場合)、 "'\n'", "'\r'", "'\r\n'", または見つかった全
   ての改行タイプを含むタプルになります。

   "'U'" を取り除いた後のモードは "'r'", "'w'", "'a'" のいずれかで始ま
   る、というのが Python における規則です。

   Python では、 "fileinput", "os", "os.path", "tempfile", "shutil" な
   どの多数のファイル操作モジュールが提供されています。

   バージョン 2.5 で変更: モード文字列の先頭についての制限が導入されま
   した.

ord(c)

   長さ 1 の与えられた文字列に対し、その文字列が unicode オブジェクト
   ならば Unicode コードポイントを表す整数を、 8 ビット文字列ならばそ
   のバイトの値を返します。たとえば、 "ord('a')" は整数 "97" を返し、
   "ord(u'\u2020')" は "8224" を返します。この値は 8 ビット文字列に対
   する "chr()" の逆であり、 unicode オブジェクトに対する "unichr()"
   の逆です。引数が unicode で Python が UCS2 Unicode 対応版ならば、そ
   の文字のコードポイントは両端を含めて [0..65535] の範囲に入っていな
   ければなりません。この範囲から外れると文字列の長さが 2 になり、
   "TypeError" が送出されることになります。

pow(x, y[, z])

   *x* の *y* 乗を返します; *z* があれば、*x* の *y* 乗に対する *z* の
   モジュロを返します ("pow(x, y) % z" より効率よく計算されます)。二引
   数の形式 "pow(x, y)" は、冪乗演算子を使った "x**y" と等価です。

   引数は数値型でなくてはなりません。型混合の場合、 2 進算術演算におけ
   る型強制規則が適用されます。通常整数、および、長整数の被演算子に対
   しては、二つ目の引数が負の数でない限り、結果は (型強制後の) 被演算
   子と同じ型になります; 負の場合、全ての引数は浮動小数点型に変換され
   、浮動小数点型の結果が 返されます。例えば、 "10**2" は "100" を返し
   ますが、 "10**-2" は "0.01" を返します。 (最後に述べた機能は Python
   2.2 で追加され たものです。 Python 2.1 以前では、双方の引数が整数で
   二つ目の値が負の場合、例外が送出されます。) 二つ目の引数が負の場合
   、三つめの引数 は無視されます。 *z* がある場合、 *x* および *y* は
   整数型でなければならず、 *y* は非負の値でなくてはなりません (この制
   限は Python 2.2 で追加されました。 Python 2.1 以前では、 3 つの浮動
   小数点引数を持つ "pow()" は浮動小数点の丸めに関する偶発誤差により、
   プラットフォー ム依存の結果を返します)。

print(*objects, sep=' ', end='\n', file=sys.stdout)

   *object* (複数でも可) を *sep* で区切りながらストリーム *file* に表
   示し、最後に *end* を表示します。 *sep*, *end* そして *file* が与え
   られる場合、キーワード引数として与えられる必要があります。

   キーワードなしの引数はすべて、 "str()" がするように文字列に変換され
   、 *sep* で区切られながらストリームに書き出され、最後に *end* が続
   きます。 *sep* と *end* の両方とも、文字列でなければなりません; ま
   たは "None" にすれば、デフォルトの値が使われます。 *objects* が与え
   られなければ、 "print()" は *end* だけを書き出します。

   *file* 引数は、 "write(string)" メソッドを持つオブジェクトでなけれ
   ばなりません。指定されないか、 "None" であった場合には、
   "sys.stdout" が使われます。出力のバッファリングは *file* により決定
   されます。たとえば即座に画面に現れて欲しければ、 "file.flush()" を
   使ってそれを保障してください。

   注釈: この関数は "print" という名前が "print" ステートメン トとし
     て解釈 されるため、通常は使用できません。ステートメントを無効化し
     て、 "print()" 関数を使うためには、以下の future ステートメントを
     モジ ュールの最初に書いて下さい。:

        from __future__ import print_function

   バージョン 2.6 で追加.

class property([fget[, fset[, fdel[, doc]]]])

   *new-style class* (新しい形式のクラス) ("object" から派生したクラス
   ) における property 属性を返します。

   *fget* は属性値を取得するための関数です。*fset* は属性値を設定する
   ための関数です。*fdel* は属性値を削除するための関数です。*doc* は属
   性の docstring を作成します。

   典型的な使用法は、属性 "x" の処理の定義です:

      class C(object):
          def __init__(self):
              self._x = None

          def getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "I'm the 'x' property.")

   *c* が *C* のインスタンスならば、"c.x" は getter を呼び出し、"c.x =
   value" は setter を、"del c.x" は deleter を呼び出します。

   *doc* は、与えられれば property 属性のドキュメント文字列になります
   。与えられなければ、 property は *fget* のドキュメント文字列(もしあ
   れば)をコピーします。そのため、 "property()" をデコレータ
   (*decorator*) として使えば、読み取り専用 property を作るのは容易で
   す:

      class Parrot(object):
          def __init__(self):
              self._voltage = 100000

          @property
          def voltage(self):
              """Get the current voltage."""
              return self._voltage

   "@property" デコレータは "voltage()" を同じ名前のまま 読み取り専用
   属性の "getter" にし、*voltage* のドキュメント文字列を "Get the
   current voltage." に設定します。

   property オブジェクトは "getter", "setter", "deleter" メソッドを持
   っています。これらのメソッドをデコレータとして使うと、対応するアク
   セサ関数がデコレートされた関数に設定された、 property のコピーを作
   成できます。これを一番分かりやすく説明する例があります:

      class C(object):
          def __init__(self):
              self._x = None

          @property
          def x(self):
              """I'm the 'x' property."""
              return self._x

          @x.setter
          def x(self, value):
              self._x = value

          @x.deleter
          def x(self):
              del self._x

   このコードは最初の例と等価です。追加の関数には、必ず元の property
   と同じ名前 (この例では "x") を与えて下さい。

   返される property オブジェクトも、コンストラクタの引数に対応した
   "fget", "fset", および "fdel" 属性を持ちます。

   バージョン 2.2 で追加.

   バージョン 2.5 で変更: *doc* が与えられない場合に *fget* のドキュメ
   ント文字列を使う。

   バージョン 2.6 で変更: "getter", "setter" そして "deleter" 属性が追
   加されました。

range(stop)
range(start, stop[, step])

   等差数列を含むリストを生成するための多機能関数です。 "for" ループで
   よく使われます。引数は通常の整数でなければなりません。 *step* 引数
   が無視された場合、標準の値 "1" になります。 *start* 引数が省 略され
   た場合、標準の値 "0" になります。完全な形式では、通常の整数列
   "[start, start + step, start + 2 * step, ...]" を返します。 *step*
   が正の値の場合、最後の要素は *stop* よりも小さい "start + i * step"
   の最大値になります; *step* が負の値の場合、最後の要素は *stop* より
   も大きい "start + i * step" の最小値になります。 *step* はゼロであ
   ってはなりません (さもなければ "ValueError" が送出されます)。以下に
   例を示します。:

   >>> range(10)
   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
   >>> range(1, 11)
   [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   >>> range(0, 30, 5)
   [0, 5, 10, 15, 20, 25]
   >>> range(0, 10, 3)
   [0, 3, 6, 9]
   >>> range(0, -10, -1)
   [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
   >>> range(0)
   []
   >>> range(1, 0)
   []

raw_input([prompt])

   引数 *prompt* が存在する場合、末尾の改行を除いて標準出力に出力され
   ます。次に、この関数は入力から 1 行を読み込んで文字列に変換して (末
   尾の改行を除いて) 返します。 EOF が読み込まれると "EOFError" が送出
   されます。以下に例を示します。:

      >>> s = raw_input('--> ')
      --> Monty Python's Flying Circus
      >>> s
      "Monty Python's Flying Circus"

   "readline" モジュールが読み込まれていれば、 "raw_input()" は精緻な
   行編集およびヒストリ機能を提供します。

reduce(function, iterable[, initializer])

   *iterable* の要素に対して、iterable を単一の値に短縮するような形で
   2 つの引数をもつ *function* を左から右に累積的に適用します。例えば
   、 "reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])" は
   "((((1+2)+3)+4)+5)" を計算します。左引数 *x* は累計の値になり、右引
   数 *y* は "iterable" から取り出した更新値になります。オプションの
   *initializer* が存在する場合、計算の際に iterable の先頭に置かれま
   す。また、 iterable が空の場合には標準の値になります。
   *initializer* が与えられておらず、 *iterable* が単一の要素しか持っ
   ていない場合、最初の要素が返されます。これは大体以下と等価です:

      def reduce(function, iterable, initializer=None):
          it = iter(iterable)
          if initializer is None:
              try:
                  initializer = next(it)
              except StopIteration:
                  raise TypeError('reduce() of empty sequence with no initial value')
          accum_value = initializer
          for x in it:
              accum_value = function(accum_value, x)
          return accum_value

reload(module)

   すでにインポートされた *module* を再解釈し、再初期化します。引数は
   モジュールオブジェクトでなければならないので、予めインポートに成功
   していなければなりません。この関数はモジュールのソースコードファイ
   ルを外部エディタで編集して、Python インタプリタから離れることなく新
   しいバージョンを試したい際に有効です。戻り値は (*module* 引数と同じ
   ) モジュールオブジェクトです。

   "reload(module)" を実行すると、以下の処理が行われます:

   * Python モジュールのコードは再コンパイルされ、モジュールレベルの
     コ ードは再度実行されます。モジュールの辞書中にある、何らかの名前
     に 結び付けられたオブジェクトを新たに定義します。拡張モジュール中
     の "init" 関数が二度呼び出されることはありません。

   * Python における他のオブジェクトと同様、以前のオブジェクトのメモ
     リ 領域は、参照カウントがゼロにならないかぎり再利用されません。

   * モジュール名前空間内の名前は新しいオブジェクト (または更新され
     た オブジェクト) を指すよう更新されます。

   * 以前のオブジェクトが (外部の他のモジュールなどからの) 参照を受
     け ている場合、それらを新たなオブジェクトに再束縛し直すことはない
     の で、必要なら自分で名前空間を更新しなければなりません。

   いくつか補足説明があります:

   モジュールが再ロードされた際、その辞書 (モジュールのグローバル変数
   を含みます) はそのまま残ります。名前の再定義を行うと、以前の定義を
   上書きするので、一般的には問題はありません。新たなバージョンのモジ
   ュールが古いバージョンで定義された名前を定義していない場合、古い定
   義がそのまま残ります。辞書がグローバルテーブルやオブジェクトのキャ
   ッシュを維持していれば、この機能をモジュールを有効性を引き出すため
   に使うことができます --- つまり、 "try" 文を使えば、必要に応じてテ
   ーブルがあるかどうかをテストし、その初期化を飛ばすことができます:

      try:
          cache
      except NameError:
          cache = {}

   組み込みモジュールや動的にロードされるモジュールを再ロードすること
   は、一般的にそれほど便利ではありません。 "sys", "__main__",
   "builtins" やその他重要なモジュールの再ロードはお勧め出来ません。多
   くの場合、拡張モジュールは 1 度以上初期化されるようには設計されてお
   らず、再ロードされた場合には何らかの理由で失敗するかもしれません。

   一方のモジュールが "from" ... "import" ... を使って、オブジェクトを
   他方のモジュールからインポートしているなら、他方のモジュールを
   "reload()" で呼び出しても、そのモジュールからインポートされたオブジ
   ェクトを再定義することはできません --- この問題を回避する一つの方法
   は、 "from" 文を再度実行することで、もう一つの方法は "from" 文の代
   わりに "import" と限定的な名前 (*module*.*name*) を使うことです。

   あるモジュールがクラスのインスタンスを生成している場合、そのクラス
   を定義しているモジュールの再ロードはそれらインスタンスのメソッド定
   義に影響しません --- それらは古いクラス定義を使い続けます。これは派
   生クラスの場合でも同じです。

repr(object)

   オブジェクトの印字可能な表現を含む文字列を返します。これは型変換で
   得られる (逆クオートの) 値と同じです。通常の関数としてこの操作にア
   クセスできるとたまに便利です。この関数は多くの型について、 "eval()"
   に渡されたときに同じ値を持つようなオブジェクトを表す文字列を生成し
   ようとします。そうでない場合は、角括弧に囲まれたオブジェクトの型の
   名前と追加の情報 (大抵の場合はオブジェクトの名前とアドレスを含みま
   す) を返します。クラスは、 "__repr__()" メソッドを定義することで、
   この関数によりそのクラスのインスタンスが返すものを制御することがで
   きます。

reversed(seq)

   要素を逆順に取り出すイテレータ (reverse *iterator*) を返します。
   *seq* は "__reversed__()" メソッドを持つか、シーケンス型プロトコル
   ("__len__()" メソッド、および、 "0" 以上の整数を引数とする
   "__getitem__()" メソッド) をサポートするオブジェクトでなければなり
   ません。

   バージョン 2.4 で追加.

   バージョン 2.6 で変更: カスタムの "__reversed__()" メソッドが使える
   ようになりました。

round(number[, ndigits])

   *number* を小数点以下 *ndigits* 桁で丸めた浮動小数点数の値を返しま
   す。 *ndigits* が省略されると、デフォルトはゼロになります。結果は浮
   動小数点数です。値は最も近い 10 のマイナス *ndigits* 乗の倍数に丸め
   られます。二つの倍数との距離が等しい場合、ゼロから離れる方向に丸め
   られます (従って、例えば "round(0.5)" は "1.0" になり、
   "round(-0.5)" は "-1.0" になります)。

   注釈: 浮動小数点数に対する "round()" の振る舞いは意外なものかもし
     れませ ん: 例えば、 "round(2.675, 2)" は予想通りの "2.68" ではな
     く "2.67" を与えます。これはバグではありません: これはほとんどの
     小数 が浮動小数点数で正確に表せないことの結果です。詳しくは 浮動
     小数点 演算、その問題と制限 を参照してください。

class set([iterable])

   オプションで *iterable* の要素を持つ、新しい "set" オブジェクトを返
   します。 "set" は組み込みクラスです。このクラスについて詳しい情報は
   "set" や set（集合）型 --- set, frozenset を参照してください。

   他のコンテナについては "collections" モジュールや組み込みの
   "frozenset" 、 "list" 、 "tuple" 、 "dict" クラスを参照してください
   。

   バージョン 2.4 で追加.

setattr(object, name, value)

   "getattr()" の相方です。引数はオブジェクト、文字列、それから任意の
   値です。文字列は既存の属性または新たな属性の名前にできます。この関
   数は指定したオブジェクトが許せば、値を属性に関連付けます。例えば、
   "setattr(x, 'foobar', 123)" は "x.foobar = 123" と等価です。

class slice(stop)
class slice(start, stop[, step])

   "range(start, stop, step)" で指定されるインデクスの集合を表す、スラ
   イス (*slice*) オブジェクトを返します。引数 *start* および *step*
   はデフォルトでは "None" です。スライスオブジェクトは読み出し専用の
   属性 "start"、"stop" および "step" を持ち、これらは単に引数で使われ
   た 値 (またはデフォルト値) を返します。これらの値には、その他のはっ
   きりと した機能はありません。しかしながら、これらの値は Numerical
   Python および、その他のサードパーティによる拡張で利用されています。
   スライスオブジェクトは拡張されたインデクス指定構文が使われる際にも
   生成されます。例えば "a[start:stop:step]" や "a[start:stop, i]" で
   す。この関数の代替となるイテレータを返す関数、"itertools.islice()"
   も参照してください。

sorted(iterable[, cmp[, key[, reverse]]])

   *iterable* の要素を並べ替えた新たなリストを返します。

   オプション引数 *cmp*, *key*, および *reverse* の意味は
   "list.sort()" メソッドと同じです。 (ミュータブルなシーケンス型 節に
   説明があります。)

   *cmp* は2つの引数 (iterable の要素) からなるカスタムの比較関数を指
   定します。 これは始めの引数が 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()" を使用してください。

   組み込みの "sort()" 関数は安定なことが保証されています。同等な要素
   の相対順序を変更しないことが保証されていれば、ソートは安定です。こ
   れは複数のパスでソートを行なうのに役立ちます（例えば部署でソートし
   てから給与の等級でソートする場合）。

   ソートの例と簡単なチュートリアルは ソート HOW TO を参照して下さい。

   バージョン 2.4 で追加.

staticmethod(function)

   *function* の静的メソッドを返します。

   静的メソッドは暗黙の第一引数を受け取りません。静的メソッドを宣言す
   るには、このイディオムを使ってください:

      class C(object):
          @staticmethod
          def f(arg1, arg2, ...):
              ...

   The "@staticmethod" form is a function *decorator* -- see 関数定義
   for details.

   A static method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()").

   Python における静的メソッドは Java や C++ における静的メソッドと類
   似しています。クラスコンストラクタの代替を生成するのに役立つ変種、
   "classmethod()" も参照してください。

   For more information on static methods, see 標準型の階層.

   バージョン 2.2 で追加.

   バージョン 2.4 で変更: 関数デコレータ構文を追加しました.

class str(object='')

   オブジェクトをうまく印字可能な形に表現したものを含む文字列を返しま
   す。文字列に対してはその文字列自体を返します。 "repr(object)" との
   違いは、 "str(object)" は常に "eval()" が受理できるような文字列を返
   そうと試みるわけではないという点です; この関数の目的は印字可能な文
   字列を返すところにあります。引数が与えられなかった場合、空の文字列
   "''" を返します。

   文字列についての詳細は、シーケンスの機能についての説明、 シーケンス
   型 --- str, unicode, list, tuple, bytearray, buffer, xrange を参照
   下さい(文字列はシーケンスです)。 また、文字列特有のメソッドについて
   は、 文字列メソッド を参照下さい。整形した文字列を出力するためには
   、テンプレート文字列か、 文字列フォーマット操作 にて説明される "%"
   演算子を使用して下さい。さらには、 文字列処理 と "unicode()" も参照
   下さい。

sum(iterable[, start])

   *start* と *iterable* の要素を左から右へ合計し、総和を返します。
   *start* はデフォルトで "0" です。 *iterable* の要素は通常は数値で、
   start の値は文字列であってはなりません。

   使う場面によっては、 "sum()" よりもいい選択肢があります。文字列から
   なるシーケンスを結合する高速かつ望ましい方法は "''.join(sequence)"
   を呼ぶことです。浮動小数点数値を拡張された精度で加算するには、
   "math.fsum()" を参照下さい。一連のイテラブルを連結するには、
   "itertools.chain()" の使用を考えてください。

   バージョン 2.3 で追加.

super(type[, object-or-type])

   メソッドの呼び出しを *type* の親または兄弟クラスに委譲するプロキシ
   オブジェクトを返します。これはクラスの中でオーバーライドされた継承
   メソッドにアクセスするのに便利です。探索の順序は、 *type* 自身が飛
   ばされるのをのぞいて "getattr()" で使われるのと同じです。

   *type* の "__mro__" 属性は、 "getattr()" と "super()" の 両方で使わ
   れる、メソッド解決の探索順序を列記します。 この属性は動的で、継承の
   階層構造が更新されれば、随時変化します。

   第 2 引数が省かれたなら、返されるスーパーオブジェクトは束縛されませ
   ん。第 2 引数がオブジェクトであれば、 "isinstance(obj, type)" は真
   でなければなりません。第 2 引数が型であれば、 "issubclass(type2,
   type)" は真でなければなりません (これはクラスメソッドに役に立つでし
   ょう)。

   注釈: "super()" は *new-style class* に対してのみ動作します。

   *super* の典型的な用途は 2 つあります。単一の継承をしているクラス階
   層構造では、 *super* は名前を明示することなく親クラスを参照するのに
   使え、これでコードはメンテナンスしやすくなります。この用途の
   *super* は他のプログラミング言語で見られるものと近い方向性です。

   2 つ目の用途は、動的な実行環境下での複数の継承の共同をサポートする
   ことです。この用途は Python 特有で、静的にコンパイルされる言語や、
   単一の継承しかサポートしない言語では見られないものです。これは複数
   の基底クラスが同じメソッドを実装する "diamond diagram" を実装できる
   ようにします。良い設計のために、このメソッドがすべての場合に同じ形
   式で呼び出せるべきです (呼び出しの順序が実行時に決定されることや、
   順序がクラスの階層の変更に対応することや、その順序には実行時まで未
   知の兄弟クラスが含まれえることが理由です)。

   両方のケースにおいて、典型的なスーパークラスの呼び出しはこのように
   なるでしょう。

      class C(B):
          def method(self, arg):
              super(C, self).method(arg)

   なお、"super()" は "super().__getitem__(name)" のような明示的なドッ
   ト表記属性探索の束縛処理の一部として使うように実装されています。こ
   れは、 "__getattribute__()" メソッドを予測可能な順序でクラスを検索
   するように実装し、協調的な多重継承をサポートすることで実現されてい
   ます。従って、 "super()" は "super()[name]" のような文や演算子を使
   った暗黙の探索向けには定義されていません。

   また、 "super()" の使用がメソッド内部に限定されないことにも注目して
   下さい。引数を2つ渡す形式の呼び出しは、必要な要素を正確に指定するの
   で、 適当な参照を作ることができます。

   "super()" を用いて協調的なクラスを設計する方法の実践的な提案は、
   guide to using super() を参照してください。

   バージョン 2.2 で追加.

tuple([iterable])

   *iterable* の要素と要素が同じで、かつ順番も同じになるタプルを返しま
   す。 *iterable* はシーケンス型、反復をサポートするコンテナ型、およ
   びイテレータオブジェクトをとることができます。 *iterable* がすでに
   タプルの場合、そのタプルを変更せずに返します。 例えば、
   "tuple('abc')" は "('a', 'b', 'c')" を返し、 "tuple([1, 2, 3])" は
   "(1, 2, 3)" を返します。

   "tuple" クラスは、不変のシーケンス型で、 シーケンス型 --- str,
   unicode, list, tuple, bytearray, buffer, xrange にて説明されます。
   他のコンテナ型については、組み込みクラスの "dict", "list", および
   "set" と、 "collections" モジュールを参照下さい。

class type(object)
class type(name, bases, dict)

   一つの引数を取り、 *object* の型を返します。戻り値は型オブジェクト
   です。オブジェクトの型の検査には "isinstance()" 組み込み関数を使う
   ことが推奨されます。

   引数が 3 つの場合、新しい型オブジェクトを返します。本質的には
   "class" 文の動的な形式です。 *name* 文字列はクラス名で、 "__name__"
   属性になります。 *bases* タプルは基底クラスの羅列で、 "__bases__"
   属性になります。 *dict* 辞書はクラス本体の定義を含む名前空間で、
   "__dict__" 属性になります。たとえば、以下の二つの文は同じ "type" オ
   ブジェクトを作ります:

   >>> class X(object):
   ...     a = 1
   ...
   >>> X = type('X', (object,), dict(a=1))

   バージョン 2.2 で追加.

unichr(i)

   Unicode におけるコードが整数 *i* になるような文字 1 文字からなる
   Unicode 文字列を返します。例えば、 "unichr(97)" は文字列 "u'a'" を
   返します。この関数は Unicode 文字列に対する "ord()" の逆です。 引数
   の正当な範囲は Python がどのように構成されているかに依存しています
   --- UCS2 ならば [0..0xFFFF] であり UCS4 ならば [0..0x10FFFF] であり
   、このどちらかです。それ以外の値に対しては "ValueError" が送出され
   ます。ASCII の 8 ビットの文字列に対しては、 "chr()" を参照下さい。

   バージョン 2.0 で追加.

unicode(object='')
unicode(object[, encoding[, errors]])

   以下のモードのうち一つを使って、 *object* の Unicode 文字列バージョ
   ンを返します:

   もし *encoding* かつ/または *errors* が与えられていれば、
   "unicode()" は 8 ビットの文字列または文字列バッファになっているオ
   ブジェクトを *encoding* の codec を使ってデコードします。
   *encoding* 引数はエンコーディング名を与える文字列です; 未知のエンコ
   ーディングの場合、 "LookupError" が送出されます。エラー処理は
   *errors* に従って行われます; このパラメータは入力エンコーディング中
   で無効な文字の扱い方を指定します。 *errors* が "'strict'" (標準の設
   定です) の場合、エラー発生時には "ValueError" が送出されます。一方
   、 "'ignore'" では、エラーは暗黙のうちに無視されるようになり、
   "'replace'" では公式の置換文字、 "U+FFFD" を使って、デコードできな
   かった文字を置き換えます。 "codecs" モジュールについても参照してく
   ださい。

   オプションのパラメータが与えられていない場合、 "unicode()" は
   "str()" の動作をまねます。ただし、8 ビット文字列ではなく、 Unicode
   文字列を返します。もっと詳しくいえば、 *object* が Unicode 文字列か
   そのサブクラスなら、デコード処理を一切介することなく Unicode 文字列
   を返すということです。

   "__unicode__()" メソッドを提供しているオブジェクトの場合、
   "unicode()" はこのメソッドを引数なしで呼び出して Unicode 文字列を生
   成します。それ以外のオブジェクトの場合、 8 ビットの文字列か、オ ブ
   ジェクトのデータ表現 (representation) を呼び出し、その後デフォルト
   エンコーディングで "'strict'" モードの codec を使って Unicode 文字
   列に変換します。

   Unicode 文字列についてのさらなる情報については、シーケンス型の機能
   についての説明、 シーケンス型 --- str, unicode, list, tuple,
   bytearray, buffer, xrange を参照下さい(Unicode 文字列はシー ケンス
   です)。また、文字列特有のメソッドについては、 文字列メソッド を参照
   下さい。整形した文字列を出力するために は、テンプレート文字列か、
   文字列フォーマット操作 にて説明される "%" 演算子を使用して下さい。
   さらには、 文字列処理 と "str()" も参照下さい。

   バージョン 2.0 で追加.

   バージョン 2.2 で変更: "__unicode__()" のサポートが追加されました.

vars([object])

   モジュール、クラス、インスタンス、あるいはそれ以外の "__dict__" 属
   性を持つオブジェクトの、 "__dict__" 属性を返します。

   モジュールやインスタンスのようなオブジェクトには、更新可能な
   "__dict__" 属性があります。しかし、それ以外のオブジェクトでは
   "__dict__" 属性への書き込みに制限があるかもしれません。(例えば新ス
   タイルクラスは、辞書を直接更新されることを防ぐために dictproxy を使
   っています。)

   引数がなければ、"vars()" は "locals()" のように振る舞います。ただし
   、辞書 locals への更新は無視されるため、辞書 locals は読み出し時の
   み有用であることに注意してください。

xrange(stop)
xrange(start, stop[, step])

   この関数は "range()" に非常によく似ていますが、リストの代わりに
   XRange 型 を返します。このオブジェクトは不透明なシーケンス型で、対
   応するリストと同じ値を持ちますが、それらの値全てを同時に記憶しませ
   ん。 "ragne()" に対する "xrange()" の利点は微々たるものです
   ("xrange()" は要求に応じて値を生成するからです) ただし、メモリ量の
   厳しい計算機で巨大な範囲の値を使う時や、(ループがよく "break" で中
   断されるといったように) 範囲中の全ての値を使うとは限らない場合はそ
   の限りではありません。xrange オブジェクトについてのさらに詳しい情報
   については、 XRange 型 と シーケンス型 --- str, unicode, list,
   tuple, bytearray, buffer, xrange を参照して下さい。

   "xrange()" はシンプルさと速度のために定義されている関数であり、その
   実現のために実装上の制限を課している場合があります。 Python の C 実
   装では、全ての引数をネイティブの C long 型 (Python の "short" 整数
   型) に制限しており、要素数がネイティブの C long 型の範囲内に収まる
   よう要求しています。もし大きな範囲が必要ならば、別の実装である
   "itertools" モジュールの、 "islice(count(start, step), (stop-
   start+step-1+2*(step<0))//step)" を使うのが巧い方法かも知れません。

zip([iterable, ...])

   この関数はタプルのリストを返します。このリストの *i* 番目のタプルは
   各引数のシーケンスまたはイテレート可能オブジェクト中の *i* 番目の要
   素を含みます。 返されるリストは引数のシーケンスのうち長さが最小のも
   のの長さに切り詰められます。引数が全て同じ長さの際には、 "zip()" は
   初期値引数が "None" の "map()" と似ています。引数が単一のシーケンス
   の場合、1 要素のタプルからなるリストを返します。引数を指定しない場
   合、空のリストを返します。

   イテラブルの左から右への評価順序が保証されます。そのため
   "zip(*[iter(s)]*n)" を使ってデータ系列を n 長のグループにクラスタリ
   ングできます。

   "zip()" に続けて "*" 演算子を使うと、zip したリストを元に戻せます:

      >>> x = [1, 2, 3]
      >>> y = [4, 5, 6]
      >>> zipped = zip(x, y)
      >>> zipped
      [(1, 4), (2, 5), (3, 6)]
      >>> x2, y2 = zip(*zipped)
      >>> x == list(x2) and y == list(y2)
      True

   バージョン 2.0 で追加.

   バージョン 2.4 で変更: これまでは、 "zip()" は少なくとも一つの引数
   を要求しており、空のリストを返す代わりに "TypeError" を送出していま
   した。

__import__(name[, globals[, locals[, fromlist[, level]]]])

   注釈: これは "importlib.import_module()" とは違い、日常の Python
     プログ ラミングでは必要ない高等な関数です。

   この関数は "import" ステートメントにより呼び出されます。これは
   ("__builtin__" モジュールをインポートし、 "__builtin__.__import__"
   を割り当てることで) "import" ステートメントの意味を変更するための置
   き換えが可能ですが、今では、フックをインポートするほうが、大抵の場
   合簡単です (**PEP 302** を参照下さい)。 "__import__()" を直接使用す
   ることは稀で、例外は、実行時に名前が決定するモジュールをインポート
   するときです。

   この関数は、モジュール *name* をインポートし、 *globals* と
   *locals* が与えられれば、パッケージのコンテキストで名前をどう解釈す
   るか決定するのに使います。 *fromlist* は *name* で与えられるモジュ
   ールからインポートされるべきオブジェクトまたはサブモジュールの名前
   を与ます。標準の実装では *locals* 引数はまったく使われず、
   *globals* は "import" 文のパッケージコンテキストを決定するためにの
   み使われます。

   *level* は絶対、もしくは、相対のどちらのインポートを使うかを指定し
   ます。デフォルトは "-1" で絶対、相対インポートの両方を試みます。
   "0" は絶対インポートのみ実行します。正の *level* の値は、
   "__import__()" を呼び出したディレクトリから検索対象となる親ディレク
   トリの階層を示します。

   *name* 変数が "package.module" 形式であるとき、通常は、*name* で指
   名されたモジュール *ではなく*、最上位のパッケージ (最初のドットまで
   の名前) が返されます。しかしながら、空でない *fromlist* 引数が与え
   られると、 *name* で指名されたモジュールが返されます。

   例えば、文 "import spam" は、以下のコードのようなバイトコードに帰結
   します:

      spam = __import__('spam', globals(), locals(), [], -1)

   文 "import spam.ham" は、この呼び出しになります:

      spam = __import__('spam.ham', globals(), locals(), [], -1)

   ここで "__import__()" がどのように最上位モジュールを返しているかに
   注意して下さい。 "import" 文により名前が束縛されたオブジェクトにな
   っています。

   一方で、文 "from spam.ham import eggs, sausage as saus" は、以下と
   なります

      _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], -1)
      eggs = _temp.eggs
      saus = _temp.sausage

   ここで、"__import__()" から "spam.ham" モジュールが返されます。この
   オブジェクトから、インポートされる名前が取り出され、それぞれの名前
   として代入されます。

   単純に名前からモジュール (パッケージの範囲内であるかも知れません)
   をインポートしたいなら、 "importlib.import_module()" を使ってくださ
   い。

   バージョン 2.5 で変更: level パラメータが追加されました。

   バージョン 2.5 で変更: Keyword サポートパラメータが追加されました。


3. 非必須組み込み関数 (Non-essential Built-in Functions)
********************************************************

いくつかの組み込み関数は、現代的な Python プログラミングを行う場合には
、必ずしも学習したり、知っていたり、使ったりする必要がなくなりました。
こうした関数は古いバージョンの Python 向け書かれたプログラムとの互換性
を維持するだけの目的で残されています。

Python のプログラマ、教官、学生、そして本の著者は、こうした関数を飛ば
してもかまわず、その際に何か重要なことを忘れていると思う必要もありませ
ん。

apply(function, args[, keywords])

   引数 *function* は呼び出しができるオブジェクト (ユーザ定義および組
   み込みの関数またはメソッド、またはクラスオブジェクト) でなければな
   りません。 *args* はシーケンス型でなくてはなりません。 *function*
   は引数リスト *args* を使って呼び出されます; 引数の数はタプルの長さ
   になります。オプションの引数 *keywords* を与 える場合、 *keywords*
   は文字列のキーを持つ辞書でなければなりません。 これは引数リストの最
   後に追加されるキーワード引数です。 "apply()" の呼び出しは、単なる
   "function(args)" の呼び出しとは異なります。というのは、 "apply()"
   の場合、引数は常に一つだからです。 "apply()" は "function(*args,
   **keywords)" を使うのと等価です。

   バージョン 2.3 で非推奨: "apply(function, args, keywords)" ではなく
   "function(*args, **keywords)" を使ってください  (引数リストのアンパ
   ック 参照)。

buffer(object[, offset[, size]])

   引数 *object* は (文字列、アレイ、バッファといった) バッファ呼び出
   しインタフェースをサポートするオブジェクトでなければなりません。引
   数 *object* を参照する新たなバッファオブジェクトが生成されます。 返
   されるバッファオブジェクトは *object* の先頭 (または *offset*) から
   のスライスになります。スライスの末端は *object* の末端まで (または
   引数 *size* で与えられた長さになるまで) です。

coerce(x, y)

   二つの数値型の引数を共通の型に変換して、変換後の値からなるタプルを
   返します。変換に使われる規則は算術演算における規則と同じです。型変
   換が不可能である場合、 "TypeError" を送出します。

intern(string)

   *string* を "隔離" された文字列のテーブルに入力し、隔離された文字列
   を返します -- この文字列は *string* 自体かコピーです。隔離された文
   字列は辞書検索のパフォーマンスを少しだけ向上させるのに有効です --
   辞書中のキーが隔離されており、検索するキーが隔離されている場合、(ハ
   ッシュ化後の) キーの比較は文字列の比較ではなくポインタの比較で行う
   ことができるからです。通常、Python プログラム内で利用されている名前
   は自動的に隔離され、モジュール、クラス、またはインスタンス属性を保
   持するための辞書は隔離されたキーを持っています。

   バージョン 2.3 で変更: 隔離された文字列の有効期限は (Python 2.2 ま
   たはそれ以前は永続的でしたが) 永続的ではなくなりました; "intern()"
   の恩恵を受けるためには、 "intern()" の返す値に対する参照を保持しな
   ければなりません。

-[ 脚注 ]-

[1] この関数は比較的利用されない関数なので、構文になるかどうかは保
    証で きません。

[2] 現状では、 "setvbuf()" を持っていないシステムでは、バッファサ
    イズ を指定しても効果はありません。バッファサイズを指定するための
    インタ フェースは "setvbuf()" を使っては行われていません。何らかの
    I/O が 実行された後で呼び出されるとコアダンプすることがあり、どの
    ような場 合にそうなるかを決定する信頼性のある方法がないからです。

[3] 現在の実装では、ローカルな値のバインディングは通常は影響を受け
    ませ んが、 (モジュールのような) 他のスコープから取り出した値は影
    響を受 けるかもしれません。またこの実装は変更されるかもしれません
    。
