組み込み関数—Pythonドキュメント

組み込み関数

Pythonインタープリターには、常に使用可能な多くの関数と型が組み込まれています。 ここではアルファベット順にリストされています。

		組み込み関数
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	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()

abs(x)

数値の絶対値を返します。 引数は整数または浮動小数点数です。 引数が複素数の場合、その大きさが返されます。 x が__abs__()を定義している場合、abs(x)はx.__abs__()を返します。

all(iterable)

iterable のすべての要素がtrueの場合（またはiterableが空の場合）、Trueを返します。 に相当：

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

any(iterable)

iterable のいずれかの要素がtrueの場合、Trueを返します。 イテラブルが空の場合は、Falseを返します。 に相当：

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

ascii(object)

repr（）として、オブジェクトの印刷可能な表現を含む文字列を返しますが、\xを使用して、 repr（）によって返される文字列内の非ASCII文字をエスケープします。 、\uまたは\Uはエスケープします。 これにより、Python2の 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([x])

ブール値を返します。 TrueまたはFalseのいずれか。 x は、標準の真理テスト手順を使用して変換されます。 x がfalseまたは省略されている場合、これはFalseを返します。 それ以外の場合は、Trueを返します。 bool クラスは、 int のサブクラスです（数値型— int、float、complex を参照）。 これ以上サブクラス化することはできません。 その唯一のインスタンスはFalseとTrueです（ブール値を参照）。

バージョン3.7で変更： x は位置のみのパラメーターになりました。

breakpoint(*args, **kws)

この関数は、呼び出しサイトのデバッガーに移動します。 具体的には、 sys.breakpointhook（）を呼び出し、argsとkwsを直接通過させます。 デフォルトでは、sys.breakpointhook()は引数を期待せずに pdb.set_trace（）を呼び出します。 この場合、これは純粋に便利な関数であるため、 pdb を明示的にインポートしたり、デバッガーに入るのに多くのコードを入力したりする必要はありません。 ただし、 sys.breakpointhook（）は他の関数に設定でき、 breakpoint（）は自動的にそれを呼び出すため、選択したデバッガーにドロップできます。

バージョン3.7の新機能。

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

バイトの新しい配列を返します。 NS bytearray classは、0 <= x <256の範囲の整数の可変シーケンスです。 可変シーケンスタイプで説明されている、可変シーケンスの通常のメソッドのほとんどと、バイトタイプのほとんどのメソッドがあります。バイトとバイトアレイ操作を参照してください。 ]。

オプションの source パラメーターを使用して、いくつかの異なる方法でアレイを初期化できます。

• 文字列の場合は、エンコーディング（およびオプションでエラー）パラメーターも指定する必要があります。 次に、 bytearray（）は、 str.encode（）を使用して文字列をバイトに変換します。

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

• バッファインターフェイスに準拠するオブジェクトの場合、オブジェクトの読み取り専用バッファがバイト配列の初期化に使用されます。

• iterable の場合、配列の初期コンテンツとして使用される0 <= x < 256の範囲の整数の反復可能である必要があります。

引数がない場合、サイズ0の配列が作成されます。

バイナリシーケンスタイプ—バイト、バイトアレイ、メモリビューおよびバイトアレイオブジェクトも参照してください。

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

0 <= x < 256の範囲の整数の不変シーケンスである新しい「bytes」オブジェクトを返します。 bytes は bytearray の不変バージョンであり、同じ非変更メソッドと同じインデックス作成およびスライス動作を備えています。

したがって、コンストラクター引数は bytearray（）と同様に解釈されます。

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

バイナリシーケンスタイプ—バイト、バイトアレイ、メモリビュー、バイトオブジェクト、およびバイトおよびバイトアレイ操作も参照してください。

callable(object)

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

バージョン3.2の新機能：この関数は最初にPython 3.0で削除され、次にPython3.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（）を参照してください。

クラスメソッドの詳細については、標準タイプ階層を参照してください。

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

source をコードまたはASTオブジェクトにコンパイルします。 コードオブジェクトは、 exec（）または eval（）で実行できます。 source は、通常の文字列、バイト文字列、またはASTオブジェクトのいずれかです。 ASTオブジェクトの操作方法については、 ast モジュールのドキュメントを参照してください。

filename 引数は、コードが読み取られたファイルを指定する必要があります。 ファイルから読み取られなかった場合は、認識可能な値を渡します（'<string>'が一般的に使用されます）。

mode 引数は、コンパイルする必要のあるコードの種類を指定します。 source が一連のステートメントで構成されている場合は、'exec'、単一の式で構成されている場合は'eval'、単一の対話型ステートメント（後者の場合、None以外に評価される式ステートメントが出力されます）。

オプションの引数フラグおよび dont_inherit は、将来のステートメントがソースのコンパイルに影響を与えるかどうかを制御します。 どちらも存在しない場合（または両方がゼロの場合）、コードは compile（）を呼び出しているコードで有効な将来のステートメントを使用してコンパイルされます。 flags 引数が指定され、 dont_inherit が指定されていない（またはゼロである）場合、 flags 引数で指定された将来のステートメントが使用されます。とにかく使用されます。 dont_inherit がゼロ以外の整数の場合、 flags 引数はそれです–コンパイルの呼び出しの周りで有効な将来のステートメントは無視されます。

将来のステートメントは、複数のステートメントを指定するためにビットごとに論理和をとることができるビットによって指定されます。 特定の機能を指定するために必要なビットフィールドは、 __ future __ モジュールの_Featureインスタンスのcompiler_flag属性として見つけることができます。

オプションの引数 flags は、コンパイルされたソースにトップレベルのawait、async for、およびasync withを含めることを許可するかどうかも制御します。 ビットast.PyCF_ALLOW_TOP_LEVEL_AWAITが設定されている場合、戻りコードオブジェクトはco_codeにCO_COROUTINEが設定されており、await eval(code_object)を介してインタラクティブに実行できます。

引数 optimize は、コンパイラーの最適化レベルを指定します。 -1のデフォルト値は、 -O オプションで指定されたインタープリターの最適化レベルを選択します。 明示的なレベルは、0（最適化なし、__debug__がtrue）、1（アサートが削除され、__debug__がfalse）、または2です。 （docstringも削除されます）。

この関数は、コンパイルされたソースが無効な場合は SyntaxError を発生させ、ソースにnullバイトが含まれている場合は ValueError を発生させます。

PythonコードをそのAST表現に解析する場合は、 ast.parse（）を参照してください。

ノート

'single'または'eval'モードで複数行コードを含む文字列をコンパイルする場合、入力は少なくとも1つの改行文字で終了する必要があります。 これは、 code モジュール内の不完全なステートメントと完全なステートメントの検出を容易にするためです。

警告

PythonのASTコンパイラではスタックの深さの制限があるため、ASTオブジェクトにコンパイルするときに、十分に大きい/複雑な文字列でPythonインタープリタをクラッシュさせる可能性があります。

バージョン3.2で変更： WindowsおよびMacの改行の使用を許可。 また、'exec'モードでの入力は、改行で終了する必要がなくなりました。 optimize パラメーターを追加しました。

バージョン3.5で変更：以前は、ソースでnullバイトが検出されたときに TypeError が発生していました。

バージョン3.8の新機能： ast.PyCF_ALLOW_TOP_LEVEL_AWAITをフラグで渡して、トップレベルのawait、async for、およびasync withのサポートを有効にできるようになりました]。

class complex([real[, imag]])

値が real + imag * 1jの複素数を返すか、文字列または数値を複素数に変換します。 最初のパラメーターが文字列の場合、それは複素数として解釈され、関数は2番目のパラメーターなしで呼び出す必要があります。 2番目のパラメーターを文字列にすることはできません。 各引数は、任意の数値型（複合を含む）にすることができます。 imag を省略すると、デフォルトでゼロになり、コンストラクターは int や float のように数値変換として機能します。 両方の引数を省略した場合は、0jを返します。

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

ノート

文字列から変換する場合、文字列の中央の+または-演算子の周囲に空白を含めることはできません。 たとえば、complex('1+2j')は問題ありませんが、complex('1 + 2j')は ValueError を発生させます。

複素数型については、数値型— int、float、complex で説明されています。

バージョン3.6で変更：コードリテラルのようにアンダースコアを使用して数字をグループ化できます。

バージョン3.8で変更：__complex__()および__float__()が定義されていない場合、は__index__()にフォールバックします。

delattr(object, name)

これは setattr（）の親戚です。 引数はオブジェクトと文字列です。 文字列は、オブジェクトの属性の1つの名前である必要があります。 オブジェクトで許可されている場合、関数は名前付き属性を削除します。 たとえば、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 
['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)

列挙オブジェクトを返します。 iterable は、シーケンス、 iterator 、または反復をサポートするその他のオブジェクトである必要があります。 enumerate（）によって返されるイテレータの __ next __（）メソッドは、カウント（ start からデフォルトで0）とから取得された値を含むタプルを返します。 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[, locals]])

引数は文字列とオプションのグローバルおよびローカルです。 指定する場合、 globals は辞書である必要があります。 提供されている場合、 locals は任意のマッピングオブジェクトにすることができます。

expression 引数は、 globals および locals 辞書をグローバルおよびローカル名前空間として使用して、Python式（技術的には条件リスト）として解析および評価されます。 globals ディクショナリが存在し、キー__builtins__の値が含まれていない場合、組み込みモジュール builtins のディクショナリへの参照がその下に挿入されます式が解析される前のキー。 これは、 expression が通常、標準の builtins モジュールへのフルアクセスを持ち、制限された環境が伝播されることを意味します。 locals ディクショナリを省略すると、デフォルトで globals ディクショナリになります。 両方の辞書を省略した場合、 eval（）が呼び出される環境で、 globals および locals を使用して式が実行されます。 eval（）は、囲んでいる環境のネストされたスコープ（非ローカル）にアクセスできないことに注意してください。

戻り値は、評価された式の結果です。 構文エラーは例外として報告されます。 例：

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

この関数は、任意のコードオブジェクト（ compile（）によって作成されたものなど）を実行するためにも使用できます。 この場合、文字列の代わりにコードオブジェクトを渡します。 コードオブジェクトが'exec'を mode 引数としてコンパイルされている場合、 eval（） 'の戻り値はNoneになります。

ヒント：ステートメントの動的実行は、 exec（）関数でサポートされています。 globals（）関数と locals（）関数は、それぞれ現在のグローバル辞書とローカル辞書を返します。これは、 eval（）で使用するために渡すのに便利です。または exec（）。

リテラルのみを含む式で文字列を安全に評価できる関数については、 ast.literal_eval（）を参照してください。

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

この関数は、Pythonコードの動的実行をサポートします。 object は、文字列またはコードオブジェクトのいずれかである必要があります。 文字列の場合、文字列はPythonステートメントのスイートとして解析され、実行されます（構文エラーが発生しない限り）。 1 コードオブジェクトの場合は、単純に実行されます。 いずれの場合も、実行されるコードはファイル入力として有効であることが期待されます（リファレンスマニュアルの「ファイル入力」のセクションを参照）。 nonlocal 、 yield 、および return ステートメントは、 execに渡されるコードのコンテキスト内であっても、関数定義の外部で使用できないことに注意してください。 （）関数。 戻り値はNoneです。

いずれの場合も、オプション部分を省略した場合、コードは現在のスコープで実行されます。 globals のみが提供されている場合は、グローバル変数とローカル変数の両方に使用されるディクショナリ（ディクショナリのサブクラスではない）である必要があります。 globals と locals が指定されている場合、それらはそれぞれグローバル変数とローカル変数に使用されます。 提供されている場合、 locals は任意のマッピングオブジェクトにすることができます。 モジュールレベルでは、グローバルとローカルは同じディクショナリであることを忘れないでください。 execが globals と locals として2つの別個のオブジェクトを取得した場合、コードはクラス定義に埋め込まれているかのように実行されます。

globals ディクショナリにキー__builtins__の値が含まれていない場合、組み込みモジュール builtins のディクショナリへの参照がそのキーの下に挿入されます。 このようにして、 exec（）に渡す前に、独自の__builtins__ディクショナリを globals に挿入することにより、実行されたコードで使用できるビルトインを制御できます。

ノート

組み込み関数 globals（）および locals（）は、それぞれ現在のグローバル辞書とローカル辞書を返します。これは、次の2番目と3番目の引数として使用するために渡すのに役立ちます。 exec（）。

ノート

デフォルトの locals は、以下の関数 locals（）で説明されているように機能します。デフォルトの locals ディクショナリへの変更は試みないでください。 関数 exec（）が戻った後、 locals に対するコードの影響を確認する必要がある場合は、明示的な locals ディクショナリを渡します。

filter(function, iterable)

function がtrueを返す iterable の要素からイテレーターを作成します。 iterable は、シーケンス、反復をサポートするコンテナー、またはイテレーターのいずれかです。 function がNoneの場合、恒等関数が想定されます。つまり、falseである iterable のすべての要素が削除されます。

filter(function, iterable)は、関数がNoneでない場合はジェネレータ式(item for item in iterable if function(item))と同等であり、関数がNoneの場合は(item for item in iterable if item)と同等であることに注意してください。

function がfalseを返す iterable の要素を返す補完関数については、 itertools.filterfalse（）を参照してください。

class float([x])

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

引数が文字列の場合は、10進数を含める必要があり、オプションで記号を前に付け、オプションで空白に埋め込む必要があります。 オプションの記号は、'+'または'-'です。 '+'記号は、生成される値に影響を与えません。 引数は、NaN（数値ではない）を表す文字列、または正または負の無限大にすることもできます。 より正確には、先頭と末尾の空白文字が削除された後、入力は次の文法に準拠する必要があります。

 サイン           ::=  "+" | "-"
 無限大       ::=  "Infinity" | "inf"
  nan            ::=  "nan"
  numeric_value  ::=  floatnumber | infinity | nan
  numeric_string ::=  [sign] numeric_value

ここで、floatnumberは、浮動小数点リテラルで説明されているPython浮動小数点リテラルの形式です。 大文字と小文字は区別されないため、たとえば、「inf」、「Inf」、「INFINITY」、「iNfINity」はすべて、正の無限大のスペルとして受け入れられます。

それ以外の場合、引数が整数または浮動小数点数の場合、同じ値（Pythonの浮動小数点精度内）の浮動小数点数が返されます。 引数がPythonfloatの範囲外の場合、 OverflowError が発生します。

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

引数が指定されていない場合は、0.0が返されます。

例：

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

float型については、数値型— int、float、complex で説明されています。

バージョン3.6で変更：コードリテラルのようにアンダースコアを使用して数字をグループ化できます。

バージョン3.7で変更： x は位置のみのパラメーターになりました。

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

format(value[, format_spec])

value を、 format_spec の制御に従って、「フォーマットされた」表現に変換します。 format_spec の解釈は、 value 引数のタイプによって異なりますが、ほとんどの組み込みタイプで使用される標準のフォーマット構文があります。 Format Specification Mini-言語。

デフォルトの format_spec は空の文字列であり、通常は str（value）を呼び出すのと同じ効果があります。

format(value, format_spec)の呼び出しは、type(value).__format__(value, format_spec)に変換され、値の__format__()メソッドを検索するときにインスタンスディクショナリをバイパスします。 メソッド検索が object に到達し、 format_spec が空でない場合、または format_spec または戻り値は文字列ではありません。

バージョン3.4で変更： format_spec が空の文字列でない場合、 object().__format__(format_spec)は TypeError を発生させます。

class frozenset([iterable])

新しい frozenset オブジェクトを返します。オプションで、 iterable から取得した要素を使用します。 frozensetは組み込みクラスです。 このクラスのドキュメントについては、フリーズセットおよびセットタイプ—セット、フリーズセットを参照してください。

その他のコンテナについては、組み込みの set 、 list 、 tuple 、 dict クラス、およびコレクションを参照してください。 モジュール。

getattr(object, name[, default])

オブジェクトの名前付き属性の値を返します。 name は文字列である必要があります。 文字列がオブジェクトの属性の1つの名前である場合、結果はその属性の値になります。 たとえば、getattr(x, 'foobar')はx.foobarと同等です。 指定された属性が存在しない場合は、 default が返されます。存在しない場合は、 AttributeError が発生します。

globals()

現在のグローバルシンボルテーブルを表すディクショナリを返します。 これは常に現在のモジュールのディクショナリです（関数またはメソッド内では、これはそれが定義されているモジュールであり、呼び出されたモジュールではありません）。

hasattr(object, name)

引数はオブジェクトと文字列です。 結果は、文字列がオブジェクトの属性の1つの名前である場合はTrueであり、そうでない場合はFalseです。 （これは、getattr(object, name)を呼び出して、 AttributeError が発生するかどうかを確認することで実装されます。）

hash(object)

オブジェクトのハッシュ値を返します（オブジェクトがある場合）。 ハッシュ値は整数です。 これらは、辞書検索中に辞書キーをすばやく比較するために使用されます。 等しいと比較される数値は、同じハッシュ値を持ちます（1と1.0の場合のように、それらが異なるタイプであっても）。

ノート

カスタム__hash__()メソッドを持つオブジェクトの場合、 hash（）は、ホストマシンのビット幅に基づいて戻り値を切り捨てることに注意してください。 詳細については、__hash__()を参照してください。

help([object])

組み込みのヘルプシステムを起動します。 （この関数はインタラクティブな使用を目的としています。）引数が指定されていない場合、インタラクティブヘルプシステムがインタプリタコンソールで起動します。 引数が文字列の場合、その文字列はモジュール、関数、クラス、メソッド、キーワード、またはドキュメントトピックの名前として検索され、ヘルプページがコンソールに出力されます。 引数が他の種類のオブジェクトの場合、オブジェクトのヘルプページが生成されます。

関数のパラメーターリストにスラッシュ（/）が表示されている場合、 help（）を呼び出すと、スラッシュの前のパラメーターは位置のみであることを意味します。 詳細については、位置のみのパラメータに関するFAQエントリを参照してください。

この関数は、 site モジュールによって組み込み名前空間に追加されます。

バージョン3.4での変更： pydoc および inspect への変更は、呼び出し可能オブジェクトの報告された署名がより包括的で一貫性があることを意味します。

hex(x)

整数を「0x」で始まる小文字の16進文字列に変換します。 x がPython int オブジェクトでない場合は、整数を返す__index__()メソッドを定義する必要があります。 いくつかの例：

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

整数をプレフィックス付きの大文字または小文字の16進文字列に変換する場合は、次のいずれかの方法を使用できます。

>>> '%#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（）も参照してください。

ノート

floatの16進文字列表現を取得するには、 float.hex（）メソッドを使用します。

id(object)

オブジェクトの「ID」を返します。 これは、その存続期間中、このオブジェクトに対して一意で一定であることが保証されている整数です。 ライフタイムが重複しない2つのオブジェクトは、同じ id（）値を持つ場合があります。

input([prompt])

prompt 引数が存在する場合、末尾の改行なしで標準出力に書き込まれます。 次に、この関数は入力から行を読み取り、それを文字列に変換して（末尾の改行を削除して）、それを返します。 EOFを読み取ると、 EOFError が発生します。 例：

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

readline モジュールがロードされている場合、 input（）はそれを使用して、複雑な行編集および履歴機能を提供します。

class int([x])
class int(x, base=10)

数値または文字列 x から構築された整数オブジェクトを返すか、引数が指定されていない場合は0を返します。 x が__int__()を定義している場合、int(x)はx.__int__()を返します。 x が__index__()を定義している場合、x.__index__()を返します。 x が__trunc__()を定義している場合、x.__trunc__()を返します。 浮動小数点数の場合、これはゼロに向かって切り捨てられます。

x が数値でない場合、または base が指定されている場合、 x は文字列、 bytes 、または bytearrayである必要があります基数ベースの整数リテラルを表すインスタンス。 オプションで、リテラルの前に+または-（間にスペースを入れない）を付け、空白で囲むことができます。 基数nリテラルは、0からn-1の数字で構成され、aからz（またはAからZ）の値は10から35です。 。 デフォルトのベースは10です。 許可される値は0および2〜36です。 Base-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 __ [がある場合X138X]メソッド、そのメソッドは、ベースの整数を取得するために呼び出されます。 以前のバージョンでは、 base .__ index __ の代わりに base .__ int __ が使用されていました。

バージョン3.6で変更：コードリテラルのようにアンダースコアを使用して数字をグループ化できます。

バージョン3.7で変更： x は位置のみのパラメーターになりました。

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

isinstance(object, classinfo)

object 引数が classinfo 引数、またはその（直接、間接、または仮想）サブクラスのインスタンスである場合は、Trueを返します。 object が指定されたタイプのオブジェクトでない場合、関数は常にFalseを返します。 classinfo がタイプオブジェクトのタプル（または再帰的に他のそのようなタプル）である場合、 object がいずれかのタイプのインスタンスである場合はTrueを返します。 classinfo がタイプまたはタイプのタプルではなく、そのようなタプルである場合、 TypeError 例外が発生します。

issubclass(class, classinfo)

class が classinfo のサブクラス（直接、間接、または仮想）の場合、Trueを返します。 クラスはそれ自体のサブクラスと見なされます。 classinfo は、クラスオブジェクトのタプルである可能性があります。その場合、 classinfo のすべてのエントリがチェックされます。 それ以外の場合は、 TypeError 例外が発生します。

iter(object[, sentinel])

イテレータオブジェクトを返します。 最初の引数は、2番目の引数の存在に応じて非常に異なって解釈されます。 2番目の引数がない場合、 object は、反復プロトコル（__iter__()メソッド）をサポートするコレクションオブジェクトであるか、シーケンスプロトコル（__getitem__()メソッドと0で始まる整数引数）。 これらのプロトコルのいずれもサポートしていない場合、 TypeError が発生します。 2番目の引数 sentinel が指定されている場合、 object は呼び出し可能なオブジェクトである必要があります。 この場合に作成されたイテレータは、 __ next __（）メソッドへの呼び出しごとに引数なしでオブジェクトを呼び出します。 返される値が sentinel と等しい場合、 StopIteration が発生します。それ以外の場合、値が返されます。

イテレータタイプも参照してください。

iter（）の2番目の形式の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)

オブジェクトの長さ（アイテムの数）を返します。 引数は、シーケンス（文字列、バイト、タプル、リスト、範囲など）またはコレクション（辞書、セット、フリーズセットなど）の場合があります。

class list([iterable])

list は、 Lists および Sequence Types — list、tuple、range に記載されているように、関数ではなく、実際には変更可能なシーケンスタイプです。

locals()

現在のローカルシンボルテーブルを表すディクショナリを更新して返します。 自由変数は、関数ブロックで呼び出されたときに locals（）によって返されますが、クラスブロックでは返されません。 モジュールレベルでは、 locals（）と globals（）は同じ辞書であることに注意してください。

ノート

この辞書の内容は変更しないでください。 変更は、インタプリタが使用するローカル変数と自由変数の値に影響を与えない場合があります。

map(function, iterable, ...)

function を iterable のすべての項目に適用するイテレーターを返し、結果を生成します。 追加の iterable 引数が渡された場合、 function はその数の引数を取る必要があり、すべてのiterableからのアイテムに並行して適用されます。 複数のイテレータを使用すると、最短のイテレータが使い果たされるとイテレータが停止します。 関数入力がすでに引数タプルに配置されている場合は、 itertools.starmap（）を参照してください。

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

反復可能な最大のアイテム、または2つ以上の引数の最大のものを返します。

位置引数が1つ指定されている場合は、 iterable である必要があります。 iterableの最大のアイテムが返されます。 2つ以上の位置引数が指定されている場合、最大の位置引数が返されます。

2つのオプションのキーワードのみの引数があります。 key 引数は、 list.sort（）に使用されるような1つの引数の順序付け関数を指定します。 default 引数は、指定された反復可能オブジェクトが空の場合に返すオブジェクトを指定します。 iterableが空で、 default が指定されていない場合、 ValueError が発生します。

複数の項目が最大の場合、関数は最初に検出された項目を返します。 これは、sorted(iterable, key=keyfunc, reverse=True)[0]やheapq.nlargest(1, iterable, key=keyfunc)などの他のソート安定性保存ツールと一致しています。

バージョン3.4の新機能： デフォルトキーワードのみの引数。

バージョン3.8で変更： キーはNoneにすることができます。

class memoryview(obj)

指定された引数から作成された「メモリビュー」オブジェクトを返します。 詳細については、メモリビューを参照してください。

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

反復可能な最小の項目、または2つ以上の引数の最小のものを返します。

位置引数が1つ指定されている場合は、 iterable である必要があります。 iterableの最小のアイテムが返されます。 2つ以上の位置引数が指定されている場合、最小の位置引数が返されます。

2つのオプションのキーワードのみの引数があります。 key 引数は、 list.sort（）に使用されるような1つの引数の順序付け関数を指定します。 default 引数は、指定された反復可能オブジェクトが空の場合に返すオブジェクトを指定します。 iterableが空で、 default が指定されていない場合、 ValueError が発生します。

複数の項目が最小の場合、関数は最初に検出された項目を返します。 これは、sorted(iterable, key=keyfunc)[0]やheapq.nsmallest(1, iterable, key=keyfunc)などの他のソート安定性保存ツールと一致しています。

バージョン3.4の新機能： デフォルトキーワードのみの引数。

バージョン3.8で変更： キーはNoneにすることができます。

next(iterator[, default])

__ next __（）メソッドを呼び出して、イテレータから次のアイテムを取得します。 default が指定されている場合、イテレータが使い果たされた場合に返されます。指定されていない場合、 StopIteration が発生します。

class object

新しい機能のないオブジェクトを返します。 object はすべてのクラスのベースです。 Pythonクラスのすべてのインスタンスに共通のメソッドがあります。 この関数は引数を受け入れません。

ノート

object には not には __ dict __ がないため、 object クラスのインスタンスに任意の属性を割り当てることはできません。

oct(x)

整数を「0o」で始まる8進文字列に変換します。 結果は有効なPython式です。 x がPython int オブジェクトでない場合は、整数を返す__index__()メソッドを定義する必要があります。 例えば：

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

整数を接頭辞「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)

ファイルを開き、対応するファイルオブジェクトを返します。 ファイルを開くことができない場合、 OSError が発生します。 この関数の使用方法のその他の例については、ファイルの読み取りと書き込みを参照してください。

file は、パスのようなオブジェクトで、開くファイルのパス名（現在の作業ディレクトリに対する絶対パス名または相対パス名）またはラップするファイルの整数ファイル記述子を指定します。 （ファイル記述子が指定されている場合、 closefd がFalseに設定されていない限り、返されたI / Oオブジェクトが閉じられると閉じられます。）

mode は、ファイルが開かれるモードを指定するオプションの文字列です。 デフォルトは'r'で、テキストモードで読むことができます。 その他の一般的な値は、書き込み用の'w'（ファイルが既に存在する場合はファイルを切り捨てる）、排他的作成用の'x'、追加用の'a'（一部）です。 Unixシステムは、 all の書き込みが、現在のシーク位置に関係なくファイルの末尾に追加されることを意味します）。 テキストモードでは、 encoding が指定されていない場合、使用されるエンコーディングはプラットフォームに依存します。現在のロケールエンコーディングを取得するためにlocale.getpreferredencoding(False)が呼び出されます。 （rawバイトの読み取りと書き込みには、バイナリモードを使用し、 encoding は指定しないでください。）使用可能なモードは次のとおりです。

キャラクター	意味
'r'	読み取り用に開く（デフォルト）
'w'	書き込み用に開き、最初にファイルを切り捨てます
'x'	排他的作成のために開き、ファイルがすでに存在する場合は失敗します
'a'	書き込み用に開き、ファイルが存在する場合はファイルの末尾に追加します
'b'	バイナリモード
't'	テキストモード（デフォルト）
'+'	更新（読み取りと書き込み）のために開いています

デフォルトのモードは'r'です（テキストを読むために開いています。'rt'の同義語です）。 モード'w+'および'w+b'は、ファイルを開いて切り捨てます。 モード'r+'および'r+b'は、切り捨てなしでファイルを開きます。

概要で説明したように、PythonはバイナリI / OとテキストI / Oを区別します。 バイナリモードで開かれたファイル（モード引数の'b'を含む）は、デコードせずにコンテンツをバイトオブジェクトとして返します。 テキストモード（デフォルト、または't'が mode 引数に含まれている場合）では、ファイルの内容は str として返され、バイトが最初になります。プラットフォームに依存するエンコーディングを使用して、または指定されている場合は指定されたエンコーディングを使用してデコードされます。

許可されている追加のモード文字'U'がありますが、これはもはや効果がなく、非推奨と見なされます。 以前はテキストモードでユニバーサルニューラインを有効にしていましたが、これがPython3.0のデフォルトの動作になりました。 詳細については、 newline パラメーターのドキュメントを参照してください。

ノート

Pythonは、基盤となるオペレーティングシステムのテキストファイルの概念に依存しません。 すべての処理はPython自体によって行われるため、プラットフォームに依存しません。

buffering は、バッファリングポリシーを設定するために使用されるオプションの整数です。 0を渡してバッファリングをオフに切り替え（バイナリモードでのみ許可）、1を渡して行バッファリングを選択し（テキストモードでのみ使用可能）、1より大きい整数を渡して固定サイズのチャンクバッファのサイズをバイト単位で示します。 buffering 引数が指定されていない場合、デフォルトのバッファリングポリシーは次のように機能します。

• バイナリファイルは固定サイズのチャンクでバッファリングされます。 バッファのサイズは、基盤となるデバイスの「ブロックサイズ」を決定し、 io.DEFAULT_BUFFER_SIZE にフォールバックするヒューリスティックを使用して選択されます。 多くのシステムでは、バッファは通常4096バイトまたは8192バイトの長さになります。

• 「インタラクティブ」テキストファイル（ isatty（）がTrueを返すファイル）は、ラインバッファリングを使用します。 他のテキストファイルは、バイナリファイルに対して上記のポリシーを使用します。

encoding は、ファイルのデコードまたはエンコードに使用されるエンコードの名前です。 これはテキストモードでのみ使用する必要があります。 デフォルトのエンコーディングはプラットフォームに依存しますが（ locale.getpreferredencoding（）が返すものは何でも）、Pythonでサポートされているテキストエンコーディングを使用できます。 サポートされているエンコーディングのリストについては、 codecs モジュールを参照してください。

errors は、エンコードおよびデコードエラーの処理方法を指定するオプションの文字列です。これはバイナリモードでは使用できません。 さまざまな標準エラーハンドラーを使用できます（エラーハンドラーの下にリストされています）が、 codecs.register_error（）に登録されているエラー処理名も有効です。 標準名は次のとおりです。

• 'strict'は、エンコードエラーが発生した場合に ValueError 例外を発生させます。 Noneのデフォルト値も同じ効果があります。

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

• 'replace'を使用すると、データの形式が正しくない場所に置換マーカー（'?'など）が挿入されます。

• 'surrogateescape'は、U + DC80からU + DCFFの範囲のUnicode私用領域のコードポイントとして誤ったバイトを表します。 これらのプライベートコードポイントは、データの書き込み時にsurrogateescapeエラーハンドラーが使用されると、同じバイトに戻されます。 これは、不明なエンコーディングのファイルを処理する場合に役立ちます。

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

• 'backslashreplace'は、不正な形式のデータをPythonのバックスラッシュされたエスケープシーケンスに置き換えます。

• 'namereplace'（書き込み時にのみサポートされます）は、サポートされていない文字を\N{...}エスケープシーケンスに置き換えます。

newline は、ユニバーサル改行モードの動作を制御します（テキストモードにのみ適用されます）。 None、、'\n'、'\r'、および'\r\n'にすることができます。 これは次のように機能します。

• ストリームから入力を読み取るときに、 newline がNoneの場合、ユニバーサル改行モードが有効になります。 入力の行は、'\n'、'\r'、または'\r\n'で終わる可能性があり、これらは呼び出し元に返される前に'\n'に変換されます。 の場合、ユニバーサル改行モードが有効になりますが、行末は変換されずに呼び出し元に返されます。 他の有効な値のいずれかがある場合、入力行は指定された文字列でのみ終了し、行の終了は変換されずに呼び出し元に返されます。

• ストリームに出力を書き込むときに、 newline がNoneの場合、書き込まれた'\n'文字はすべて、システムのデフォルトの行区切り文字 os.linesep に変換されます。 。 改行がまたは'\n'の場合、変換は行われません。 newline が他の有効な値のいずれかである場合、書き込まれた'\n'文字はすべて指定された文字列に変換されます。

closefd がFalseであり、ファイル名ではなくファイル記述子が指定されている場合、ファイルが閉じられても、基になるファイル記述子は開いたままになります。 ファイル名が指定されている場合、 closefd はTrue（デフォルト）である必要があります。そうでない場合、エラーが発生します。

カスタムオープナーは、呼び出し可能オブジェクトをオープナーとして渡すことで使用できます。 次に、ファイルオブジェクトの基になるファイル記述子は、オープナーを（ファイル、フラグ）で呼び出すことによって取得されます。 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（）関数によって返されるファイルオブジェクトのタイプは、モードによって異なります。 open（）を使用してファイルをテキストモードで開く場合（'w'、'r'、'wt'、'rt'など。）、 io.TextIOBase （具体的には io.TextIOWrapper ）のサブクラスを返します。 バッファリングを使用してバイナリモードでファイルを開くために使用される場合、返されるクラスは io.BufferedIOBase のサブクラスです。 正確なクラスは異なります。読み取りバイナリモードでは、 io.BufferedReader を返します。 書き込みバイナリおよび追加バイナリモードでは、 io.BufferedWriter を返し、読み取り/書き込みモードでは、 io.BufferedRandom を返します。 バッファリングが無効になっている場合、生のストリーム、 io.RawIOBase 、 io.FileIO のサブクラスが返されます。

fileinput 、 io （ open（）が宣言されている）、 os 、などのファイル処理モジュールも参照してください。 ] os.path 、 tempfile 、および shutil 。

modeおよびflags引数は、元の呼び出しから変更または推測されている可能性があります。

バージョン3.3で変更：

• オープナーパラメーターが追加されました。

• 'x'モードが追加されました。

• IOError が発生していましたが、現在は OSError のエイリアスになっています。

• FileExistsError は、排他的作成モード（'x'）で開かれたファイルがすでに存在する場合に発生するようになりました。

バージョン3.4で変更：

• ファイルは継承できなくなりました。

バージョン3.5で変更：

• システムコールが中断され、シグナルハンドラが例外を発生させない場合、関数は InterruptedError 例外を発生させる代わりに、システムコールを再試行するようになりました（ PEP 475 [X210Xを参照） ]理論的根拠のために）。

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

バージョン3.6で変更：

• os.PathLike を実装するオブジェクトを受け入れるためのサポートが追加されました。

• Windowsでは、コンソールバッファを開くと、 io.FileIO 以外の io.RawIOBase のサブクラスが返される場合があります。

ord(c)

1つのUnicode文字を表す文字列を指定すると、その文字のUnicodeコードポイントを表す整数を返します。 たとえば、ord('a')は整数97を返し、ord('€')（ユーロ記号）は8364を返します。 これは chr（）の逆です。

pow(base, exp[, mod])

ベースを exp の累乗に戻します。 mod が存在する場合は、 base を exp の累乗、モジュロ mod （pow(base, exp) % modよりも効率的に計算）に戻します） 。 2つの引数形式pow(base, exp)は、累乗演算子base**expを使用するのと同じです。

引数は数値型でなければなりません。 オペランドタイプが混在している場合、2進算術演算子の強制規則が適用されます。 int オペランドの場合、2番目の引数が負でない限り、結果はオペランドと同じ型になります（強制後）。 その場合、すべての引数がfloatに変換され、floatの結果が配信されます。 たとえば、10**2は100を返しますが、10**-2は0.01を返します。

int オペランド base および exp の場合、 mod が存在する場合、 mod も整数型である必要があります。 mod はゼロ以外である必要があります。 mod が存在し、 exp が負の場合、 base は mod と互いに素でなければなりません。 その場合、pow(inv_base, -exp, mod)が返されます。ここで、 inv_base は base モジュロ mod の逆です。

38モジュロ97の逆数を計算する例を次に示します。

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

バージョン3.8で変更： int オペランドの場合、powの3引数形式では、2番目の引数を負にできるようになり、モジュラ逆数の計算が可能になりました。

バージョン3.8で変更：キーワード引数を許可します。 以前は、位置引数のみがサポートされていました。

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

オブジェクトをテキストストリームファイルに出力し、 sep で区切り、その後に end を続けます。 sep 、 end 、 file 、および flush が存在する場合は、キーワード引数として指定する必要があります。

キーワード以外の引数はすべて、 str（）のように文字列に変換されてストリームに書き込まれ、 sep で区切られ、その後に end が続きます。 sep と end はどちらも文字列である必要があります。 Noneにすることもできます。これは、デフォルト値を使用することを意味します。 オブジェクトが指定されていない場合、 print（）は end を書き込むだけです。

file 引数は、write(string)メソッドを持つオブジェクトである必要があります。 存在しない場合、またはNoneの場合、 sys.stdout が使用されます。 印刷された引数はテキスト文字列に変換されるため、 print（）はバイナリモードのファイルオブジェクトでは使用できません。 これらには、代わりにfile.write(...)を使用してください。

出力がバッファリングされるかどうかは通常 file によって決定されますが、 flush キーワード引数がtrueの場合、ストリームは強制的にフラッシュされます。

バージョン3.3で変更： flush キーワード引数を追加しました。

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

プロパティ属性を返します。

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はゲッターを呼び出し、c.x = valueはセッターを呼び出し、del c.xはデリッターを呼び出します。 。

指定した場合、 doc はプロパティ属性のdocstringになります。 それ以外の場合、プロパティは fget のdocstring（存在する場合）をコピーします。 これにより、 property（）をデコレータとして使用して、読み取り専用プロパティを簡単に作成できます。

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

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

@propertyデコレータは、voltage()メソッドを同じ名前の読み取り専用属性の「ゲッター」に変え、電圧のdocstringを「Getthe現在の電圧。」

プロパティオブジェクトには、デコレータとして使用できるgetter、setter、およびdeleterメソッドがあり、対応するアクセサ関数がデコレートされた関数に設定されたプロパティのコピーを作成します。 これは例で最もよく説明されます：

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

このコードは、最初の例とまったく同じです。 追加の関数には、必ず元のプロパティと同じ名前を付けてください（この場合はx）。

返されるプロパティオブジェクトには、コンストラクター引数に対応する属性fget、fset、およびfdelもあります。

バージョン3.5で変更：プロパティオブジェクトのdocstringが書き込み可能になりました。

class range(stop)

class range(start, stop[, step])

range は、関数ではなく、 Ranges および Sequence Types — list、tuple、range に記載されているように、実際には不変のシーケンスタイプです。

repr(object)

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

reversed(seq)

逆イテレータを返します。 seq は、__reversed__()メソッドを持つオブジェクト、またはシーケンスプロトコル（__len__()メソッドおよび__getitem__()メソッドで始まる整数引数）をサポートするオブジェクトである必要があります。 X176X] ）。

round(number[, ndigits])

数値を小数点以下 n桁の精度に丸めて返します。 ndigits が省略されているか、Noneの場合、入力に最も近い整数を返します。

round（）をサポートする組み込み型の場合、値は10の累乗から n桁を引いたものに最も近い倍数に丸められます。 2つの倍数が等しく近い場合、偶数の選択に向けて丸めが行われます（たとえば、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])

新しい set オブジェクトを返します。オプションで、 iterable から取得した要素を使用します。 setは組み込みクラスです。 このクラスのドキュメントについては、 set および Set Types — set、frozenset を参照してください。

その他のコンテナについては、組み込みのフリーズセット、リスト、タプル、 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があり、これらは単に引数値（またはそれらのデフォルト）を返します。 他に明示的な機能はありません。 ただし、NumericalPythonやその他のサードパーティの拡張機能で使用されます。 拡張インデックス構文が使用されている場合も、スライスオブジェクトが生成されます。 例：a[start:stop:step]またはa[start:stop, i]。 イテレータを返す代替バージョンについては、 itertools.islice（）を参照してください。

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

iterable のアイテムから新しいソート済みリストを返します。

キーワード引数として指定する必要がある2つのオプションの引数があります。

key は、 iterable の各要素から比較キーを抽出するために使用される1つの引数の関数を指定します（たとえば、key=str.lower）。 デフォルト値はNoneです（要素を直接比較してください）。

reverse はブール値です。 Trueに設定すると、リスト要素は、各比較が逆になったかのように並べ替えられます。

functools.cmp_to_key（）を使用して、古いスタイルの cmp 関数を key 関数に変換します。

組み込みの sorted（）関数は安定していることが保証されています。 同等に比較される要素の相対的な順序を変更しないことが保証されている場合、並べ替えは安定しています。これは、複数のパスで並べ替える場合に役立ちます（たとえば、部門で並べ替えてから給与等級で並べ替える）。

並べ替えの例と簡単な並べ替えのチュートリアルについては、並べ替え方法を参照してください。

@staticmethod

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

静的メソッドは、暗黙の最初の引数を受け取りません。 静的メソッドを宣言するには、次のイディオムを使用します。

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

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

静的メソッドは、クラス（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')

str バージョンのオブジェクトを返します。 詳細については、 str（）を参照してください。

strは、組み込みの文字列 class です。 文字列の一般的な情報については、テキストシーケンスタイプ— str を参照してください。

sum(iterable, /, start=0)

start と iterable の項目を左から右に合計し、合計を返します。 iterable の項目は通常数値であり、開始値を文字列にすることはできません。

いくつかのユースケースでは、 sum（）の良い代替手段があります。 文字列のシーケンスを連結するための推奨される高速な方法は、.join(sequence)を呼び出すことです。 拡張精度で浮動小数点値を追加するには、 math.fsum（）を参照してください。 一連の反復可能オブジェクトを連結するには、 itertools.chain（）の使用を検討してください。

バージョン3.8で変更： start パラメーターをキーワード引数として指定できます。

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

type の親クラスまたは兄弟クラスにメソッド呼び出しを委任するプロキシオブジェクトを返します。 これは、クラスでオーバーライドされた継承されたメソッドにアクセスする場合に役立ちます。

object-or-type は、検索するメソッドの解決順序を決定します。 type の直後のクラスから検索を開始します。

たとえば、 object-or-type の __ mro __ がD -> B -> C -> A -> objectで、 type の値がBの場合、 super（）はC -> A -> objectを検索します。

object-or-type の __ mro __ 属性は、 getattr（）と super（）の両方で使用されるメソッド解決検索順序を示しています。 。 属性は動的であり、継承階層が更新されるたびに変更できます。

2番目の引数を省略すると、返されるスーパーオブジェクトはバインドされません。 2番目の引数がオブジェクトの場合、isinstance(obj, type)は真でなければなりません。 2番目の引数が型の場合、issubclass(type2, type)はtrueである必要があります（これはクラスメソッドに役立ちます）。

super には2つの典型的な使用例があります。 単一継承のクラス階層では、 super を使用して、明示的に名前を付けずに親クラスを参照できるため、コードの保守性が向上します。 この使用法は、他のプログラミング言語での super の使用法とほぼ同じです。

2番目のユースケースは、動的実行環境で協調的な多重継承をサポートすることです。 このユースケースはPythonに固有のものであり、静的にコンパイルされた言語や単一継承のみをサポートする言語には見られません。 これにより、複数の基本クラスが同じメソッドを実装する「ひし形図」を実装できます。 優れた設計では、このような実装はすべての場合に同じ呼び出しシグネチャを持つ必要があります（呼び出しの順序は実行時に決定されるため、その順序はクラス階層の変更に適応し、その順序には実行前に不明な兄弟クラスが含まれる可能性があるため） ）。

どちらのユースケースでも、一般的なスーパークラスの呼び出しは次のようになります。

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

メソッドルックアップに加えて、 super（）は属性ルックアップでも機能します。 これの考えられるユースケースの1つは、親クラスまたは兄弟クラスで記述子を呼び出すことです。

super（）は、super().__getitem__(name)などの明示的なドット属性ルックアップのバインディングプロセスの一部として実装されていることに注意してください。 これは、協調的な多重継承をサポートする予測可能な順序でクラスを検索するための独自の__getattribute__()メソッドを実装することによって行われます。 したがって、 super（）は、super()[name]などのステートメントまたは演算子を使用した暗黙的なルックアップに対しては定義されていません。

また、ゼロ引数形式を除いて、 super（）はメソッド内での使用に限定されないことに注意してください。 2つの引数形式は、引数を正確に指定し、適切な参照を行います。 ゼロ引数形式は、クラス定義内でのみ機能します。コンパイラは、定義されているクラスを正しく取得するために必要な詳細を入力し、通常のメソッドの現在のインスタンスにアクセスするためです。

super（）を使用して協調クラスを設計する方法に関する実際的な提案については、 super（）の使用ガイドを参照してください。

class tuple([iterable])

タプルは、関数ではなく、タプルおよびシーケンスタイプ—リスト、タプル、範囲に記載されているように、実際には不変のシーケンスタイプです。

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

引数を1つ指定して、オブジェクトの型を返します。 戻り値は型オブジェクトであり、通常は object .__ class __ によって返されるものと同じオブジェクトです。

isinstance（）組み込み関数は、サブクラスを考慮に入れるため、オブジェクトの型をテストするために推奨されます。

3つの引数を使用して、新しい型オブジェクトを返します。 これは基本的に、 class ステートメントの動的な形式です。 name 文字列はクラス名であり、 __ name __ 属性になります。 bases タプルには基本クラスが含まれ、 __ bases __ 属性になります。 空の場合、すべてのクラスの最終的なベースである object が追加されます。 dict ディクショナリには、クラス本体の属性とメソッドの定義が含まれています。 __ dict __ 属性になる前に、コピーまたはラップすることができます。 次の2つのステートメントは、同一の type オブジェクトを作成します。

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

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

3つの引数形式に提供されたキーワード引数は、クラス定義のキーワード（ metaclass 以外）と同じ方法で、適切なメタクラス機構（通常は __ init_subclass __（））に渡されます。

クラス作成のカスタマイズも参照してください。

バージョン3.6で変更： type.__new__をオーバーライドしない type のサブクラスは、オブジェクトの型を取得するために1引数形式を使用できなくなりました。

vars([object])

モジュール、クラス、インスタンス、または __ dict __ 属性を持つその他のオブジェクトの __ dict __ 属性を返します。

モジュールやインスタンスなどのオブジェクトには、更新可能な __ dict __ 属性があります。 ただし、他のオブジェクトでは、 __ dict __ 属性に書き込み制限がある場合があります（たとえば、クラスは types.MappingProxyType を使用して、辞書が直接更新されないようにします）。

引数がない場合、 vars（）は locals（）のように機能します。 ローカルディクショナリの更新は無視されるため、ローカルディクショナリは読み取りにのみ役立ちます。

オブジェクトが指定されているが、 __ dict __ 属性がない場合（たとえば、そのクラスが __ slots __ 属性を定義している場合）、 TypeError 例外が発生します。

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（）を*演算子と組み合わせて使用すると、リストを解凍できます。

>>> 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 ステートメントによって呼び出されます。 importステートメントのセマンティクスを変更するために（ builtins モジュールをインポートしてbuiltins.__import__に割り当てることにより）置き換えることができますが、そうすることは強力に[ X175X]は、インポートフック（ PEP 302 を参照）を使用して同じ目標を達成する方が通常は簡単であり、デフォルトのインポート実装が使用されていると想定するコードで問題が発生しないため、推奨されません。 。 __ import __（）を直接使用することもお勧めしません。これは、 importlib.import_module（）を優先するためです。

この関数は、モジュール name をインポートし、指定された globals および locals を使用して、パッケージコンテキストで名前を解釈する方法を決定する可能性があります。 fromlist は、 name で指定されたモジュールからインポートする必要があるオブジェクトまたはサブモジュールの名前を示します。 標準実装では、 locals 引数をまったく使用せず、 globals を使用して、 import ステートメントのパッケージコンテキストを決定します。

level は、絶対インポートと相対インポートのどちらを使用するかを指定します。 0（デフォルト）は、絶対インポートのみを実行することを意味します。 level の正の値は、 __ import __（）を呼び出すモジュールのディレクトリを基準にして検索する親ディレクトリの数を示します（ PEP 328 [X182Xを参照] ]詳細については）。

name 変数がpackage.moduleの形式の場合、通常、最上位パッケージ（最初のドットまでの名前）が返されますが、ではなくという名前のモジュールが返されます。 名前による。 ただし、空でない 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

ここで、spam.hamモジュールは __ import __（）から返されます。 このオブジェクトから、インポートする名前が取得され、それぞれの名前に割り当てられます。

モジュール（パッケージ内の可能性がある）を名前でインポートするだけの場合は、 importlib.import_module（）を使用します。

バージョン3.3での変更： level の負の値はサポートされなくなりました（これにより、デフォルト値も0に変更されます）。

脚注

1

パーサーはUnixスタイルの行末規則のみを受け入れることに注意してください。 ファイルからコードを読み取る場合は、必ず改行変換モードを使用してWindowsまたはMacスタイルの改行を変換してください。