組み込み関数
************

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

+---------------------------+-------------------------+-------------------------+---------------------------+
| 組み込み関数                                                                                              |
|===========================|=========================|=========================|===========================|
| **A** "abs()" "aiter()"   | **E** "enumerate()"     | **L** "len()" "list()"  | **R** "range()" "repr()"  |
| "all()" "anext()" "any()" | "eval()" "exec()"       | "locals()"  **M**       | "reversed()" "round()"    |
| "ascii()"  **B** "bin()"  | **F** "filter()"        | "map()" "max()"         | **S** "set()" "setattr()" |
| "bool()" "breakpoint()"   | "float()" "format()"    | "memoryview()" "min()"  | "slice()" "sorted()"      |
| "bytearray()" "bytes()"   | "frozenset()"  **G**    | **N** "next()"  **O**   | "staticmethod()" "str()"  |
| **C** "callable()"        | "getattr()" "globals()" | "object()" "oct()"      | "sum()" "super()"  **T**  |
| "chr()" "classmethod()"   | **H** "hasattr()"       | "open()" "ord()"  **P** | "tuple()" "type()"  **V** |
| "compile()" "complex()"   | "hash()" "help()"       | "pow()" "print()"       | "vars()"  **Z** "zip()"   |
| **D** "delattr()"         | "hex()"  **I** "id()"   | "property()"            | **_** "__import__()"      |
| "dict()" "dir()"          | "input()" "int()"       |                         |                           |
| "divmod()"                | "isinstance()"          |                         |                           |
|                           | "issubclass()" "iter()" |                         |                           |
+---------------------------+-------------------------+-------------------------+---------------------------+

abs(x)

   数の絶対値を返します。引数は整数、浮動小数点数または "__abs__()" が
   実装されたオブジェクトです。引数が複素数なら、その絶対値
   (magnitude) が返されます。

aiter(async_iterable)

   *asynchronous iterable* から  *asynchronous iterator* を返します。
   "x.__aiter__()" を呼び出すのと等価です。

   なお、 "iter()" とは異なり、 "aiter()" は第二引数を持ちません。

   Added in version 3.10.

all(iterable)

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

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

awaitable anext(async_iterator)
awaitable anext(async_iterator, default)

   待ち受け中に、与えられた非同期イテレータ (*asynchronous iterator*)
   を返します。イテレータが枯渇した場合、 *default* が与えられていれば
   *default* を返します。

   これは組み込みの "next()" 関数の非同期版であり、同じように動作しま
   す。

   これは *async_iterator* の "__anext__()" メソッドを呼び出し、待ち受
   け可能オブジェクト (*awaitable*) を返します。待ち受けることによりイ
   テレータの次の値を返します。 *default* が与えられた場合、イテレータ
   が枯渇したときにその値が返されます。 *default* が与えられない場合は
   "StopAsyncIteration" が送出されます。

   Added in version 3.10.

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
   の式としても使える形式になります。 *x* が Python の "int" オブジェ
   クトでない場合、整数を返す "__index__()" メソッドが定義されていなけ
   ればなりません。 いくつかの例を示します:

   >>> 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(object=False, /)

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

   バージョン 3.7 で変更: 引数は位置専用になりました。

breakpoint(*args, **kws)

   この関数は、呼び出された箇所にて処理をデバッガに移行します。具体的
   には、 "sys.breakpointhook()" を呼び出し、 "args" と "kws" をそのま
   ま渡します。デフォルトでは、 "sys.breakpointhook()" は引数なしで
   "pdb.set_trace()" を呼び出すだけです。その場合、これは単なる便利関
   数でデバッガに入るために "pdb" を明示的にインポートしたり多くのコー
   ドを書いたりせずに済むだけです。ですが、 "sys.breakpointhook()" は
   別の関数に設定でき、 "breakpoint()" はそれを自動で呼び出すため、自
   分好みのデバッガに処理を移行させることができます。
   "sys.breakpointhook()" にアクセスできない場合、この関数は
   "RuntimeError" を送出します。

   デフォルトでは、環境変数 "PYTHONBREAKPOINT" をセットすることで
   "breakpoint()" の動作を変えることができます。 使い方の詳細は
   "sys.breakpointhook()" を参照してください。

   ただし、 "sys.breakpointhook()" が別の関数で置き換えられている場合
   、上記の環境変数によって必ずしも動作を変えることができないことに注
   意してください。

   引数 "breakpointhook" 付きで 監査イベント "builtins.breakpoint" を
   送出します。

   Added in version 3.7.

class bytearray(source=b'')
class bytearray(source, encoding)
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=b'')
class bytes(source, encoding)
class bytes(source, encoding, errors)

   範囲 "0 <= x < 256" の整数のイミュータブルなシーケンスである
   "bytes" オブジェクトを返します。 "bytes" は "bytearray" のイミュー
   タブル版であり、オブジェクトを変化させないメソッドや、インデックス
   指定、オブジェクトのスライスについてのふるまいは同じです。

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

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

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

callable(object)

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

   Added in version 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" 形式は関数 *デコレータ* です。詳しくは 関数定義 を参
   照してください。

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

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

   バージョン 3.9 で変更: クラスメソッドは "property()" など、他の *デ
   スクリプタ* をラップすることができるようになりました。

   バージョン 3.10 で変更: クラスメソッドはメソッド属性 ("__module__",
   "__name__", "__qualname__", "__doc__" と "__annotations__") を継承
   するようになりました。また、新たに "__wrapped__" 属性を持つようにな
   りました。

   バージョン 3.11 で変更: クラスメソッドは "property()" など、他の *
   デスクリプタ* をラップすることができなくなりました。

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* は、どの コンパイラオプシ
   ョン を有効化するか、 将来の機能 のどれを許可するかを制御します。ど
   ちらの引数も存在しない (またはどちらもゼロである) 場合は、
   "compile()" の呼び出し元のコードに作用したものと同じフラグでコンパ
   イルされます。 *flags* 引数が与えられて *dont_inherit* が与えられな
   い (またはゼロ) の場合、上記に加えて *flags* 引数で与えられたコンパ
   イラオプションと future 文が使われます。 *dont_inherit* がゼロでな
   い整数の場合、 *flags* 引数で指定されたオプションだけが有効です --
   呼び出し元コードに適用されたフラグ (将来の機能とコンパイラオプショ
   ン) は無視されます。

   有効化するコンパイラオプションと future 文はビットフィールドで指定
   可能で、ビット単位の OR をとることで複数のオプションを一緒に指定す
   ることができます。特定の future 機能を指定するために必要なビットフ
   ィールドの情報は、 "__future__" モジュールにおける "_Feature" イン
   スタンスの "compiler_flag" 属性で得ることができます。 コンパイラフ
   ラグ の情報は "ast" モジュールの "PyCF_" で始まるフラグで得ることが
   できます。

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

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

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

   引数 "source" と "filename" を指定して 監査イベント "compile" を送
   出します。これは、暗黙に行われるコンパイルでも送出される可能性があ
   ります。

   注釈:

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

   警告:

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

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

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

   Added in version 3.8: "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" フラグを渡し
   てトップレベルの "await", "async for", および "async with" のサポー
   トを有効化することができるようになりました。

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

   単一の文字列や数値を複素数に変換する、あるいは実部と虚部から複素数
   を作成します。

   例:

      >>> complex('+1.23')
      (1.23+0j)
      >>> complex('-4.5j')
      -4.5j
      >>> complex('-1.23+4.5j')
      (-1.23+4.5j)
      >>> complex('\t( -1.23+4.5J )\n')
      (-1.23+4.5j)
      >>> complex('-Infinity+NaNj')
      (-inf+nanj)
      >>> complex(1.23)
      (1.23+0j)
      >>> complex(imag=-4.5)
      -4.5j
      >>> complex(-1.23, 4.5)
      (-1.23+4.5j)

   引数が文字列の場合、実数部（ "float()" と同じ形式）、虚数部（同様の
   形式で "'j'" または "'J'" 接尾辞）どちらか、あるいは両方（この場合
   、虚数部の符号は必須）を含まなければなりません。文字列 は空白や括弧
   "'('" と``')'`` で囲むこともできますが、無視されます。文字列は、
   "'+'" 、"'-'" 、 "'j'" または "'J'" 接尾辞 、そして10進数の間に空白
   を含んではなりません。たとえば "complex('1+2j')" はよいですが、
   "complex('1 + 2j')" は "ValueError" を送出します。より正確には、入
   力は括弧および先頭と末尾の空白文字を除去した後、以下の文法における
   "complexvalue" の生成規則を満たす必要があります:

      complexvalue ::= floatvalue |
                       floatvalue ("j" | "J") |
                       floatvalue sign absfloatvalue ("j" | "J")

   引数が数値の場合、コンストラクタは "int" や "float" のように数値変
   換します。一般的な Python オブジェクト "x" では、 "complex(x)" は
   "x.__complex__()" に委譲します。 "__complex__()" が定義されていない
   場合は "__float__()" にフォールバックします。 "__float__()" も定義
   されていない場合には、 "__index__()" にフォールバックします。

   ２引数が指定されるかキーワード引数が使われている場合、各引数は任意
   の数値型（複素数を含む）となります。両方の引数が実数の場合には、実
   数成分 *real* と虚数成分 *imag* を持つ複素数を返します。引数が両方
   とも複素数の場合、実数成分 "real.real-imag.imag" と虚数成分
   "real.imag+imag.real" を持つ複素数を返します。引数の片方が実数の場
   合、前述の式ではその実数成分のみ使われます。

   引数がすべて省略された場合は、 "0j" を返します。

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

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

   バージョン 3.8 で変更: "__complex__()" と "__float__()" が定義され
   ていない場合、 "__index__()" へフォールバックします。

delattr(object, name)

   "setattr()" の親戚です。引数はオブジェクトと文字列です。文字列はオ
   ブジェクトの属性名のいずれかでなければなりません。対象のオブジェク
   トが許可する場合に限り、この関数は指定された名前の属性を削除します
   。たとえば、 "delattr(x, 'foobar')" は "del x.foobar" と等価です。
   *name* は Python の識別子である必要はありません ("setattr()" を参照
   してください)。

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

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

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

dir()
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
   ['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つの (複素数でない) 数を引数としてとり、整数の除法を行ったときの商
   と剰余からなる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(iterable, start=0):
          n = start
          for elem in iterable:
              yield n, elem
              n += 1

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

   パラメータ:
      * **expression** ("str" | code object) -- Python 式。

      * **globals** ("dict" | "None") -- グローバル名前空間 (default:
        "None") 。

      * **locals** (*mapping* | "None") -- ローカル名前空間 (default:
        "None") 。

   戻り値:
      評価された式の結果。

   例外:
      構文エラーは例外として報告されます。

   警告:

     この関数は任意のコードを実行します。ユーザが入力した文字列を引数
     としてこの関数を呼び出すと、セキュリティの脆弱性につながる可能性
     があります。

   The *expression* argument is parsed and evaluated as a Python
   expression (technically speaking, a condition list) using the
   *globals* and *locals* dictionaries as global and local namespace.
   If the *globals* dictionary is present and does not contain a value
   for the key "__builtins__", a reference to the dictionary of the
   built-in module "builtins" is inserted under that key before
   *expression* is parsed.  That way you can control what builtins are
   available to the executed code by inserting your own "__builtins__"
   dictionary into *globals* before passing it to "eval()".  If the
   *locals* dictionary is omitted it defaults to the *globals*
   dictionary.  If both dictionaries are omitted, the expression is
   executed with the *globals* and *locals* in the environment where
   "eval()" is called.  Note, *eval()* does not have access to the
   *nested scopes* (non-locals) in the enclosing environment.

   例:

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

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

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

   ソースコードとして文字列が与えられた場合、先頭と末尾の空白文字およ
   びタブは取り去られます。

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

   コードオブジェクトを引数として 監査イベント "exec" を送出します。コ
   ードコンパイルのイベントも送出されることがあります。

exec(object, globals=None, locals=None, /, *, closure=None)

   警告:

     この関数は任意のコードを実行します。ユーザが入力した文字列を引数
     としてこの関数を呼び出すと、セキュリティの脆弱性につながる可能性
     があります。

   This function supports dynamic execution of Python code. *object*
   must be either a string or a code object.  If it is a string, the
   string is parsed as a suite of Python statements which is then
   executed (unless a syntax error occurs). [1] If it is a code
   object, it is simply executed.  In all cases, the code that's
   executed is expected to be valid as file input (see the section フ
   ァイル入力 in the Reference Manual). Be aware that the "nonlocal",
   "yield",  and "return" statements may not be used outside of
   function definitions even within the context of code passed to the
   "exec()" function. The return value is "None".

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

   注釈:

     Most users should just pass a *globals* argument and never
     *locals*. If exec gets two separate objects as *globals* and
     *locals*, the code will be executed as if it were embedded in a
     class definition.

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

   The *closure* argument specifies a closure--a tuple of cellvars.
   It's only valid when the *object* is a code object containing free
   variables. The length of the tuple must exactly match the number of
   free variables referenced by the code object.

   コードオブジェクトを引数として 監査イベント "exec" を送出します。コ
   ードコンパイルのイベントも送出されることがあります。

   注釈:

     The built-in functions "globals()" and "locals()" return the
     current global and local dictionary, respectively, which may be
     useful to pass around for use as the second and third argument to
     "exec()".

   注釈:

     The default *locals* act as described for function "locals()"
     below: modifications to the default *locals* dictionary should
     not be attempted. Pass an explicit *locals* dictionary if you
     need to see effects of the code on *locals* after function
     "exec()" returns.

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

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

   逆の働きをする関数については、 "itertools.filterfalse()" を参照して
   ください。 *iterable* の要素のうち、 *function* が偽であるものを返
   します。

class float(number=0.0, /)
class float(string, /)

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

   例:

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

   引数が文字列の場合、10進数でなければなりません。先頭に符号または空
   白を含んでもかまいません。符号は "'+'" か "'-'" のいずれかです。正
   符号 "'+'" は生成される値に対して何の効果もありません。引数は NaN
   (not-a-number) や正または負の無限大をあらわす文字列でもかまいません
   。より正確にいうと、入力は先頭と末尾の空白文字を除き、以下に示す
   "floatvalue" の生成規則に従う必要があります:

      sign          ::= "+" | "-"
      infinity      ::= "Infinity" | "inf"
      nan           ::= "nan"
      digit         ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
      digitpart     ::= digit (["_"] digit)*
      number        ::= [digitpart] "." digitpart | digitpart ["."]
      exponent      ::= ("e" | "E") [sign] digitpart
      floatnumber   ::= number [exponent]
      absfloatvalue ::= floatnumber | infinity | nan
      floatvalue    ::= [sign] absfloatvalue

   大文字と小文字は重要ではないので、例えば、 "inf", "Inf",
   "INFINITY", "iNfINity" はすべて正の無限大を表す綴りとして受け入れら
   れます。

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

   一般の Python オブジェクト "x" に対して、"float(x)" は
   "x.__float__()" に委譲します。 "__float__()" が定義されていない場合
   、"__index__()" へフォールバックします。

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

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

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

   バージョン 3.7 で変更: 引数は位置専用になりました。

   バージョン 3.8 で変更: "__float__()" が定義されていない場合、
   "__index__()" へフォールバックします。

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=set())

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

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

getattr(object, name)
getattr(object, name, default)

   *object* の指定された属性の値を返します。 *name* は文字列でなければ
   なりません。与えられた文字列がオブジェクトの属性名のうちいずれかに
   一致すれば、戻り値はその属性の値になります。たとえば、 "getattr(x,
   'foobar')" は "x.foobar" と等価です。もし指定された属性が存在しない
   場合、 *default* が指定されていればその値が返されます。そうでない場
   合は "AttributeError" が送出されます。 *name* は Python 識別子であ
   る必要はありません ("setattr()" を参照してください)。

   注釈:

     プライベートな名前のマングリング はコンパイル時に行われます。その
     ため、プライベートな属性 (先頭に2つのアンダースコアを伴う名前を持
     つ属性) の値を "getattr()" で取り出すためには、属性名を手動でマン
     グリングする必要があります。

globals()

   現在のモジュールの名前空間を実装した辞書を返します。関数内のコード
   に対しては、関数が定義されるときに辞書が設定され、その関数がどこか
   ら呼ばれたかにかかわらず同じ内容になります。

hasattr(object, name)

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

hash(object)

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

   注釈:

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

help()
help(request)

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

   "help()" を呼び出したときに関数の引数リストにスラッシュ (/) が現れ
   た場合は、スラッシュより前の引数が位置専用引数だという意味であるこ
   とに注意してください。より詳しい情報は、 位置専用引数についての FAQ
   の項目 を参照してください。

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

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

hex(x)

   整数を先頭に "0x" が付いた小文字の 16 進文字列に変換します。 *x* が
   Python の "int" オブジェクトでない場合、整数を返す "__index__()" メ
   ソッドが定義されていなければなりません。 いくつかの例を示します:

   >>> 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()" 値を持つかもしれません
   。

   これはオブジェクトのメモリアドレスです。

   引数 "id" を指定して 監査イベント "builtins.id" を送出します。

input()
input(prompt)

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

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

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

   入力を読み込む前に、引数 "prompt" 付きで 監査イベント
   "builtins.input" を送出します。

   入力の読み込みに成功した後に、その結果付きで 監査イベント
   "builtins.input/result" を送出します。

class int(number=0, /)
class int(string, /, base=10)

   数または文字列から生成された整数オブジェクトを返します。引数が指定
   されない場合は "0" を返します。

   例:

      >>> int(123.45)
      123
      >>> int('123')
      123
      >>> int('   -12_345\n')
      -12345
      >>> int('FACE', 16)
      64206
      >>> int('0xface', 0)
      64206
      >>> int('01110011', base=2)
      115

   If the argument defines "__int__()", "int(x)" returns
   "x.__int__()".  If the argument defines "__index__()", it returns
   "x.__index__()".  If the argument defines "__trunc__()", it returns
   "x.__trunc__()". For floating-point numbers, this truncates towards
   zero.

   引数が数値でないか、または *base* が与えられた場合、引数は *base*
   を基数とした整数を表現する文字列、 "bytes" インスタンス、または
   "bytearray" インスタンスのいずれかでなければなりません。文字列は先
   頭に "+" または "-" を伴ったり (符号と数値の間に空白文字を入れては
   いけません)、数値の先頭に任意の数のゼロを付けたり、前後に空白文字を
   付けたり、各桁を単一の下線で区切ったりしても有効です。

   n-進数の整数文字列は、各桁が0から n-1 の数値で表されます。ユニコー
   ドの10進数では、各桁は0から9のいずれかです。また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 のどれになるかが決まります。基数を0にし
   た場合先頭にゼロを追加することはできません: すなわち "int('010',
   0)" は基数を0に指定しているため不正ですが、 "int('010')" や
   "int('010', 8)" は有効です。

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

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

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

   バージョン 3.7 で変更: 第1引数は位置専用になりました。

   バージョン 3.8 で変更: "__int__()" が定義されていない場合、
   "__index__()" へフォールバックします。

   バージョン 3.11 で変更: The delegation to "__trunc__()" is
   deprecated.

   バージョン 3.11 で変更: "int" への文字列入力やその文字列表現は、サ
   ービス拒否攻撃 (DoS 攻撃) を避けるために制限されることがあります。
   文字列を "int" に変換したり "int" を文字列に変換したりする際にその
   制限を超えた場合、 "ValueError" が送出されます。詳しくは 整数文字列
   の変換における長さ制限 を参照してください。

isinstance(object, classinfo)

   *object* 引数が *classinfo* 引数に指定した型、またはその (直接、間
   接、または *仮想* の) サブクラスのインスタンスである場合に "True"
   を返します。 *object* が与えられた型のオブジェクトでない場合、この
   関数は常に "False" を返します。 *classinfo* が型オブジェクトのタプ
   ル (または再帰的にそのようなタプルを含むタプル) や複数の型の Union
   型 である場合、 *object* がそれらの型のいずれかのインスタンスであれ
   ば "True" を返します。 *classinfo* が型や型からなるタプルまたは再帰
   的タプルのいずれでもない場合、 "TypeError" 例外が送出されます。タプ
   ルの中で先行する型に対するチェックが成功した場合、後続の不正な型に
   対して "TypeError" が送出されないことがあります。

   バージョン 3.10 で変更: *classinfo* に Union 型 を指定できるように
   なりました。

issubclass(class, classinfo)

   *class* が *classinfo* の (直接、間接、または *仮想* の) サブクラス
   である場合に "True" を返します。クラスは自身のサブクラスとみなされ
   ます。 *classinfo* はクラスオブジェクトのタプル (または再帰的にその
   ようなタプルを含むタプル) やクラスオブジェクトの Union 型 でもよく
   、この場合は *class* が *classinfo* のいずれかのクラスのサブクラス
   であれば "True" を返します。上記以外の値が指定された場合、
   "TypeError" 例外が送出されます。

   バージョン 3.10 で変更: *classinfo* に Union 型 を指定できるように
   なりました。

iter(object)
iter(object, sentinel)

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

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

   2引数形式の "iter()" の便利な利用方法の1つは、ブロックリーダーの構
   築です。 例えば、バイナリのデータベースファイルから固定幅のブロック
   をファイルの終端に到達するまで読み出すには次のようにします:

      from functools import partial
      with open('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

len(s)

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

   "len" は、例えば "range(2 ** 100)" のような、 "sys.maxsize" を超え
   る長さに対して "OverflowError" を送出します。

class list
class list(iterable)

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

locals()

   Update and return a dictionary representing the current local
   symbol table. Free variables are returned by "locals()" when it is
   called in function blocks, but not in class blocks. Note that at
   the module level, "locals()" and "globals()" are the same
   dictionary.

   注釈:

     The contents of this dictionary should not be modified; changes
     may not affect the values of local and free variables used by the
     interpreter.

map(function, iterable, *iterables)

   Return an iterator that applies *function* to every item of
   *iterable*, yielding the results.  If additional *iterables*
   arguments are passed, *function* must take that many arguments and
   is applied to the items from all iterables in parallel.  With
   multiple iterables, the iterator stops when the shortest iterable
   is exhausted.  For cases where the function inputs are already
   arranged into argument tuples, see "itertools.starmap()".

max(iterable, *, key=None)
max(iterable, *, default, key=None)
max(arg1, arg2, *args, key=None)

   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* が追加されまし
   た。

   バージョン 3.8 で変更: *key* 引数が "None" であることを許容します。

class memoryview(object)

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

min(iterable, *, key=None)
min(iterable, *, default, key=None)
min(arg1, arg2, *args, key=None)

   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* が追加されまし
   た。

   バージョン 3.8 で変更: *key* 引数が "None" であることを許容します。

next(iterator)
next(iterator, default)

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

class object

   This is the ultimate base class of all other classes. It has
   methods that are common to all instances of Python classes. When
   the constructor is called, it returns a new featureless object. The
   constructor does not accept any arguments.

   注釈:

     "object" instances do *not* have "__dict__" attributes, so you
     can't assign arbitrary attributes to an instance of "object".

oct(x)

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

   >>> 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* は *path-like object* で、開くファイルのパス名 (絶対パスまた
   は現在の作業ディレクトリからの相対パス) あるいはラップするファイル
   の整数のファイルデスクリプタを与えます。 (ファイルデスクリプタが与
   えられた場合、 *closefd* が "False" に設定されていないかぎり、この
   関数が返す I/O オブジェクトがクローズされるときにファイルデスクリプ
   タもクローズされます。)

   *mode* オプション文字列はファイルが開かれる際のモードを指定します。
   デフォルトは "'r'" で、読み込み用にテキストモードで開くという意味で
   す。その他によく使われるモードとして、書き込み用の "'w'" (ファイル
   が既に存在する場合は上書きします) 、排他的な生成をあらわす "'x'" 、
   そして追記用の "'a'" ( *いくつかの* Unix システムでは、 *すべての*
   書き込みは現在のシーク位置にかかわらずファイルの末尾に追記する、と
   いう意味です) です。テキストモードで *encoding* が指定されない場合
   に使われるエンコーディングは、プラットフォーム依存です: 現在のロケ
   ールエンコーディングを取得するために "locale.getencoding()" が呼ば
   れます。 (生のバイトデータを読み書きする際にはバイナリモードを使い
   、 *encoding* は指定しません。) 指定できるモードは以下の通りです:

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

   デフォルトのモードは "'r'" (テキストの読み込み用に開く、 "'rt'" と
   同義) です。 "'w+'" と "'w+b'" はファイルを開いて上書きします。
   "'r+'" と "'r+b'" はファイルを上書きせずに開きます。

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

   注釈:

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

   *buffering* はオプションの整数で、バッファリングのポリシーを設定す
   るために使われます。  バッファリングを無効化するためには0を渡してく
   ださい (バイナリモードでのみ設定可能です)。また行単位でのバッファリ
   ングには1を設定してください (テキストモードでの書き込み時のみ有効で
   す)。固定サイズのチャンクバッファに対するサイズをバイト単位で指定し
   たい場合は、1より大きい整数を渡してください。この形式でバッファサイ
   ズを指定した場合、バイナリ形式でバッファリングをサポートする I/O
   (buffered I/O) にはそのまま適用されますが、 "TextIOWrapper" (すなわ
   ち "mode='r+'" のモードでオープンされたファイル) では別のバッファリ
   ングを行うかもしれません。 "TextIOWrapper" でバッファリングを無効化
   するには、 "io.TextIOWrapper.reconfigure()" で "write_through" フラ
   グを使うことを検討してください。 *buffering* 引数が与えられなかった
   場合、デフォルトのバッファリングポリシーは以下のように動作します:

   * Binary files are buffered in fixed-size chunks; the size of the
     buffer is chosen using a heuristic trying to determine the
     underlying device's "block size" and falling back on
     "io.DEFAULT_BUFFER_SIZE".  On many systems, the buffer will
     typically be 4096 or 8192 bytes long.

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

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

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

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

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

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

   * "'surrogateescape'" は正しくないバイト列をユニコードの下位サロゲ
     ート領域のうち U+DC80 から U+DCFF の範囲のコードユニットであらわ
     します。データの書き込み時に "surrogateescape" エラーハンドラが使
     われると、これらのサロゲートコードユニットは元と同じバイト列に変
     換されます。これはエンコーディングが不明なファイルを処理するのに
     便利です。

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

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

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

   *newline* はストリームから受け取った改行文字をどのようにパースする
   かを決定します。 "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)  # ファイル記述子の解放漏れがないように

   "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" などの、ファイル操作モジュール
   も参照してください。

   引数 "path", "mode", "flags" を指定して 監査イベント "open" を送出
   します。

   "mode" と "flags" の2つの引数は呼び出し時の値から修正されたり、推量
   により設定されたりする可能性があります。

   バージョン 3.3 で変更:

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

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

   * 以前は "IOError" が送出されました; それは現在 "OSError" のエイリ
     アスです。

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

   バージョン 3.4 で変更:

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

   バージョン 3.5 で変更:

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

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

   バージョン 3.6 で変更:

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

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

   バージョン 3.11 で変更: "'U'" モードは削除されました。

ord(c)

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

pow(base, exp, mod=None)

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

   引数は数値型でなければなりません。型混合の場合、二項算術演算におけ
   る型強制規則が適用されます。 "int" オペランドの場合、第2引数が負で
   ない限り、結果は (型強制後の) オペランドと同じ型になります; 第2引数
   が負の場合、全ての引数は浮動小数点数に変換され、浮動小数点数の結果
   が返されます。例えば、 "pow(10, 2)" は "100" を返しますが、
   "pow(10, -2)" は "0.01" を返します。底が "int" 型または "float" 型
   で負の値であり、かつ指数が整数でない場合、複素数の結果が返されます
   。例えば、 "pow(-9, 0.5)" は "3j" に近い値を返します。一方で底が
   "int" 型または "float" の負の数であり、指数が整数の場合、浮動小数点
   数の結果が返されます。例えば、"pow(-9, 2.0)" は "81.0" を返します。

   *base* と *exp* が "int" オペランドで *mod* が存在するとき、 *mod*
   もまた整数型でなければならず、かつゼロであってはいけません。 *mod*
   が存在して *exp* が負の整数の場合、 *base* は *mod* と互いに素 (最
   大公約数が1) でなければなりません。この場合、 *inv_base* を *base*
   に対する *mod* を法とするモジュラ逆数 (*base* と *inv_base* の積を
   *mod* で割った余りが1になるような数) として、 "pow(inv_base, -exp,
   mod)" が返されます。

   以下は "97" を法とする "38" のモジュラ逆数の計算例です:

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

   バージョン 3.8 で変更: "int" オペランドに対して、三引数形式の "pow"
   で第二引数に負の値を取ることができるようになりました。これによりモ
   ジュラ逆数の計算が可能になります。

   バージョン 3.8 で変更: キーワード引数を取ることができるようになりま
   した。以前は位置引数だけがサポートされていました。

print(*objects, sep=' ', end='\n', file=None, 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()" を *デコレータ* とし
   て使えば、読み出し専用 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." に設定します。

   @getter

   @setter

   @deleter

      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 で変更: 属性オブジェクトのドックストリングが書き込み
   可能になりました。

class range(stop)
class range(start, stop, step=1)

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

repr(object)

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

   このクラスは、eval 評価可能な独自の representation を持ちます:

      class Person:
         def __init__(self, name, age):
            self.name = name
            self.age = age

         def __repr__(self):
            return f"Person('{self.name}', {self.age})"

reversed(seq)

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

round(number, ndigits=None)

   *number* を小数点以下 *ndigits* 桁の精度で丸めた値を返します。
   *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
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" と等価です。

   "__getattribute__()" のカスタマイズや "__slots__" を通じてオブジェ
   クトが強制していない限り、 *name* は 識別子 (identifier) およびキー
   ワード (keyword) で定義されている Python 識別子である必要はありませ
   ん。属性名が識別子でない場合、ドットを使った属性へのアクセスはでき
   ませんが、 "getattr()" などを通じてアクセス可能です。

   注釈:

     プライベートな名前のマングリング はコンパイル時に行われます。その
     ため、プライベートな属性 (先頭に2つのアンダースコアを伴う名前を持
     つ属性) の値を "setattr()" でセットするためには、属性名を手動でマ
     ングリングする必要があります。

class slice(stop)
class slice(start, stop, step=None)

   "range(start, stop, step)" で指定されたインデックスのセットを表す
   *slice* オブジェクトを返します。  引数 *start* と *step* のデフォル
   トは "None" です。

   start

   stop

   step

      スライスオブジェクトには読み出し専用のデータ属性 "start" "stop"
      "step" があり、これらは単に引数の値（またはそのデフォルト値）を
      返します。  スライスオブジェクトは特に他の機能を持ちませんが、
      NumPy や他のサードパーティパッケージで使われています。

   スライスオブジェクトは、拡張インデックス構文が使われた場合にも作ら
   れます。  例： "a[start:stop:step]" や "a[start:stop, i]" 。
   *iterator* を返す代替バージョンについては "itertools.islice()" を参
   照して下さい。

   バージョン 3.12 で変更: スライスオブジェクトが *hashable* (ハッシュ
   可能) となりました (ただし、属性 "start" 、 "stop" 、 "step" がすべ
   てハッシュ可能である場合に限ります)。

sorted(iterable, /, *, key=None, reverse=False)

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

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

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

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

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

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

   ソートアルゴリズムは、要素間の比較に "<" 演算子だけを使います。した
   がってソートのためには "__lt__()" メソッドを定義すれば十分なはずで
   すが、 **PEP 8** は6つの 比較演算子 を全て実装することを推奨してい
   ます。これにより、異なるメソッドを必要とする "max()" のような他のソ
   ートツールを、同じデータに対して適用することによって起こりうるバグ
   を避ける助けになります。6つの比較演算子を全て実装することは、リフレ
   クションによって "__gt__()" メソッドを呼び出す可能性のある型混合の
   比較での混乱を避けることにも役立ちます。

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

@staticmethod

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

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

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

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

   静的メソッドは ("C.f()" のように) クラスに対して呼び出すことも、
   ("C().f()" のように) インスタンスに対して呼び出すこともできます。さ
   らに、静的メソッド *descriptor* は呼び出し可能でもあるため、("f()"
   のように) クラス定義の中でも使用できます。

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

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

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

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

   バージョン 3.10 で変更: Static methods now inherit the method
   attributes ("__module__", "__name__", "__qualname__", "__doc__" and
   "__annotations__"), have a new "__wrapped__" attribute, and are now
   callable as regular functions.

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

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

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

sum(iterable, /, start=0)

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

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

   バージョン 3.8 で変更: *start* パラメータをキーワード引数として指定
   することができるようになりました。

   バージョン 3.12 で変更: Summation of floats switched to an
   algorithm that gives higher accuracy on most builds.

class super
class super(type, object_or_type=None)

   メソッドの呼び出しを *type* の親または兄弟クラスに委譲するプロキシ
   オブジェクトを返します。これはクラスの中でオーバーライドされた継承
   メソッドにアクセスするのに便利です。

   *object_or_type* はメソッドの検索のための *method resolution order*
   (メソッド解決順序) を決定します。検索は *type* 直後のクラスから開始
   します。

   For example, if "__mro__" of *object_or_type* is "D -> B -> C -> A
   -> object" and the value of *type* is "B", then "super()" searches
   "C -> A -> object".

   The "__mro__" attribute of the class corresponding to
   *object_or_type* lists the method resolution search order used by
   both "getattr()" and "super()".  The attribute is dynamic and can
   change whenever the inheritance hierarchy is updated.

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

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

   2つ目の用途は動的な実行環境において協調的 (cooperative) な多重継承
   をサポートすることです。これは Python に特有の用途で、静的にコンパ
   イルされる言語や、単継承のみをサポートする言語には見られないもので
   す。この機能により、同じ名前のメソッドを実装する複数の基底クラスを
   使った "ダイヤモンド型* の継承構造を実装することができます。良い設
   計は、そのような実装において、どのような場合でも同じ呼び出しシグネ
   チャを持つように強制します。 (理由は呼び出しの順序が実行時に決定さ
   れること、呼び出し順序はクラス階層構造の変化に順応すること、そして
   呼び出し順序が実行時まで未知の兄弟クラスが含まれる場合があることで
   す)。

   両方の用途において、典型的なスーパークラスの呼び出しは次のようにな
   ります:

      class C(B):
          def method(self, arg):
              super().method(arg)    # これは次と同じことを行います:
                                     # super(C, self).method(arg)

   メソッドのルックアップに加えて、 "super()" は属性のルックアップに対
   しても同様に動作します。考えうる用途のひとつは親クラスや兄弟クラス
   の *descriptors* (デスクリプタ) を呼び出すことです。

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

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

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

class tuple
class tuple(iterable)

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

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

   With one argument, return the type of an *object*.  The return
   value is a type object and generally the same object as returned by
   "object.__class__".

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

   With three arguments, return a new type object.  This is
   essentially a dynamic form of the "class" statement. The *name*
   string is the class name and becomes the "__name__" attribute. The
   *bases* tuple contains the base classes and becomes the "__bases__"
   attribute; if empty, "object", the ultimate base of all classes, is
   added.  The *dict* dictionary contains attribute and method
   definitions for the class body; it may be copied or wrapped before
   becoming the "__dict__" attribute. The following two statements
   create identical "type" objects:

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

   下記を参照してください。

   * Documentation on attributes and methods on classes.

   * 型オブジェクト

   三引数形式の呼び出しに与えられたキーワード引数は、(*metaclass* を除
   く) クラス定義におけるキーワード引数と同様に、適切なメタクラスの機
   構 (通常は "__init_subclass__()") に渡されます。

   クラス生成をカスタマイズする も参照してください。

   バージョン 3.6 で変更: Subclasses of "type" which don't override
   "type.__new__" may no longer use the one-argument form to get the
   type of an object.

vars()
vars(object)

   Return the "__dict__" attribute for a module, class, instance, or
   any other object with a "__dict__" attribute.

   Objects such as modules and instances have an updateable "__dict__"
   attribute; however, other objects may have write restrictions on
   their "__dict__" attributes (for example, classes use a
   "types.MappingProxyType" to prevent direct dictionary updates).

   Without an argument, "vars()" acts like "locals()".  Note, the
   locals dictionary is only useful for reads since updates to the
   locals dictionary are ignored.

   指定されたオブジェクトに "__dict__" 属性がない場合 (たとえばそのク
   ラスが "__slots__" 属性を定義している場合)、 "TypeError" 例外が送出
   されます。

zip(*iterables, strict=False)

   複数のイテラブルを並行に反復処理し、各イテラブルの要素からなるタプ
   ルを生成します。

   以下はプログラム例です:

      >>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
      ...     print(item)
      ...
      (1, 'sugar')
      (2, 'spice')
      (3, 'everything nice')

   より正式な定義: "zip()" は、 *i* 番目のタプルが 引数に与えた各イテ
   ラブルの *i* 番目の要素を含むような、タプルのイテレータを返します。

   "zip()" に対する別の考え方は、この関数は行を列に、また列を行に変換
   するということです。これは 行列の転置 とよく似ています。

   "zip()" は遅延評価です: イテラブルが "for" ループに渡されたり、
   "list" でラップされたりするなどして反復処理されるまで、要素が実際に
   処理されることはありません。

   ここで考慮すべきことは、 "zip()" に渡されるイテラブルが異なる長さを
   持つことがあるという点です; ときには意図的な場合もあり、またときに
   はイテラブルを準備するコードにおけるバグのこともあるでしょう。
   Python はこの問題に対して3つの異なるアプローチを提供します:

   * デフォルトでは、 "zip()" は最も短いイテラブルが消費しきった時点で
     停止します。より繰り返し数の長いイテラブルの残りの要素は無視して
     、結果を最も短いイテラブルの長さに切り詰めます:

        >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
        [(0, 'fee'), (1, 'fi'), (2, 'fo')]

   * "zip()" は、しばしば受け取ったイテラブルが全て同じ長さであるとい
     う想定の下で使われます。そのような場合、 "strict=True" オプション
     の利用が推奨されます。その出力は通常の "zip()" と同じです:

        >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
        [('a', 1), ('b', 2), ('c', 3)]

     しかし、デフォルトの動作と異なり、あるイテラブルが他のイテラブル
     よりも先に消費しきった場合に "ValueError" 例外を送出します:

     >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
     ...     print(item)
     ...
     (0, 'fee')
     (1, 'fi')
     (2, 'fo')
     Traceback (most recent call last):
       ...
     ValueError: zip() argument 2 is longer than argument 1

     "strict=True" 引数なしの場合、長さの異なるイテラブルを生じる原因
     となるいかなるバグも、この時点では問題なく処理されます。そして代
     わりにプログラムの別の場所で、原因を特定しにくいバグとして検出さ
     れることになるでしょう。

   * 短いイテラブルを一定の値でパディングして全てのイテラブルが同じ長
     さになるようにすることもできます。この機能は
     "itertools.zip_longest()" で提供されます。

   エッジケース: 引数としてイテラブルをひとつだけ渡した場合、 "zip()"
   は 1 タプルのイテレータを返します。引数なしの場合は空のイテレータを
   返します。

   ヒントとコツ:

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

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

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

   バージョン 3.10 で変更: "strict" 引数が追加されました。

__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 に変更されます)。

   バージョン 3.9 で変更: コマンドラインオプション "-E" or "-I" が指定
   された場合、環境変数 "PYTHONCASEOK" は無視されるようになりました。

-[ 脚注 ]-

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