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

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

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

abs(x)

   数の絶対値を返します。引数は整数または浮動小数点数です。引数が複素
   数なら、その絶対値 (magnitude) が返されます。

all(iterable)

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

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

any(iterable)

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

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

ascii(object)

   "repr()" と同様、オブジェクトの印字可能な表現を含む文字列を返します
   が、"repr()" によって返された文字列中の非 ASCII 文字は "\x" 、 "\u"
   、 "\U" エスケープを使ってエスケープされます。これは Python 2 の
   "repr()" によって返されるのと同じ文字列を作ります。

bin(x)

   整数を先頭に "0b" が付いた 2 進文字列に変換します。 結果は Python
   の式としても使える形式になります。

   >>> bin(3)
   '0b11'
   >>> bin(-10)
   '-0b1010'

   先頭に "0b" が付いて欲しい、もしくは付いて欲しくない場合には、次の
   方法のどちらでも使えます。

   >>> format(14, '#b'), format(14, 'b')
   ('0b1110', '1110')
   >>> f'{14:#b}', f'{14:b}'
   ('0b1110', '1110')

   より詳しいことは "format()" も参照してください。

class bool([x])

   ブール値、即ち "True" または "False" のどちらかを返します。*x* は標
   準の 真理値判定手続き を用いて変換されます。*x* が偽または省略され
   ている場合、この関数は "False" を返します。それ以外の場合、"True"
   を返します。"bool" クラスは "int" クラスの派生クラスです(数値型
   int, float, complex を参照してください)。このクラスからさらに派生す
   ることはできません。ブール値のインスタンスは "False" と "True" のみ
   です(ブール値 を参照してください)。

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

   新しいバイト配列を返します。"bytearray" クラスは0 <= x < 256の範囲
   の整数からなる変更可能な配列です。ミュータブルなシーケンス型 に記述
   されている変更可能な配列に対する普通のメソッドの大半を備えています
   。また、"bytes" 型が持つメソッドの大半も備えています（see bytes と
   bytearray の操作)。

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

   * *文字列* の場合、 *encoding* (と、オプションの *errors*) 引数も
     与 えなければなりません。このとき "bytearray()" は文字列を
     "str.encode()" でバイトに変換して返します。

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

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

   * *イテラブル* の場合、範囲 "0 <= x < 256" 内の整数のイテラブルで
     な ければならず、それらが配列の初期の内容として使われます。

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

   バイナリシーケンス型 --- bytes, bytearray, memoryview と bytearray
   オブジェクト も参照してください。

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

   範囲 "0 <= x < 256" の整数のイミュータブルなシーケンスである
   "bytes" オブジェクトを返します。 "bytes" は "bytearray" のイミュー
   タブル版です。オブジェクトを変化させないようなメソッドや、インデク
   シングやスライシングのふるまいは、これと同様のものです。

   従って、コンストラクタ引数は "bytearray()" のものと同様に解釈されま
   す。

   バイト列オブジェクトはリテラルでも生成できます。 文字列およびバイト
   列リテラル を参照してください。

   バイナリシーケンス型 --- bytes, bytearray, memoryview, バイトオブジ
   ェクト, bytes と bytearray の操作 も参照してください。

callable(object)

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

   バージョン 3.2 で追加: この関数は Python 3.0 で一度取り除かれました
   が、Python 3.2 で復活しました。

chr(i)

   Unicode コードポイントが整数 *i* である文字を表す文字列を返します。
   例えば "chr(97)" は文字列 "'a'" を、 "chr(8364)" は文字列 "'€'" を
   返します。 "ord()" の逆です。

   引数の有効な範囲は 0 から 1,114,111 (16 進数で 0x10FFFF) です。 *i*
   が範囲外の場合 "ValueError" が送出されます。

@classmethod

   メソッドをクラスメソッドへ変換します。

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

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

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

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

   クラスメソッドは C++ や Java の静的メソッドとは異なります。静的メソ
   ッドは、この節の "staticmethod()" を参照してください。

   クラスメソッドについて詳しい情報は、 標準型の階層 の標準型階層のド
   キュメントを参照してください。

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

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

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

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

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

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

   引数 *optimize* は、コンパイラの最適化レベルを指定します; デフォル
   トの値 "-1" は、インタプリタの "-O" オプションで与えられるのと同じ
   最適化レベルを選びます。明示的なレベルは、 "0" (最適化なし、
   "__debug__" は真)、 "1" (assert は取り除かれ、 "__debug__" は偽)、
   "2" (docstring も取り除かれる) です。

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

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

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

   警告: AST オブジェクトにコンパイルしているときに、十分に大きい文
     字列や 複雑な文字列によって Python の抽象構文木コンパイラのスタッ
     クが深 さの限界を越えることで、 Python インタプリタをクラッシュさ
     せられ ます。

   バージョン 3.2 で変更: Windows や Mac の改行も受け付けます。また
   "'exec'" モードでの入力が改行で終わっている必要もありません。
   *optimize* 引数が追加されました。

   バージョン 3.5 で変更: 以前は *source* にヌルバイトがあったときに
   "TypeError" を送出していました。

class complex([real[, imag]])

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

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

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

   バージョン 3.6 で変更: コードリテラル中で桁をグループ化するのにアン
   ダースコアを利用できます。

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__', '__name__', 'struct']
   >>> dir(struct)   # show the names in the struct module # doctest: +SKIP
   ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
    '__initializing__', '__loader__', '__name__', '__package__',
    '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
    'unpack', 'unpack_from']
   >>> class Shape:
   ...     def __dir__(self):
   ...         return ['area', 'perimeter', 'location']
   >>> s = Shape()
   >>> dir(s)
   ['area', 'location', 'perimeter']

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

divmod(a, b)

   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)" です。

enumerate(iterable, start=0)

   enumerate オブジェクトを返します。 *iterable* は、シーケンスか
   *iterator* か、あるいはイテレーションをサポートするその他のオブジェ
   クトでなければなりません。 "enumerate()" によって返されたイテレータ
   の "__next__()" メソッドは、 (デフォルトでは 0 となる *start* から
   の) カウントと、 *iterable* 上のイテレーションによって得られた値を
   含むタプルを返します。

   >>> 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

eval(expression, globals=None, locals=None)

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

   *expression* 引数は Python 式 (技術的な言い方では、条件のリスト) と
   して構文解析され評価されます。 このとき辞書 *globals* および
   *locals* はそれぞれグローバルおよびローカルな名前空間として使われま
   す。 *globals* 辞書が与えられ、 "__builtins__" をキーとする値が含ま
   れていない場合、 *expression* が構文解析される前に、組み込みモジュ
   ール "builtins" の辞書への参照がキー "__builtins__" の値として挿入
   されます。 よって、 *expression* は通常、標準の "builtins" モジュー
   ルへの完全なアクセスを有し、制限された環境は伝播します。 *locals*
   辞書が省略された場合、デフォルトは *globals* 辞書です。 辞書が両方
   とも省略された場合、表現式は "eval()" が呼び出されている環境の下で
   実行されます。 構文エラーは例外として報告されます。例:

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

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

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

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

exec(object[, globals[, locals]])

   この関数は Python コードの動的な実行をサポートします。 *object* は
   文字列かコードオブジェクトでなければなりません。文字列なら、その文
   字列は一連の Python 文として解析され、そして (構文エラーが生じない
   限り) 実行されます。 [1] コードオブジェクトなら、それは単純に実行さ
   れます。どの場合でも、実行されるコードはファイル入力として有効であ
   ることが期待されます (リファレンスマニュアルの節 "file-input" を参
   照)。なお、 "return" および "yield" 文は、 "exec()" 関数に渡された
   コードの文脈中においてさえ、関数定義の外では使えません。返り値は
   "None" です。

   いずれの場合でも、オプションの部分が省略されると、コードは現在のス
   コープ内で実行されます。*globals* だけが与えられたなら、辞書でなく
   てはならず、グローバル変数とローカル変数の両方に使われます。
   *globals* と *locals* が与えられたなら、それぞれグローバル変数とロ
   ーカル変数として使われます。*locals* を指定する場合は何らかのマップ
   型オブジェクトでなければなりません。モジュールレベルでは、グローバ
   ルとローカルは同じ辞書です。exec が *globals* と *locals* として別
   のオブジェクトを取った場合、コードはクラス定義に埋め込まれたかのよ
   うに実行されます。

   *globals* 辞書がキー "__builtins__" に対する値を含まなければ、その
   キーに対して、組み込みモジュール "builtins" の辞書への参照が挿入さ
   れます。ですから、実行されるコードを "exec()" に渡す前に、
   *globals* に自作の "__builtins__" 辞書を挿入することで、コードがど
   の組み込みを利用できるか制御できます。

   注釈: 組み込み関数 "globals()" および "locals()" は、それぞれ現在
     のグロ ーバルおよびローカルの辞書を返すので、それらを "exec()" の
     第二、 第三引数にそのまま渡して使うと便利なことがあります。

   注釈: 標準では *locals* は後に述べる関数 "locals()" のように動作
     します: 標準の *locals* 辞書に対する変更を試みてはいけません。
     "exec()" の呼び出しが返る時にコードが *locals* に与える影響を知り
     たいなら 、明示的に *locals* 辞書を渡してください。

filter(function, iterable)

   *iterable* の要素のうち *function* が真を返すものでイテレータを構築
   します。*iterable* はシーケンスか、反復をサポートするコンテナか、イ
   テレータです。*function* が "None" なら、恒等関数を仮定します。すな
   わち、*iterable* の偽である要素がすべて除去されます。

   なお、"filter(function, iterable)" は、関数が "None" でなければジェ
   ネレータ式 "(item for item in iterable if function(item))" と同等で
   、関数が "None" なら "(item for item in iterable if item)" と同等で
   す。

   *function* が偽を返すような *iterable* の各要素を返す補完的関数は、
   "itertools.filterfalse()" を参照してください。

class float([x])

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

   引数が文字列の場合、10進数を含んだ文字列にしてください。先頭に符号
   が付いていたり、空白中に埋め込まれていてもかまいません。符号として
   "'+'" か "'-'" を追加できます。"'+'" は、作られる値に何の影響も与え
   ません。引数は NaN (not-a-number) や正負の無限大を表す文字列でもか
   まいません。正確には、入力は、前後の空白を取り除いた後に以下の文法
   に従う必要があります:

      sign           ::= "+" | "-"
      infinity       ::= "Infinity" | "inf"
      nan            ::= "nan"
      numeric_value  ::= floatnumber | infinity | nan
      numeric_string ::= [sign] numeric_value

   ここで "floatnumber" は 浮動小数点数リテラル で記述されている
   Python の浮動小数点数リテラルです。大文字か小文字かは関係なく、例え
   ば "inf"、 "Inf"、 "INFINITY" 、 "iNfINity" は全て正の無限大として
   使える綴りです。

   一方で、引数が整数または浮動小数点数なら、(Python の浮動小数点数の
   精度で) 同じ値の浮動小数点数が返されます。引数が Python の浮動小数
   点数の範囲外なら、 "OverflowError" が送出されます。

   一般の Python オブジェクト "x" に対して、"float(x)" は
   "x.__float__()" に委譲します。

   引数が与えられなければ、"0.0" が返されます。

   例:

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

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

   バージョン 3.6 で変更: コードリテラル中で桁をグループ化するのにアン
   ダースコアを利用できます。

format(value[, format_spec])

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

   デフォルトの *format_spec* は空の文字列です。それは通常
   "str(value)" の呼び出しと同じ結果になります。

   "format(value, format_spec)" の呼び出しは、
   "type(value).__format__(value, format_spec)" に翻訳され、これは
   value の "__format__()" メソッドの検索をするとき、インスタンス辞書
   を回避します。このメソッドの探索が "object" に到達しても
   *format_spec* が空にならなかったり、 *format_spec* や返り値が文字列
   でなかったりした場合、 "TypeError" が送出されます。

   バージョン 3.4 で変更: *format_spec* が空の文字列でない場合
   "object().__format__(format_spec)" は "TypeError" を送出します。

class frozenset([iterable])

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

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

getattr(object, name[, default])

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

globals()

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

hasattr(object, name)

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

hash(object)

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

   注釈: 独自の "__hash__()" メソッドを実装したオブジェクトを使う場
     合、 "hash()" が実行するマシンのビット幅に合わせて戻り値を切り捨
     てるこ とに注意してください。詳しくは "__hash__()" を参照してくだ
     さい。

help([object])

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

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

   バージョン 3.4 で変更: "pydoc" と "inspect" への変更により、呼び出
   し可能オブジェクトの報告されたシグニチャがより包括的で一貫性のある
   ものになりました。

hex(x)

   Convert an integer number to a lowercase hexadecimal string
   prefixed with "0x". If *x* is not a Python "int" object, it has to
   define an "__index__()" method that returns an integer. Some
   examples:

   >>> hex(255)
   '0xff'
   >>> hex(-42)
   '-0x2a'

   整数を大文字の 16 進文字列や小文字の 16 進文字列、先頭の "0x" 付き
   や "0x" 無しに変換したい場合は、次に挙げる方法が使えます:

   >>> '%#x' % 255, '%x' % 255, '%X' % 255
   ('0xff', 'ff', 'FF')
   >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
   ('0xff', 'ff', 'FF')
   >>> f'{255:#x}', f'{255:x}', f'{255:X}'
   ('0xff', 'ff', 'FF')

   より詳しいことは "format()" も参照してください。

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

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

id(object)

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

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

input([prompt])

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

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

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

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

   数値または文字列 *x* から作成された整数オブジェクトを返します。引数
   が与えられない場合には "0" を返します。 *x* に "__int__()" が定義さ
   れている場合は、 "int(x)" は "x.__int__()" を返します。 *x* に
   "__trunc__()" が定義されている場合は、 "`x.__trunc__()" を返します
   。 浮動小数点数については、これは 0 に近い側へ切り捨てます。

   *x* が数値でない、あるいは *base* が与えられた場合、 *x* は文字列、
   "bytes" インスタンス、 "bytearray" インスタンスのいずれかで、基数
   *base* の 整数リテラル で表されたものでなければなりません。 オプシ
   ョンで、リテラルの前に "+" あるいは "-" を (中間のスペースなしで)
   付けることができます。 また、リテラルは余白で囲むことができます。
   基数 n のリテラルは、 0 から n-1 の数字に値 10-35 を持つ "a" から
   "z" (または "A" から "Z") を加えたもので構成されます。 デフォルトの
   *base* は 10 です。 許される値は 0 と 2--36 です。 基数 2, 8, 16 の
   リテラルは、別の記法としてコード中の整数リテラルのように "0b"/"0B",
   "0o"/"0O", "0x"/"0X" を前に付けることができます。 基数 0 はコードリ
   テラルとして厳密に解釈することを意味します。 その結果、実際の基数は
   2, 8, 10, 16 のどれかになります。 したがって "int('010', 0)" は有効
   ではありませんが、 "int('010')" や "int('010', 8)" は有効です。

   整数型については、 数値型 int, float, complex も参照してください。

   バージョン 3.4 で変更: *base* が "int" のインスタンスでなく、*base*
   オブジェクトが "base.__index__" メソッドを持っている場合、そのメソ
   ッドを呼んで底に対する整数を得ることができます。以前のバージョンで
   は "base.__index__" ではなく "base.__int__" を使用していました。

   バージョン 3.6 で変更: コードリテラル中で桁をグループ化するのにアン
   ダースコアを利用できます。

isinstance(object, classinfo)

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

issubclass(class, classinfo)

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

iter(object[, sentinel])

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

   イテレータ型 も見てください。

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

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

len(s)

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

class list([iterable])

   "list" は、実際には関数ではなくミュータブルなシーケンス型で、 リス
   ト型 (list) と シーケンス型 --- list, tuple, range にドキュメント化
   されています。

locals()

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

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

map(function, iterable, ...)

   *function* を、結果を返しながら *iterable* の全ての要素に適用するイ
   テレータを返します。追加の *iterable* 引数が渡されたなら、
   *function* はその数だけの引数を取らなければならず、全てのイテラブル
   から並行して取られた要素に適用されます。複数のイテラブルが与えられ
   たら、このイテレータはその中の最短のイテラブルが尽きた時点で止まり
   ます。関数の入力がすでに引数タプルに配置されている場合は、
   "itertools.starmap()" を参照してください。

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

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

   位置引数が1つだけ与えられた場合、それはは空でない *iterable* でなく
   てはいけません。その iterable の最大の要素が返されます。2 つ以上の
   キーワード無しの位置引数が与えられた場合、その位置引数の中で最大の
   ものが返されます。

   任意のキーワード専用引数が 2 つあります。 *key* 引数は引数を 1 つ取
   る順序関数 ("list.sort()" のもののように) を指定します。 *default*
   引数は与えられたイテラブルが空の場合に返すオブジェクトを指定します
   。 イテラブルが空で *default* が与えれれていない場合 "ValueError"
   が送出されます。

   最大の要素が複数あるとき、この関数はそのうち最初に現れたものを返し
   ます。これは、"sorted(iterable, key=keyfunc, reverse=True)[0]" や
   "heapq.nlargest(1, iterable, key=keyfunc)" のような、他のソート安定
   性を維持するツールと両立します。

   バージョン 3.4 で追加: *default* キーワード専用引数。

memoryview(obj)

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

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

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

   位置引数が1つだけ与えられた場合、それはは空でない *iterable* でなく
   てはいけません。その iterable の最小の要素が返されます。2 つ以上の
   キーワード無しの位置引数が与えられた場合、その位置引数の中で最小の
   ものが返されます。

   任意のキーワード専用引数が 2 つあります。 *key* 引数は引数を 1 つ取
   る順序関数 ("list.sort()" のもののように) を指定します。 *default*
   引数は与えられたイテラブルが空の場合に返すオブジェクトを指定します
   。 イテラブルが空で *default* が与えれれていない場合 "ValueError"
   が送出されます。

   最小の要素が複数あるとき、この関数はそのうち最初に現れたものを返し
   ます。これは、"sorted(iterable, key=keyfunc)[0]" や
   "heapq.nsmallest(1, iterable, key=keyfunc)" のような、他のソート安
   定性を維持するツールと両立します。

   バージョン 3.4 で追加: *default* キーワード専用引数。

next(iterator[, default])

   *iterator* の "__next__()" メソッドを呼び出すことにより、次の要素を
   取得します。イテレータが尽きている場合、 *default* が与えられていれ
   ばそれが返され、そうでなければ "StopIteration" が送出されます。

class object

   特徴を持たない新しいオブジェクトを返します。 "object" は全てのクラ
   スの基底クラスです。これは、 Python のクラスの全てのインスタンスに
   共通のメソッド群を持ちます。この関数はいかなる引数も受け付けません
   。

   注釈: "object" は "__dict__" を *持たない* ので、 "object"  クラ
     スのイ ンスタンスに任意の属性を代入することはできません。

oct(x)

   整数を先頭に "0o" が付いた 8 進文字列に変換します。 結果は Python
   の式としても使える形式になります。

   >>> oct(8)
   '0o10'
   >>> oct(-56)
   '-0o70'

   整数を接頭辞の "0o" 付きや "0o" 無しの 8 進文字列に変換したい場合は
   、次に挙げる方法が使えます。

   >>> '%#o' % 10, '%o' % 10
   ('0o12', '12')
   >>> format(10, '#o'), format(10, 'o')
   ('0o12', '12')
   >>> f'{10:#o}', f'{10:o}'
   ('0o12', '12')

   より詳しいことは "format()" も参照してください。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

   *file* を開き、対応する *ファイルオブジェクト* を返します。ファイル
   を開くことができなければ、"OSError" が送出されます。

   *file* は:term:*path-like object* で、開くファイルの (絶対または現
   在のワーキングディレクトリに対する相対) パス名を与えるものか、また
   は、ラップするファイルの整数のファイルディスクリプタです。(ファイル
   ディスクリプタが与えられた場合は、それは *closefd* が "False" に設
   定されていない限り、返された I/O オブジェクトが閉じられるときに閉じ
   られます。)

   *mode* はオプションの文字列で、ファイルが開かれるモードを指定します
   。デフォルトは "'r'" で、読み込み用にテキストモードで開くという意味
   です。その他のよく使われる値は、書き込み (ファイルがすでに存在する
   場合はそのファイルを切り詰めます) 用の "'w'"、排他的な生成用の
   "'x'"、追記用の "'a'" です (*いくつかの* Unix システムでは、*全て*
   の書き込みが現在のファイルシーク位置に関係なくファイルの末尾に追加
   されます)。テキストモードでは、*encoding* が指定されていない場合に
   使われるエンコーディングはプラットフォームに依存します
   :"locale.getpreferredencoding(False)" を使って現在のロケールエンコ
   ーディングを取得します。(rawバイト列の読み書きには、バイナリモード
   を使い、*encoding* は未指定のままとします) 指定可能なモードは次の表
   の通りです。

   +-----------+-----------------------------------------------------------------+
   | 文字      | 意味                                                            |
   |===========|=================================================================|
   | "'r'"     | 読み込み用に開く (デフォルト)                                   |
   +-----------+-----------------------------------------------------------------+
   | "'w'"     | 書き込み用に開き、まずファイルを切り詰める                      |
   +-----------+-----------------------------------------------------------------+
   | "'x'"     | 排他的な生成に開き、ファイルが存在する場合は失敗する            |
   +-----------+-----------------------------------------------------------------+
   | "'a'"     | 書き込み用に開き、ファイルが存在する場合は末尾に追記する        |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | バイナリモード                                                  |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | テキストモード (デフォルト)                                     |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | ディスクファイルを更新用に開く (読み込み／書き込み)             |
   +-----------+-----------------------------------------------------------------+
   | "'U'"     | *ユニバーサル改行* モード (非推奨)                              |
   +-----------+-----------------------------------------------------------------+

   デフォルトのモードは "'r'" (開いてテキストの読み込み、"'rt'" と同義
   ) です。バイナリの読み書きアクセスについては、モード "'w+b'" はファ
   イルを開いて 0 バイトに切り詰めます。"'r+b'" はファイルを切り詰めず
   に開きます。

   概要 で触れられているように、Python はバイナリとテキストの I/O を区
   別します。(*mode* 引数に "'b'" を含めて) バイナリモードで開かれたフ
   ァイルは、内容をいかなるデコーディングもせずに "bytes"  オブジェク
   トとして返します。(デフォルトや、 *mode* 引数に "'t'" が含まれたと
   きの) テキストモードでは、ファイルの内容は "str" として返され、バイ
   ト列はまず、プラットフォーム依存のエンコーディングか、*encoding* が
   指定された場合は指定されたエンコーディングを使ってデコードされます
   。

   注釈: Python は、下層のオペレーティングシステムがテキストファイル
     をどう 認識するかには依存しません; すべての処理は Python 自身で行
     われ、 よってプラットフォーム非依存です。

   *buffering* はオプションの整数で、バッファリングの方針を設定するの
   に使われます。バッファリングを無効にする (バイナリモードでのみ有効)
   には 0、行単位バッファリング (テキストモードでのみ有効) には 1、固
   定値のチャンクバッファの大きさをバイト単位で指定するには 1 以上の整
   数を渡してください。*buffering* 引数が与えられていないとき、デフォ
   ルトのバッファリング方針は以下のように動作します:

   * バイナリファイルは固定サイズのチャンクでバッファリングされます
     。 バッファサイズは、下層のデバイスの「ブロックサイズ」を決定する
     ヒ ューリスティックを用いて選択され、それが不可能な場合は代わりに
     "io.DEFAULT_BUFFER_SIZE" が使われます。多くのシステムでは、典型的
     なバッファサイズは 4096 か 8192 バイト長になるでしょう。

   * 「対話的な」テキストファイル ("isatty()" が "True" を返すファイ
     ル ) は行バッファリングを使用します。 その他のテキストファイルは
     、上 で説明したバイナリファイル用の方針を使用します。

   *encoding* はファイルのエンコードやデコードに使われる *text
   encoding* の名前です。このオプションはテキストモードでのみ使用して
   ください。デフォルトエンコーディングはプラットフォーム依存
   ("locale.getpreferredencoding()" が返すもの) ですが、Pythonでサポー
   トされているエンコーディングはどれでも使えます。詳しくは "codecs"
   モジュール内のサポートしているエンコーディングのリストを参照してく
   ださい。

   *errors* はオプションの文字列で、エンコードやデコードでのエラーをど
   のように扱うかを指定するものです。バイナリモードでは使用できません
   。様々な標準のエラーハンドラが使用可能です (エラーハンドラ に列記さ
   れています) が、 "codecs.register_error()" に登録されているエラー処
   理の名前も使用可能です。標準のエラーハンドラの名前には、以下のよう
   なものがあります:

   * "'strict'" はエンコーディングエラーがあると例外 "ValueError" を
     発 生させます。デフォルト値である "None" も同じ効果です。

   * "'ignore'" はエラーを無視します。エンコーディングエラーを無視す
     る ことで、データが失われる可能性があることに注意してください。

   * "'replace'" は、不正な形式のデータが存在した場所に("'?'" のよう
     な ) 置換マーカーを挿入します。

   * "'surrogateescape'" は正しくないバイト列を、Unicode の Private
     Use Area (私用領域) にある U+DC80 から U+DCFF のコードポイントで
     示します。データを書き込む際に "surrogateescape" エラーハンドラが
     使われると、これらの私用コードポイントは元と同じバイト列に変換さ
     れます。これはエンコーディングが不明なファイルを処理するのに便利
     です。

   * "'xmlcharrefreplace'" はファイルへの書き込み時のみサポートされ
     ま す。そのエンコーディングでサポートされない文字は、"&#nnn;" 形
     式の 適切な XML 文字参照で置換されます。

   * "'backslashreplace'" は不正なデータを Python のバックスラッシュ
     付 きのエスケープシーケンスで置換します。

   * "'namereplace'" (書き込み時のみサポートされています) はサポート
     さ れていない文字を "\N{...}" エスケープシーケンスで置換します。

   *newline* は *universal newlines* モードの動作を制御します (テキス
   トモードでのみ動作します)。"None", "''", "'\n'", "'\r'", "'\r\n'"
   のいずれかです。これは以下のように動作します:

   * ストリームからの入力の読み込み時、*newline* が "None" の場合、
     ユ ニバーサル改行モードが有効になります。入力中の行は "'\n'",
     "'\r'", または "'\r\n'" で終わり、呼び出し元に返される前に "'\n'"
     に変換されます。 "''" の場合、ユニバーサル改行モードは有効になり
     ますが、行末は変換されずに呼び出し元に返されます。その他の正当な
     値の場合、入力行は与えられた文字列でのみ終わり、行末は変換されず
     に呼び出し元に返されます。

   * ストリームへの出力の書き込み時、*newline* が "None" の場合、全
     て の "'\n'" 文字はシステムのデフォルトの行セパレータ
     "os.linesep" に変換されます。 *newline* が "''" または "'\n'" の
     場合は変換され ません。*newline* がその他の正当な値の場合、全ての
     "'\n'" 文字は 与えられた文字列に変換されます。

   *closefd* が "False" で、ファイル名ではなくてファイル記述子が与えら
   れた場合、下層のファイル記述子はファイルが閉じられた後も開いたまま
   となります。 ファイル名が与えられた場合、*closefd* は "True" (デフ
   ォルト値) でなければなりません。 そうでない場合エラーが送出されます
   。

   呼び出し可能オブジェクトを *opener* として与えることで、カスタムの
   オープナーが使えます。そしてファイルオブジェクトの下層のファイル記
   述子は、*opener* を (*file*, *flags*) で呼び出して得られます。
   *opener* は開いたファイル記述子を返さなければなりません。
   ("os.open" を *opener* として渡すと、"None" を渡したのと同様の機能
   になります)。

   新たに作成されたファイルは 継承不可  です。

   次の例は "os.open()" 関数の dir_fd 引数を使い、与えられたディレクト
   リからの相対パスで指定されたファイルを開きます:

      >>> import os
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('This will be written to somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # don't leak a file descriptor

   "open()" 関数が返す *file object* の型はモードに依存します。
   "open()" をファイルをテキストモード ("'w'", "'r'", "'wt'", "'rt'",
   など) で開くのに使ったときは "io.TextIOBase" (特に
   "io.TextIOWrapper") のサブクラスを返します。 ファイルをバッファリン
   グ付きのバイナリモードで開くのに使ったときは "io.BufferedIOBase" の
   サブクラスを返します。 実際のクラスは様々です。 読み込みバイナリモ
   ードでは "io.BufferedReader" を返します。 書き込みバイナリモードや
   追記バイナリモードでは "io.BufferedWriter" を返します。 読み書きモ
   ードでは "io.BufferedRandom" を返します。 バッファリングが無効なと
   きはrawストリーム、すなわち "io.RawIOBase" のサブクラスである
   "io.FileIO" を返します。

   "fileinput" 、("open()" が宣言された場所である) "io" 、 "os" 、
   "os.path" 、 "tempfile" 、 "shutil" などの、ファイル操作モジュール
   も参照してください。

      バージョン 3.3 で変更:

      * *opener* 引数を追加しました。

      * "'x'" モードを追加しました。

      * 以前は "IOError" が送出されていました、それは現在 "OSError"
        の エイリアスになりました。

      * 既存のファイルを 排他的生成モード("'x'")で開いた場合、
        "FileExistsError" を送出するようになりました。

      バージョン 3.4 で変更:

      * ファイルが継承不可になりました。

   Deprecated since version 3.4, will be removed in version 4.0: "'U'"
   モード。

      バージョン 3.5 で変更:

      * システムコールが中断されシグナルハンドラが例外を送出しなかっ
        た 場合、この関数は "InterruptedError" 例外を送出する代わりに
        シス テムコールを再試行するようになりました (論拠については
        **PEP 475** を参照してください)。

      * "'namereplace'" エラーハンドラが追加されました。

      バージョン 3.6 で変更:

      * "os.PathLike" を実装したオブジェクトを受け入れるようになりま
        し た。

      * Windowsでは、コンソールバッファのオープンは、"io.FileIO`では
        な く、:class:`io.RawIOBase" のサブクラスを返すでしょう。

ord(c)

   1 文字の Unicode 文字を表す文字列に対し、その文字の Unicode コード
   ポイントを表す整数を返します。例えば、 "ord('a')" は整数 "97" を返
   し、 "ord('€')" (ユーロ記号) は "8364" を返します。これは "chr()"
   の逆です。

pow(x, y[, z])

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

   引数は数値型でなくてはなりません。型混合の場合、二項算術演算におけ
   る型強制規則が適用されます。 "int" 被演算子に対しては、第二引数が負
   でない限り、結果は (型強制後の) 被演算子と同じ型になります; 負の場
   合、全ての引数は浮動小数点に変換され、浮動小数点の結果が返されます
   。例えば、 "10**2" は "100" を返しますが、 "10**-2" は "0.01" を返
   します。第二引数が負の場合、第三引数は省略しなければなりません。
   *z* がある場合、 *x* および *y* は整数型でなければならず、 *y* は非
   負でなくてはなりません。

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

   *objects* を *sep* で区切りながらテキストストリーム *file* に表示し
   、最後に *end* を表示します。*sep* 、 *end* 、 *file* 、 *flush* を
   与える場合、キーワード引数として与える必要があります。

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

   *file* 引数は、 "write(string)" メソッドを持つオブジェクトでなけれ
   ばなりません。指定されないか、 "None" である場合、 "sys.stdout" が
   使われます。表示される引数は全てテキスト文字列に変換されますから、
   "print()" はバイナリモードファイルオブジェクトには使用できません。
   代わりに "file.write(...)" を使ってください。

   出力がバッファ化されるかどうかは通常 *file* で決まりますが、*flush*
   キーワード引数が真ならストリームは強制的にフラッシュされます。

   バージョン 3.3 で変更: キーワード引数 *flush* が追加されました。

class property(fget=None, fset=None, fdel=None, doc=None)

   property 属性を返します。

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

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

      class C:
          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:
          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:
          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" 属性を持ちます。

   バージョン 3.5 で変更: 属性オブジェクトのドックストリングが書き込み
   可能になりました。

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

   "range" は、実際には関数ではなくイミュータブルなシーケンス型で、
   range と シーケンス型 --- list, tuple, range にドキュメント化されて
   います。

repr(object)

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

reversed(seq)

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

round(number[, ndigits])

   *number* の小数部を *ndigists* 桁に丸めた値を返します。*ndigits* が
   省略されたり、"None" だった場合、入力値に最も近い整数を返します。

   "round()" をサポートする組み込み型では、値は 10 のマイナス
   *ndigits* 乗の倍数の中で最も近いものに丸められます; 二つの倍数が同
   じだけ近いなら、偶数を選ぶ方に (そのため、例えば "round(0.5)" と
   "round(-0.5)" は両方とも "0" に、 "round(1.5)" は "2" に) 丸められ
   ます。 *ndigits* には任意の整数値が有効となります (正の整数、ゼロ、
   負の整数)。 返り値は *ndigits* が指定されていないか "None" の場合は
   整数、そうでなければ返り値は *number* と同じ型です。

   一般的な Python オブジェクト "number" に対して、"round" は処理を
   >>``<<number.__round__` に移譲します。

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

class set([iterable])

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

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

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, *, key=None, reverse=False)

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

   2 つのオプション引数があり、これらはキーワード引数として指定されな
   ければなりません。

   *key* には 1 引数関数を指定します。これは *iterable* の各要素から比
   較キーを展開するのに使われます (例えば、 "key=str.lower" のように指
   定します)。 デフォルト値は "None" です (要素を直接比較します)。

   *reverse* は真偽値です。 "True" がセットされた場合、リストの要素は
   個々の比較が反転したものとして並び替えられます。

   旧式の *cmp* 関数を *key* 関数に変換するには
   "functools.cmp_to_key()" を使用してください。

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

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

@staticmethod

   メソッドを静的メソッドへ変換します。

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

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

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

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

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

   あらゆるデコレータと同じく、 "staticmethod" は普通の関数のように呼
   べ、その返り値で処理が行えます。 この機能は、クラス本体から関数を参
   照する必要があり、かつ、インスタンスメソッドに自動変換されるのを避
   けたいケースで必要になります。 そのようなケースでは、このイディオム
   が使えます:

      class C:
          builtin_open = staticmethod(open)

   静的メソッドについて詳しくは、 標準型の階層 の標準型階層についての
   ドキュメントを繙いてください。

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

   *object* の "str" 版を返します。詳細は "str()" を参照してください。

   "str" は組み込みの文字列 *クラス* です。文字列に関する一般的な情報
   は、テキストシーケンス型 --- str を参照してください。

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().method(arg)    # This does the same thing as:
                                     # super(C, self).method(arg)

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

   また、 "super()" の使用は引数無しの形式を除きメソッド内部に限定され
   ないことにも注目して下さい。2引数の形式は、必要な要素を正確に指定す
   るので、適当な参照を作ることができます。クラス定義中における引数無
   しの形式は、定義されているクラスを取り出すのに必要な詳細を、通常の
   方法で現在のインスタンスにアクセスするようにコンパイラが埋めるので
   はたらきます。

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

tuple([iterable])

   "tuple" は、実際は関数ではなくイミュータブルなシーケンス型で、タプ
   ル型 (tuple) と シーケンス型 --- list, tuple, range にドキュメント
   化されています。

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

   引数が1つだけの場合、*object* の型を返します。返り値は型オブジェク
   トで、一般に "object.__class__" によって返されるのと同じオブジェク
   トです。

   オブジェクトの型の判定には、 "isinstance()" 組み込み関数を使うこと
   が推奨されます。これはサブクラスを考慮するからです。

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

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

   型オブジェクト も参照してください。

   バージョン 3.6 で変更: "type.__new__" をオーバーライドしていない
   :class:*type* のサブクラスは、オブジェクトの型を得るのに１引数形式
   を利用することができません。

vars([object])

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

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

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

zip(*iterables)

   それぞれのイテラブルから要素を集めたイテレータを作ります。

   この関数はタプルのイテレータを返し、その *i* 番目のタプルは引数シー
   ケンスまたはイテラブルそれぞれの *i* 番目の要素を含みます。このイテ
   レータは、入力イテラブルの中で最短のものが尽きたときに止まります。
   単一のイテラブル引数が与えられたときは、1 要素のタプルからなるイテ
   レータを返します。引数がなければ、空のイテレータを返します。次と等
   価です:

      def zip(*iterables):
          # zip('ABCD', 'xy') --> Ax By
          sentinel = object()
          iterators = [iter(it) for it in iterables]
          while iterators:
              result = []
              for it in iterators:
                  elem = next(it, sentinel)
                  if elem is sentinel:
                      return
                  result.append(elem)
              yield tuple(result)

   イテラブルの左から右への評価順序は保証されています。そのため
   "zip(*[iter(s)]*n)" を使ってデータ系列を長さ n のグループにクラスタ
   リングするイディオムが使えます。これは、各出力タプルがイテレータを
   "n" 回呼び出した結果となるよう、 *同じ* イテレータを "n" 回繰り返し
   ます。これは入力を長さ n のチャンクに分割する効果があります。

   "zip()" は、長い方のイテラブルの終端にある対にならない値を考慮した
   い場合は、等しくない長さの入力に対して使うべきではありません。その
   ような値が重要な場合、代わりに "itertools.zip_longest()" を使ってく
   ださい。

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

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

__import__(name, globals=None, locals=None, fromlist=(), level=0)

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

   この関数は "import" 文により呼び出されます。 ("builtins" モジュール
   をインポートして "builtins.__import__" に代入することで) この関数を
   置き換えて "import" 文のセマンティクスを変更することができますが、
   同様のことをするのに通常はインポートフック (**PEP 302** 参照) を利
   用する方が簡単で、かつデフォルトのインポート実装が使用されているこ
   とを仮定するコードとの間で問題が起きないので、このやり方は *強く*
   推奨されません。 "__import__()" を直接使用することも推奨されず、
   "importlib.import_module()" の方が好まれます。

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

   *level* は絶対と相対どちらのインポートを使うかを指定します。 "0" (
   デフォルト) は絶対インポートのみ実行します。正の *level* の値は、
   "__import__()" を呼び出したディレクトリから検索対象となる親ディレク
   トリの数を示します (詳細は **PEP 328** を参照してください)。

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

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

      spam = __import__('spam', globals(), locals(), [], 0)

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

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

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

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

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

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

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

   バージョン 3.3 で変更: 負の *level* の値はサポートされなくなりまし
   た (デフォルト値の 0 に変更されます)。

-[ 脚注 ]-

[1] なお、パーサは Unix スタイルの行末の記法しか受け付けません。コ
    ード をファイルから読んでいるなら、必ず、改行変換モードで Windows
    や Mac スタイルの改行を変換してください。
