### ナビゲーション

- 索引
- モジュール |
- 次へ |
- 前へ |
- Python 2.7ja1 documentation »
- Python 標準ライブラリ »

# 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()` | `apply()`
`delattr()` | `help()` | `next()` | `setattr()` | `buffer()`
`dict()` | `hex()` | `object()` | `slice()` | `coerce()`
`dir()` | `id()` | `oct()` | `sorted()` | `intern()`

`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 で追加.

`bool`([x])

  標準の真値テストを使って、値をブール値に変換します。 x が偽か省略された場合、 `False` を返します; そうでなければ `True` を返します。 `bool` はクラスでもあり、 `int` のサブクラスになります。 `bool` クラスはそれ以上サブクラス化できません。このクラスのインスタンスは `False` および `True` だけです。

  バージョン 2.2.1 で追加.

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

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

  新しいバイトの配列を返します。 `bytearray` 型は範囲 0 <= x < 256 の整数のミュータブルなシーケンスです。これは、 変更可能なシーケンス型 で書かれているような、ミュータブルなシーケンスの通常のメソッドのほとんどを持ちますし、 文字列メソッド にあるような、 `str` 型が持つメソッドのほとんども持っています。

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

  - これが 文字列 なら、 encoding (と、オプションの errors) パラメタも与えなければなりません。このとき `bytearray()` は文字列を `str.encode()` でバイト列に変換して返します。
  - これが 整数 なら、配列はそのサイズになり、null バイトで初期化されます。
  - これが バッファ インタフェースに適合するオブジェクトなら、そのオブジェクトの読み込み専用バッファがバイト配列の初期化に使われます。
  - これが イテラブル なら、それは範囲 `0 <= x < 256` 内の整数のイテラブルであることが必要で、それらが配列の初期の内容になります。

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

`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:
          @classmethod
          def f(cls, arg1, arg2, ...): ...

  `@classmethod` は関数 decorator (デコレータ)形式です。詳しくは 関数定義 の関数定義についての説明を参照してください。

  このメソッドはクラスで呼び出すこと (例えば C.f() ) も、インスタンスとして呼び出すこと (例えば C().f()) もできます。インスタンスはそのクラスが何であるかを除いて無視されます。クラスメソッドが派生クラスに対して呼び出された場合、派生したクラスオブジェクトが暗黙の第一引数として渡されます。

  クラスメソッドは C++ や Java における静的メソッドとは異なります。そのような機能を求めているなら、 `staticmethod()` を参照してください。

  クラスメソッドについてさらに情報が必要ならば、 標準型の階層 の型階層の項を参照下さい。

  バージョン 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 は、文字列と AST オブジェクトのどちらでもかまいません。 AST オブジェクトへの、また、 AST オブジェクトからのコンパイルの方法は、 `_ast` モジュールのドキュメントを参照下さい。

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

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

  オプションの引数 flags および dont_inherit (Python 2.2 で新たに追加) は、 string のコンパイル時にどの future 文 (PEP 236 参照) の影響を及ぼすかを制御します。どちらも省略した場合 (または両方ともゼロの場合)、コンパイルを呼び出している側のコードで有効になっている future 文の内容を有効にして string をコンパイルします。 flags が指定されていて、かつ dont_inherit が指定されていない (またはゼロ) の場合、上の場合に加えて flags に指定された future 文を使います。 dont_inherit がゼロでない整数の場合、 flags の値そのものを使い、この関数呼び出し周辺での future 文の効果は無視します。

  future 文はビットで指定され、互いにビット単位の論理和を取って複数の文を指定できます。ある機能を指定するために必要なビットフィールドは、 `__future__` モジュールの `_Feature` インスタンスにおける `compiler_flag` 属性で得られます。

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

  ノート

  複数行に渡るコードの文字列を `'single'` や `'eval'` モードでコンパイルするとき、入力は少なくともひとつの改行文字で終端されなければなりません。これは `code` モジュールで、文が不完全か完全かをわかりやすくするためです。

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

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

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

`complex`([real[, imag]])

  値 real + imag*j の複素数型数を生成するか、文字列または数値を複素数型に変換します。最初の引数が文字列の場合、文字列を複素数として変換します。この場合関数は二つ目の引数無しで呼び出さなければなりません。二つ目の引数は文字列であってはなりません。それぞれの引数は (複素数を含む) 任意の数値型をとることができます。 imag が省略された場合、標準の値はゼロで、関数は `int()` 、 `long()` および `float()` のような数値型への変換関数として動作します。全ての引数が省略された場合、 `0j` を返します。

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

`delattr`(object, name)

  `setattr()` の親戚となる関数です。引数はオブジェクトと文字列です。文字列はオブジェクトの属性のどれか一つの名前でなければなりません。この関数は与えられた名前の属性を削除しますが、オブジェクトがそれを許す場合に限ります。例えば、 `delattr(x, 'foobar')` は `del x.foobar` と等価です。

`dict`([arg])

  新しい辞書型データを作成します。オプションとして引数 arg が与えることができます。辞書型については、 マップ型 に説明があります。

  他のコンテナについては、組み込みクラスの `list` 、 `set` 、 `tuple` 、および、モジュールの `collections` を参照下さい。

`dir`([object])

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

  もし、オブジェクトが `__dir__()` メソッドを持つなら、このメソッドが呼び出され、属性のリストを必ず返します。これにより、 `dir()` がオブジェクトの属性を返す方法をカスタマイズするために、 `__getattr__()` や `__getattribute__()` といったカスタム関数を実装することができます。

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

  デフォルトの `dir()` メカニズムの振る舞いは、異なる型のオブジェクトでは、異なります。それは、完全というよりは、より関連のある情報を生成しようとするためです。

  - オブジェクトがモジュールオブジェクトの場合、リストにはモジュール属性の名前が含まれます。
  - オブジェクトが型オブジェクトやクラスオブジェクトの場合、リストにはそれらの属性が含まれ、かつそれらの基底クラスの属性も再帰的にたどられて含まれます。
  - それ以外の場合には、リストにはオブジェクトの属性名、クラス属性名、再帰的にたどった基底クラスの属性名が含まれます。

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

      >>> import struct
      >>> dir()   # doctest: +SKIP
      ['__builtins__', '__doc__', '__name__', 'struct']
      >>> dir(struct)   # doctest: +NORMALIZE_WHITESPACE
      ['Struct', '__builtins__', '__doc__', '__file__', '__name__',
       '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
       'unpack', 'unpack_from']
      >>> class Foo(object):
      ...     def __dir__(self):
      ...         return ["kan", "ga", "roo"]
      ...
      >>> f = Foo()
      >>> dir(f)
      ['ga', 'kan', 'roo']

  ノート

  `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()` メソッドは、 (ゼロから始まる) カウント値と、値だけ iterable を反復操作して得られる、対応するオブジェクトを含むタプルを返します。 `enumerate()` はインデクス付けされた値の列: `(0, seq[0])`, `(1, seq[1])`, `(2, seq[2])`, ... を得るのに便利です。例 :

      >>> for i, season in enumerate(['Spring', 'Summer', 'Fall', 'Winter']):
      ...     print i, season
      0 Spring
      1 Summer
      2 Fall
      3 Winter

  バージョン 2.3 で追加.

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

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

  文字列とオプションの引数 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 つの辞書からなります。 file は読み込まれ、 (モジュールのように) Python 文の列として評価されます。このとき globals および locals がそれぞれグローバル、および、ローカルな名前空間として使われます。 locals は任意のマップ型に指定できます。

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

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

  ノート

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

`file`(filename[, mode[, bufsize]])

  `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 を返す場合に要素を返す変種も含んでいます。

`float`([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 Specification Mini-Language) 。

  ノート

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

  バージョン 2.6 で追加.

`frozenset`([iterable])

  `frozenset` オブジェクトを返します。オプションで iterable から要素を取得します。 frozenset 型については、 set（集合）型 — set, frozenset も参照下さい。

  他のコンテナ型については、組み込みクラスの `dict`, `list`, および , `tuple` と、 `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)

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

  ノート

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

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

`id`(object)

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

`input`([prompt])

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

  警告

  この関数はユーザのエラーに対して安全ではありません ! この関数は、入力は有効な Python の式であると期待しています; 入力が構文的に正しくない場合、 `SyntaxError` が送出されます。式を評価する際にエラーが生じた場合、他の例外も送出されるかもしれません。 (一方、この関数はまさに、ときどき熟練者がすばやくスクリプトを書く際に必要とするものです)

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

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

`int`([x[, base]])

  文字列または数値を通常の整数に変換します。引数が文字列の場合、 Python 整数として表現可能な十進の数でなければなりません。符号が付いていてもかまいません。また、空白文字中に埋め込まれていてもかまいません。 base 引数は変換の基数 (デフォルト値は10です) を表し、範囲 [2, 36] の整数またはゼロをとることができます。 base がゼロの場合、文字列の内容から適切な基数を推測します; 変換は整数リテラルと同じです (数値リテラル を参照下さい) 。 base が指定されており、 x が文字列でない場合、 `TypeError` が送出されます。それ以外の場合、引数は通常整数、長整数、または浮動小数点数をとることができます。浮動小数点数から整数へ変換では (ゼロ方向に) 値を丸めます。引数が通常整数の範囲を超えている場合、長整数が代わりに返されます。引数が与えられなかった場合、 `0` を返します。

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

`isinstance`(object, classinfo)

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

  バージョン 2.2 で変更: 型情報をタプルにした形式のサポートが追加されました。

`issubclass`(class, classinfo)

  class が classinfo の (直接または間接的な) サブクラスである場合に真を返します。クラスはそれ自身のサブクラスとみなされます。 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の形式の便利に応用できます。以下の例では `"STOP"` にたどりつくまでファイルを読みます:

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

  バージョン 2.2 で追加.

`len`(s)

  オブジェクトの長さ (要素の数) を返します。引数はシーケンス型 (文字列、タプル、またはリスト) か、マップ型 (辞書) です。

`list`([iterable])

  iterable の要素と同じ要素をもち、かつ順番も同じなリストを返します。 sequence はシーケンス、反復処理をサポートするコンテナ、あるいはイテレータオブジェクトです。 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()` を呼び出した場合自由変数が返されます、クラスブロックでは返されません。

  ノート

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

`long`([x[, base]])

  文字列または数値を長整数値に変換します。引数が文字列の場合、 Python 整数として表現可能な十進の数でなければなりません。符号が付いていてもかまいません。また、空白文字中に埋め込まれていてもかまいません。 base 引数は `int()` と同じように解釈され、 x が文字列の時だけ与えることができます。それ以外の場合、引数は通常整数、長整数、または浮動小数点数をとることができ、同じ値の長整数が返されます。浮動小数点数から整数へ変換では (ゼロ方向に) 値を丸めます。引数が与えられなかった場合、 `0L` を返します。

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

`map`(function, iterable, ...)

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

`max`(iterable[, args...][key])

  引数が iterable だけの場合、空でないシーケンス (文字列、タプルまたはリスト) の要素のうち最大のものを返します。 1 個よりも引数が多い場合、引数間で最大のものを返します。

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

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

`memoryview`(obj)

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

`min`(iterable[, args...][key])

  引数が iterable だけの場合、空でないシーケンス (文字列、タプルまたはリスト) の要素のうち最小のものを返します。 1 個よりも引数が多い場合、引数間で最小のものを返します。

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

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

`next`(iterator[, default])

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

  バージョン 2.6 で追加.

`object`()

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

  バージョン 2.2 で追加.

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

`oct`(x)

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

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

`open`(filename[, mode[, bufsize]])

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

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

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

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

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

  標準の `fopen()` における mode の値に加えて、 `'U'` または `'rU'` を使うことができます。 Python が全改行文字サポートを行っている (標準ではしています) 場合、ファイルがテキストファイルで開かれますが、行末文字として Unix における慣行である `'\n'` 、Macintosh における慣行である `'\r'` 、 Windows における慣行である `'\r\n'` のいずれを使うこともできます。これらの改行文字の外部表現はどれも、 Python プログラムからは `'\n'` に見えます。 Python が全改行文字サポートなしで構築されている場合、 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`([object, ...][, sep=' '][, end='\n'][, file=sys.stdout])

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

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

  file 引数は、 `write(string)` メソッドを持つオブジェクトでなければなりません。指定されないか、 `None` であった場合には、 `sys.stdout` が使われます。

  ノート

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

      from __future__ import print_function

  バージョン 2.6 で追加.

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

  new-style class (新しい形式のクラス) (`object` から派生したクラス) におけるプロパティ属性を返します。

  fget は属性値を取得するための関数で、同様に fset は属性値を設定するための関数です。また、 fdel は属性を削除するための関数です。以下に属性 `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 がもし与えられたならばそれがプロパティ属性のドキュメント文字列になります。与えられない場合、プロパティは fget のドキュメント文字列(もしあれば)をコピーします。これにより、読み取り専用プロパティを `property()` を decorator (デコレータ)として使って容易に作れるようになります。:

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

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

  のようにすると、 `voltage()` が同じ名前の読み取り専用属性の “getter” になります。

  プロパティオブジェクトは `getter`, `setter`, および `deleter` メソッドを備えています。これらのメソッドは属性のコピーを生成するデコレータに適していて、デコレートした関数を対応する属性参照関数に割り当てます。これを説明するには、以下の例が最適でしょう。:

      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

  このコードは、最初の例と等価です。追加の関数に、元々の属性と同じ名前 (この例では、 `x` です) を与えることに注意して下さい。

  返される属性も、コンストラクタの引数を反映した、 `fget`, `fset`, そして `fdel` 属性を持ちます。

  バージョン 2.2 で追加.

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

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

`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` モジュールが読み込まれていれば、 `input()` は精緻な行編集およびヒストリ機能を提供します。

`reduce`(function, iterable[, initializer])

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

`reload`(module)

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

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

  - Python モジュールのコードは再コンパイルされ、モジュールレベルのコードは再度実行されます。モジュールの辞書中にある、何らかの名前に結び付けられたオブジェクトを新たに定義します。拡張モジュール中の `init` 関数が二度呼び出されることはありません。
  - Python における他のオブジェクトと同様、以前のオブジェクトのメモリ領域は、参照カウントがゼロにならないかぎり再利用されません。
  - モジュール名前空間内の名前は新しいオブジェクト (または更新されたオブジェクト) を指すよう更新されます。
  - 以前のオブジェクトが (外部の他のモジュールなどからの) 参照を受けている場合、それらを新たなオブジェクトに再束縛し直すことはないので、必要なら自分で名前空間を更新せねばなりません。

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

  モジュールは文法的に正しいが、その初期化には失敗した場合、そのモジュールの最初の `import` 文はモジュール名をローカルにはバインドしませんが、(部分的に初期化された) モジュールオブジェクトを `sys.modules` に記憶します。従って、そのモジュールをロードしなおすには、 `reload()` する前にまず `import` (モジュールの名前を部分的に初期化されたオブジェクトにバインドします) を再度行わなければなりません。

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

      try:
          cache
      except NameError:
          cache = {}

  組み込みモジュールや動的にロードされるモジュールを再ロードすることは、不正なやり方ではありませんが、一般的にそれほど便利ではありません。例外は `sys`, `__main__` および `__builtin__` です。しかしながら、多くの場合、拡張モジュールは 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`(x[, n])

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

  ノート

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

`set`([iterable])

  新しいセット型オブジェクトを返します。オプションで iterable からとった要素を持たせることもできます。 set 型については、 set（集合）型 — set, frozenset に説明があります。

  他のコンテナについては、組み込みクラスの `dict`, `list`, および `tuple` クラス、および、 `collections` モジュールを参照下さい。

  バージョン 2.4 で追加.

`setattr`(object, name, value)

  `getattr()` と対をなす関数です。引数はそれぞれオブジェクト、文字列、そして任意の値です。文字列はすでに存在する属性の名前でも、新たな属性の名前でもかまいません。この関数は指定した値を指定した属性に関連付けますが、指定したオブジェクトにおいて可能な場合に限ります。例えば、 `setattr(x, 'foobar', 123)` は `x.foobar = 123` と等価です。

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

  `range(start, stop, step)` で指定されるインデクスの集合を表すスライス(slice)オブジェクトを返します。 `range(start)` スライスオブジェクトを返します。引数 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()` を使用してください。

  並ベ替えの例と簡潔なチュートリアルとして、 Sorting HowTo を参照して下さい。

  バージョン 2.4 で追加.

`staticmethod`(function)

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

  静的メソッドは暗黙の第一引数を受け取りません。静的メソッドの宣言は、以下のように書き慣わされます:

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

  `@staticmethod` は関数 decorator (デコレータ)形式です。詳しくは 関数定義 の関数定義についての説明を参照してください。

  このメソッドはクラスで呼び出すこと (例えば C.f() ) も、インスタンスとして呼び出すこと (例えば C().f()) もできます。インスタンスはそのクラスが何であるかを除いて無視されます。

  Python における静的メソッドは Java や C++ における静的メソッドと類似しています。より進んだ概念については、 `classmethod()` を参照してください。

  もっと静的メソッドについての情報が必要ならば、 標準型の階層 の標準型階層についてのドキュメントを繙いてください。

  バージョン 2.2 で追加.

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

`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()` の使用を考えてください。

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

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

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

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

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

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

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

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

  `super()` は `super(C, self).__getitem__(name)` のような明示的なドット表記による属性参照の一部として使うように実装されていることに注意して下さい。これは、 `__getattribute__()` メソッドを、協調的な多重継承をサポートするための予測可能な順序でクラスを検索するように実装することで実現されています。従って、 `super()` は `super()[name]` のような文や演算子を使った非明示的な属性参照向けには定義されていないので注意してください。

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

  バージョン 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` モジュールを参照下さい。

`type`(object)

  object の型を返します。オブジェクトの型の検査には `isinstance()` 組み込み関数を使うことが推奨されます。

  3 引数で呼び出された場合には `type()` 関数は後述するようにコンストラクタとして働きます。

`type`(name, bases, dict)

  新しい型オブジェクトを返します。本質的には `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[, 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])

  引数無しでは、 `locals()` のように動作します。

  モジュール、クラス、またはクラスインスタンスオブジェクト (またはその他 `__dict__` 属性を持つもの) を引数として与えた場合、その属性を返します。

  ノート

  返される辞書は変更すべきではありません: 変更が対応するシンボルテーブルにもたらす影響は未定義です。 [3]

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

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

  CPython implementation detail: `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 要素のタプルからなるリストを返します。引数を指定しない場合、空のリストを返します。

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

  `*` 演算子と共の論理積に対して、リストを upzip するために `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]]]])

  ノート

  これは日々の 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

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

  単純にモジュールをインポートする場合(パッケージの範囲内であるかも知れません)、 `__import__()` を呼び出して、 `sys.modules` から見付けることもできます。

      >>> import sys
      >>> name = 'foo.bar.baz'
      >>> __import__(name)
      <module 'foo' from >
      >>> baz = sys.modules[name]
      >>> baz
      <module 'foo.bar.baz' from >

  バージョン 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 で撤廃: `*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] | 現在の実装では、ローカルな値のバインディングは通常は影響を受けませんが、 (モジュールのような) 他のスコープから取り出した値は影響を受けるかもしれません。またこの実装は変更されるかもしれません。

### ナビゲーション

- 索引
- モジュール |
- 次へ |
- 前へ |
- Python 2.7ja1 documentation »
- Python 標準ライブラリ »