# 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, ...):
              ...

  `@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 は 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, ...):
              ...

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

  静的メソッドは (`C.f()` のよう) クラスから呼び出したり、 (`C().f()` のように) インスタンスから呼び出したりできます。

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

  静的メソッドについて詳しい情報は 標準型の階層 を参照してください。

  バージョン 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

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