組み込み型—Pythonドキュメント

組み込み型

次のセクションでは、インタープリターに組み込まれている標準タイプについて説明します。

主要な組み込み型は、数値、シーケンス、マッピング、クラス、インスタンス、および例外です。

一部のコレクションクラスは変更可能です。 メンバーを所定の位置に追加、減算、または再配置し、特定のアイテムを返さないメソッドは、コレクションインスタンス自体を返すことはなく、Noneを返します。

一部の操作は、いくつかのオブジェクトタイプでサポートされています。 特に、実質的にすべてのオブジェクトが等しいかどうかを比較し、真理値をテストして、文字列に変換できます（ repr（）関数またはわずかに異なる str（）関数を使用） 。 後者の関数は、オブジェクトが print（）関数によって書き込まれるときに暗黙的に使用されます。

真理値テスト

if または while 条件で使用するため、または以下のブール演算のオペランドとして使用するために、任意のオブジェクトの真理値をテストできます。

デフォルトでは、オブジェクトで呼び出されたときにFalseを返す__bool__()メソッド、またはゼロを返す__len__()メソッドのいずれかがクラスで定義されていない限り、オブジェクトはtrueと見なされます。 1 これはfalseと見なされる組み込みオブジェクトのほとんどです。

• falseと定義された定数：NoneおよびFalse。
• 任意の数値型のゼロ：0、0.0、0j、Decimal(0)、Fraction(0, 1)
• 空のシーケンスとコレクション：、()、[]、{}、set()、range(0)

特に明記されていない限り、ブール結果を持つ演算および組み込み関数は、falseの場合は常に0またはFalseを返し、trueの場合は1またはTrueを返します。 （重要な例外：ブール演算orおよびandは、常にそれらのオペランドの1つを返します。）

ブール演算— and、or、not

これらは、優先度の昇順で並べられたブール演算です。

手術	結果	ノート
x or y	x がfalseの場合、 y 、それ以外の場合、 x	(1)
x and y	x がfalseの場合、 x 、それ以外の場合 y	(2)
not x	x がfalseの場合、True、それ以外の場合False	(3)

ノート：

1. これは短絡演算子であるため、最初の引数がfalseの場合にのみ2番目の引数を評価します。
2. これは短絡演算子であるため、最初の引数が真の場合にのみ2番目の引数を評価します。
3. notは非ブール演算子よりも優先度が低いため、not a == bはnot (a == b)として解釈され、a == not bは構文エラーです。

比較

Pythonには8つの比較操作があります。 それらはすべて同じ優先順位を持っています（これはブール演算の優先順位よりも高いです）。 比較は任意に連鎖させることができます。 たとえば、x < y <= zはx < y and y <= zと同等ですが、 y は1回だけ評価されます（ただし、どちらの場合も z はまったく評価されません。 x < yはfalseであることが判明しています）。

この表は、比較操作をまとめたものです。

手術	意味
<	厳密に
<=	以下
>	厳密により大きい
>=	以上
==	同等
!=	等しくない
is	オブジェクトID
is not	否定されたオブジェクトID

異なる数値タイプを除いて、異なるタイプのオブジェクトは決して等しく比較されません。 ==演算子は常に定義されていますが、一部のオブジェクトタイプ（クラスオブジェクトなど）では、 is と同等です。 <、<=、>、および>=演算子は、意味のある場合にのみ定義されます。 たとえば、引数の1つが複素数の場合、 TypeError 例外が発生します。

クラスの同一でないインスタンスは、クラスが__eq__()メソッドを定義しない限り、通常、等しくないと比較されます。

クラスのインスタンスは、クラスが十分なメソッド__lt__()、__le__()、 [X189Xを定義しない限り、同じクラスの他のインスタンスまたは他のタイプのオブジェクトに関して順序付けできません。 ]、および__ge__()（通常、比較演算子の従来の意味が必要な場合は、__lt__()および__eq__()で十分です）。

is および is not 演算子の動作はカスタマイズできません。 また、それらは任意の2つのオブジェクトに適用でき、例外を発生させることはありません。

同じ構文優先度を持つさらに2つの操作、 in と not in は、 iterable であるか、__contains__()メソッドを実装するタイプでサポートされます。

数値型— int 、 float 、 complex

整数、浮動小数点数、および複素数の3つの異なる数値タイプがあります。 さらに、ブール値は整数のサブタイプです。 整数の精度は無制限です。 浮動小数点数は通常、Cで double を使用して実装されます。 プログラムが実行されているマシンの浮動小数点数の精度と内部表現に関する情報は、 sys.float_info で入手できます。 複素数には実数部と虚数部があり、それぞれが浮動小数点数です。 複素数 z からこれらのパーツを抽出するには、z.realおよびz.imagを使用します。 （標準ライブラリには、有理数用の追加の数値タイプ fractions.Fraction と、ユーザー定義可能な精度の浮動小数点数用の decimal.Decimal が含まれています。）

数値は、数値リテラルによって、または組み込みの関数と演算子の結果として作成されます。 装飾されていない整数リテラル（16進数、8進数、2進数を含む）は整数を生成します。 小数点または指数記号を含む数値リテラルは、浮動小数点数を生成します。 'j'または'J'を数値リテラルに追加すると、虚数（実数部がゼロの複素数）が生成されます。これを整数または浮動小数点数に追加して、実数と虚数の複素数を取得できます。部品。

Pythonは混合算術を完全にサポートします。バイナリ算術演算子に異なる数値型のオペランドがある場合、「より狭い」型のオペランドは、整数が浮動小数点よりも狭く、複素数よりも狭い他のオペランドに拡張されます。 異なるタイプの数値間の比較は、それらの数値の正確な値が比較されているかのように動作します。 2

コンストラクター int（）、 float（）、および complex（）を使用して、特定の型の数値を生成できます。

すべての数値型（複合を除く）は、次の操作をサポートします（操作の優先順位については、演算子の優先順位を参照してください）。

手術	結果	ノート	完全なドキュメント
x + y	x と y の合計
x - y	x と y の違い
x * y	x と y の積
x / y	x と y の商
x // y	x と y のフロア商	(1)
x % y	x / yの残り	(2)
-x	x が否定されました
+x	x 変更なし
abs(x)	x の絶対値または大きさ		abs()
int(x)	x を整数に変換	(3)(6)	int()
float(x)	x を浮動小数点に変換	(4)(6)	float()
complex(re, im)	実数部 re 、虚数部 im の複素数。 im のデフォルトはゼロです。	(6)	complex()
c.conjugate()	複素数の共役 c
divmod(x, y)	ペア(x // y, x % y)	(2)	divmod()
pow(x, y)	x の累乗 y	(5)	pow()
x ** y	x の累乗 y	(5)

ノート：

1. 整数除算とも呼ばれます。 結果の型は必ずしもintではありませんが、結果の値は整数です。 結果は常にマイナス無限大に丸められます。1//2は0、(-1)//2は-1、1//(-2)は-1です。 、および(-1)//(-2)は0です。

2. 複素数ではありません。 代わりに、必要に応じて abs（）を使用してfloatに変換してください。

3. 浮動小数点から整数への変換は、Cのように丸めたり切り捨てたりする場合があります。 明確に定義された変換については、関数 math.floor（）および math.ceil（）を参照してください。

4. floatは、文字列「nan」と「inf」を受け入れます。オプションのプレフィックス「+」または「-」は、Not a Number（NaN）および正または負の無限大を表します。

5. Pythonは、プログラミング言語で一般的なように、pow(0, 0)と0 ** 0を1と定義しています。

6. 受け入れられる数値リテラルには、数字0から9または同等のUnicode（Ndプロパティを持つコードポイント）が含まれます。

   Ndプロパティを持つコードポイントの完全なリストについては、 https://www.unicode.org/Public/13.0.0/ucd/extracted/DerivedNumericType.txtを参照してください。

すべての numbers.Real タイプ（ int および float ）には、次の操作も含まれています。

手術	結果
math.trunc(x)	x は Integral に切り捨てられます
round(x[, n])	x は n 桁に丸められ、半分から偶数に丸められます。 n を省略すると、デフォルトで0になります。
math.floor(x)	最大積分 <= NS
math.ceil(x)	最小の Integral > = x

追加の数値演算については、 math および cmath モジュールを参照してください。

整数型のビット演算

ビット演算は整数に対してのみ意味があります。 ビット単位の演算の結果は、無限の数の符号ビットを使用して2の補数で実行されたかのように計算されます。

バイナリビット演算の優先順位はすべて数値演算よりも低く、比較よりも高くなっています。 単項演算~は、他の単項数値演算（+および-）と同じ優先順位を持ちます。

次の表に、優先度の昇順でソートされたビット演算を示します。

手術	結果	ノート
y	x および y のビット単位のまたは	(4)
x ^ y	x と y のビット単位の排他的論理和	(4)
x & y	x および y のビット単位のおよび	(4)
x << n	x が n ビットだけ左にシフト	(1)(2)
x >> n	x が n ビットだけ右にシフト	(1)(3)
~x	x のビットが反転しました

ノート：

1. 負のシフトカウントは不正であり、 ValueError が発生します。
2. n ビットによる左シフトは、pow(2, n)による乗算と同等です。
3. n ビットによる右シフトは、pow(2, n)によるフロア分割と同等です。
4. 有限の2の補数表現（1 + max(x.bit_length(), y.bit_length())以上の作業ビット幅）で少なくとも1つの追加の符号拡張ビットを使用してこれらの計算を実行すると、無限の数の符号ビットがある場合と同じ結果を得るのに十分です。 。

整数型に関する追加のメソッド

int型は、 numbers.Integral abstract基本クラスを実装します。 さらに、さらにいくつかのメソッドを提供します。

int.bit_length()

符号と先行ゼロを除いて、整数を2進数で表すために必要なビット数を返します。

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

より正確には、xがゼロ以外の場合、x.bit_length()は2**(k-1) <= abs(x) < 2**kのような一意の正の整数kです。 同様に、abs(x)が十分に小さく、対数が正しく丸められている場合は、k = 1 + int(log(abs(x), 2))になります。 xがゼロの場合、x.bit_length()は0を返します。

に相当：

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

バージョン3.1の新機能。

int.bit_count()

整数の絶対値のバイナリ表現で1の数を返します。 これは人口数としても知られています。 例：

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3

に相当：

def bit_count(self):
    return bin(self).count("1")

バージョン3.10の新機能。

int.to_bytes(length, byteorder, *, signed=False)

整数を表すバイトの配列を返します。

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

整数は長さバイトを使用して表されます。 整数が指定されたバイト数で表現できない場合、 OverflowError が発生します。

byteorder 引数は、整数を表すために使用されるバイト順序を決定します。 byteorder が"big"の場合、最上位バイトはバイト配列の先頭にあります。 byteorder が"little"の場合、最上位バイトはバイト配列の最後にあります。 ホストシステムのネイティブバイトオーダーを要求するには、バイトオーダー値として sys.byteorder を使用します。

signed 引数は、2の補数を使用して整数を表すかどうかを決定します。 signed がFalseで負の整数が指定されている場合、 OverflowError が発生します。 signed のデフォルト値はFalseです。

バージョン3.2の新機能。

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

指定されたバイト配列で表される整数を返します。

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

引数 bytes は、 bytesのようなオブジェクトまたは反復可能な生成バイトのいずれかである必要があります。

byteorder 引数は、整数を表すために使用されるバイト順序を決定します。 byteorder が"big"の場合、最上位バイトはバイト配列の先頭にあります。 byteorder が"little"の場合、最上位バイトはバイト配列の最後にあります。 ホストシステムのネイティブバイトオーダーを要求するには、バイトオーダー値として sys.byteorder を使用します。

signed 引数は、2の補数を使用して整数を表すかどうかを示します。

バージョン3.2の新機能。

int.as_integer_ratio()

比率が元の整数と正確に等しく、分母が正の整数のペアを返します。 整数（整数）の整数比は、常に分子としての整数と分母としての1です。

バージョン3.8の新機能。

フロートの追加メソッド

float型は、 numbers.Real abstract基本クラスを実装します。 floatには、次の追加メソッドもあります。

float.as_integer_ratio()

比率が元のfloatと正確に等しく、正の分母を持つ整数のペアを返します。 無限大で OverflowError を発生させ、NaNで ValueError を発生させます。

float.is_integer()

floatインスタンスが整数値で有限の場合はTrueを返し、それ以外の場合はFalseを返します。

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

2つの方法は、16進文字列との間の変換をサポートします。 Pythonのfloatは内部で2進数として格納されるため、floatを 10進数文字列に変換したり、 10進数文字列から変換したりすると、通常、小さな丸め誤差が発生します。 対照的に、16進文字列では、浮動小数点数の正確な表現と指定が可能です。 これは、デバッグ時や数値作業で役立ちます。

float.hex()

浮動小数点数の表現を16進文字列として返します。 有限浮動小数点数の場合、この表現には常に先頭の0xと末尾のpおよび指数が含まれます。

classmethod float.fromhex(s)

16進文字列 s で表されるfloatを返すクラスメソッド。 文字列 s には、先頭と末尾に空白が含まれる場合があります。

float.hex（）はインスタンスメソッドであり、 float.fromhex（）はクラスメソッドであることに注意してください。

16進文字列は次の形式を取ります。

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

ここで、オプションのsignは、+または-のいずれかで、integerおよびfractionは16進数の文字列であり、 [ X134X]は、オプションの先行記号が付いた10進整数です。 大文字と小文字は区別されません。整数または分数のいずれかに少なくとも1桁の16進数が必要です。 この構文は、C99標準のセクション6.4.4.2で指定されている構文、およびJava1.5以降で使用されている構文に似ています。 特に、 float.hex（）の出力は、CまたはJavaコードの16進浮動小数点リテラル、およびCの%a形式の文字またはJavaの[X196X ] は、 float.fromhex（）によって受け入れられます。

指数は16進数ではなく10進数で記述されており、係数を乗算する2の累乗を与えることに注意してください。 たとえば、16進文字列0x3.a7p10は、浮動小数点数(3 + 10./16 + 7./16**2) * 2.0**10または3740.0を表します。

>>> float.fromhex('0x3.a7p10')
3740.0

3740.0に逆変換を適用すると、同じ数値を表す別の16進文字列が得られます。

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

数値型のハッシュ

番号xおよびyの場合、おそらく異なるタイプの場合、x == yの場合は常にhash(x) == hash(y)が必要です（__hash__()メソッドのドキュメントを参照してください。詳細）。 さまざまな数値タイプ（ int 、 float 、 decimal.Decimal 、 fractions.Fraction を含む）での実装と効率を容易にするため数値型のPythonのハッシュは、任意の有理数に対して定義された単一の数学関数に基づいているため、 int と fractions.Fraction のすべてのインスタンス、および[ X404X] float および decimal.Decimal 。 基本的に、この関数は、固定素数PのPを法とする還元によって与えられます。 Pの値は、 sys.hash_info のmodulus属性としてPythonで使用できるようになります。

ルールの詳細は次のとおりです。

• x = m / nが非負の有理数であり、nがPで割り切れない場合、hash(x)をm * invmod(n, P) % Pとして定義します。ここで [ X132X]は、nを法としてPの逆数を与えます。
• x = m / nが非負の有理数であり、nがPで割り切れる場合（ただし、mは割り切れない）、nには逆モジュロがありません。 Pおよび上記のルールは適用されません。 この場合、hash(x)を定数値sys.hash_info.infとして定義します。
• x = m / nが負の有理数の場合、hash(x)を-hash(-x)として定義します。 結果のハッシュが-1の場合は、-2に置き換えます。
• 特定の値sys.hash_info.infおよび-sys.hash_info.infは、それぞれ正の無限大または負の無限大のハッシュ値として使用されます。
• 複素数の数zの場合、実数部と虚数部のハッシュ値は、hash(z.real) + sys.hash_info.imag * hash(z.imag)を計算することによって結合され、モジュロ2**sys.hash_info.widthが次のようになります。 range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1))。 この場合も、結果が-1の場合、-2に置き換えられます。

上記のルールを明確にするために、有理数 float 、または complex のハッシュを計算するための組み込みハッシュと同等のPythonコードの例を次に示します。

import sys, math

def hash_fraction(m, n):
    """Compute the hash of a rational number m / n.

    Assumes m and n are integers, with n positive.
    Equivalent to hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Remove common factors of P.  (Unnecessary if m and n already coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
        # pow(n, P-2, P) gives the inverse of n modulo P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    if m < 0:
        hash_value = -hash_value
    if hash_value == -1:
        hash_value = -2
    return hash_value

def hash_float(x):
    """Compute the hash of a float x."""

    if math.isnan(x):
        return object.__hash__(x)
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    else:
        return hash_fraction(*x.as_integer_ratio())

def hash_complex(z):
    """Compute the hash of a complex number z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do a signed reduction modulo 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_value = (hash_value & (M - 1)) - (hash_value & M)
    if hash_value == -1:
        hash_value = -2
    return hash_value

イテレータタイプ

Pythonは、コンテナーに対する反復の概念をサポートしています。 これは、2つの異なる方法を使用して実装されます。 これらは、ユーザー定義クラスが反復をサポートできるようにするために使用されます。 以下でより詳細に説明するシーケンスは、常に反復法をサポートします。

反復サポートを提供するには、コンテナオブジェクトに対して1つのメソッドを定義する必要があります。

container.__iter__()

イテレータオブジェクトを返します。 オブジェクトは、以下で説明するイテレータプロトコルをサポートする必要があります。 コンテナーがさまざまなタイプの反復をサポートしている場合は、それらの反復タイプの反復子を具体的に要求するための追加のメソッドを提供できます。 （複数の形式の反復をサポートするオブジェクトの例は、幅優先探索と深さ優先探索の両方をサポートするツリー構造です。）このメソッドは、Pythonオブジェクトの型構造の tp_iter スロットに対応します。 Python / CAPI。

イテレータオブジェクト自体は、イテレータプロトコルを形成する次の2つのメソッドをサポートする必要があります。

iterator.__iter__()

イテレータオブジェクト自体を返します。 これは、コンテナとイテレータの両方を for および in ステートメントで使用できるようにするために必要です。 このメソッドは、Python / CAPIのPythonオブジェクトの型構造の tp_iter スロットに対応します。

iterator.__next__()

コンテナから次のアイテムを返します。 それ以上アイテムがない場合は、 StopIteration 例外を発生させます。 このメソッドは、Python / CAPIのPythonオブジェクトの型構造の tp_iternext スロットに対応します。

Pythonは、一般的および特定のシーケンスタイプ、ディクショナリ、およびその他のより特殊な形式での反復をサポートするために、いくつかのイテレータオブジェクトを定義しています。 特定のタイプは、イテレータプロトコルの実装以外には重要ではありません。

イテレータの __ next __（）メソッドが StopIteration を発生させると、それ以降の呼び出しでもそれを継続する必要があります。 このプロパティに従わない実装は、壊れていると見なされます。

発電機の種類

Pythonの generator は、イテレータプロトコルを実装するための便利な方法を提供します。 コンテナオブジェクトの__iter__()メソッドがジェネレータとして実装されている場合、__iter__()および __ next __（）メソッドを提供するイテレータオブジェクト（技術的にはジェネレータオブジェクト）が自動的に返されます。 。 ジェネレーターの詳細については、 yield式のドキュメントを参照してください。

シーケンスタイプ— リスト、タプル、範囲

リスト、タプル、範囲オブジェクトの3つの基本的なシーケンスタイプがあります。 バイナリデータおよびテキスト文字列の処理用に調整された追加のシーケンスタイプについては、専用のセクションで説明します。

一般的なシーケンス操作

次の表の操作は、可変および不変の両方のほとんどのシーケンスタイプでサポートされています。 collections.abc.Sequence ABCは、カスタムシーケンスタイプでこれらの操作を正しく実装するのを容易にするために提供されています。

この表は、優先順位の昇順でソートされたシーケンス操作を示しています。 表中、 s と t は同じタイプのシーケンスであり、 n 、 i 、 j 、 k は整数であり、 x は、 s によって課せられるタイプと値の制限を満たす任意のオブジェクトです。

inおよびnot in操作は、比較操作と同じ優先順位を持っています。 +（連結）および*（繰り返し）演算は、対応する数値演算と同じ優先順位を持ちます。 3

手術	結果	ノート
x in s	True s のアイテムが x と等しい場合、それ以外の場合はFalse	(1)
x not in s	False s のアイテムが x と等しい場合、それ以外の場合はTrue	(1)
s + t	s と t の連結	(6)(7)
s * nまたはn * s	s をそれ自体に n 回追加するのと同じです	(2)(7)
s[i]	i の番目のアイテム、原点0	(3)
s[i:j]	s の i から j へのスライス	(3)(4)
s[i:j:k]	ステップ k で s を i から j にスライスします。	(3)(5)
len(s)	の長さ
min(s)	の最小アイテム
max(s)	の最大のアイテム
s.index(x[, i[, j]])	s で最初に出現する x のインデックス（インデックス i 以降およびインデックス j の前）	(8)
s.count(x)	s での x の合計発生数

同じタイプのシーケンスも比較をサポートします。 特に、タプルとリストは、対応する要素を比較することによって辞書式に比較されます。 つまり、等しいと比較するには、すべての要素が等しく比較され、2つのシーケンスが同じタイプで同じ長さである必要があります。 （詳細については、言語リファレンスの比較を参照してください。）

ノート：

1. inおよびnot in操作は、一般的なケースでの単純な封じ込めテストにのみ使用されますが、一部の特殊なシーケンス（ str 、 bytes 、 bytearray ）は、サブシーケンステストにも使用します。

   >>> "gg" in "eggs"
   True

2. n の値が0より小さい場合は、0として扱われます（ s と同じタイプの空のシーケンスが生成されます）。 s のシーケンスのアイテムはコピーされないことに注意してください。 それらは複数回参照されます。 これはしばしば新しいPythonプログラマーを悩ませます。 検討：

   >>> lists = [[../]] * 3
   >>> lists
   [[], [], []]
   >>> lists[0].append(3)
   >>> lists
   [[3], [3], [3]]

   何が起こったのかというと、Python/docs/3.10/libraryは空のリストを含む1要素のリストであるため、Python/docs/3.10/library * 3の3つの要素はすべてこの単一の空のリストへの参照です。 listsの要素のいずれかを変更すると、この単一のリストが変更されます。 次の方法で、さまざまなリストのリストを作成できます。

   >>> lists = [[] for i in range(3)]
   >>> lists[0].append(3)
   >>> lists[1].append(5)
   >>> lists[2].append(7)
   >>> lists
   [[3], [5], [7]]

   詳細な説明は、FAQエントリ多次元リストを作成するにはどうすればよいですか？にあります。

3. i または j が負の場合、インデックスはシーケンス s の終わりを基準にしています：len(s) + iまたはlen(s) + jは代用。 ただし、-0は0のままであることに注意してください。

4. i から j までの s のスライスは、i <= k < jのようなインデックス k を持つアイテムのシーケンスとして定義されます。 。 i または j がlen(s)より大きい場合は、len(s)を使用します。 i を省略した場合、またはNoneの場合は、0を使用してください。 j を省略した場合、またはNoneの場合は、len(s)を使用してください。 i が j 以上の場合、スライスは空です。

5. ステップ k での i から j への s のスライスは、インデックスx = i + n*kを持つアイテムのシーケンスとして定義されます。 0 <= n < (j-i)/kのように。 つまり、インデックスはi、i+k、i+2*k、i+3*kなどであり、 j に達すると停止します（ただし、 j ）は含めないでください。 k が正の場合、 i と j は、大きい場合はlen(s)に縮小されます。 k が負の場合、 i と j が大きい場合はlen(s) - 1に減少します。 i または j を省略した場合、またはNoneの場合、これらは「終了」値になります（終了は k の符号によって異なります）。 k をゼロにすることはできないことに注意してください。 k がNoneの場合、1のように扱われます。

6. 不変のシーケンスを連結すると、常に新しいオブジェクトが生成されます。 これは、連結を繰り返してシーケンスを構築すると、シーケンスの全長に2次の実行コストがかかることを意味します。 線形ランタイムコストを取得するには、以下のいずれかの方法に切り替える必要があります。

   • str オブジェクトを連結する場合は、リストを作成して最後に str.join（）を使用するか、 io.StringIO インスタンスに書き込んでそのインスタンスを取得できます。完了時の値

   • bytes オブジェクトを連結する場合は、同様に bytes.join（）または io.BytesIO を使用するか、を使用してインプレース連結を行うことができます。 bytearray オブジェクト。 bytearray オブジェクトは可変であり、効率的なオーバーアロケーションメカニズムを備えています

   • タプルオブジェクトを連結する場合は、代わりにリストを拡張してください

   • 他のタイプについては、関連するクラスのドキュメントを調べてください

7. 一部のシーケンスタイプ（ range など）は、特定のパターンに従うアイテムシーケンスのみをサポートするため、シーケンスの連結または繰り返しをサポートしません。

8. s に x が見つからない場合、indexは ValueError を発生させます。 すべての実装が追加の引数 i および j の受け渡しをサポートしているわけではありません。 これらの引数により、シーケンスのサブセクションを効率的に検索できます。 追加の引数を渡すことは、s[i:j].index(x)を使用することとほぼ同じですが、データをコピーせず、返されるインデックスがスライスの開始ではなくシーケンスの開始に関連している場合のみです。

不変のシーケンスタイプ

不変シーケンスタイプが一般的に実装し、可変シーケンスタイプによっても実装されない唯一の操作は、 hash（）組み込みのサポートです。

このサポートにより、タプルインスタンスなどの不変シーケンスを dict キーとして使用し、 set および frozenset インスタンスに格納できます。

ハッシュできない値を含む不変のシーケンスをハッシュしようとすると、 TypeError が発生します。

可変シーケンスタイプ

次の表の操作は、可変シーケンスタイプで定義されています。 collections.abc.MutableSequence ABCは、カスタムシーケンスタイプでこれらの操作を正しく実装するのを容易にするために提供されています。

表では、 s は可変シーケンスタイプのインスタンスであり、 t は任意の反復可能オブジェクトであり、 x は課されたタイプと値の制限を満たす任意のオブジェクトです。 s による（たとえば、 bytearray は、値の制限0 <= x <= 255を満たす整数のみを受け入れます）。

手術	結果	ノート
s[i] = x	s のアイテム i は x に置き換えられます
s[i:j] = t	i から j までの s のスライスは、反復可能な t の内容に置き換えられます。
del s[i:j]	s[i:j] = []と同じ
s[i:j:k] = t	s[i:j:k]の要素は、 t の要素に置き換えられます。	(1)
del s[i:j:k]	s[i:j:k]の要素をリストから削除します
s.append(x)	シーケンスの最後に x を追加します（s[len(s):len(s)] = [x]と同じ）
s.clear()	s からすべてのアイテムを削除します（del s[:]と同じ）	(5)
s.copy()	s の浅いコピーを作成します（s[:]と同じ）	(5)
s.extend(t)またはs += t	s を t の内容で拡張します（ほとんどの場合、s[len(s):len(s)] = tと同じです）
s *= n	s を更新してその内容を n 回繰り返します	(6)
s.insert(i, x)	x を i で指定されたインデックスの s に挿入します（s[i:i] = [x]と同じ）
s.pop()またはs.pop(i)	i でアイテムを取得し、 s からも削除します	(2)
s.remove(x)	s から最初のアイテムを削除します。s[i]は x と同じです。	(3)
s.reverse()	s の項目を元に戻します	(4)

ノート：

1. t は、置き換えるスライスと同じ長さである必要があります。

2. オプションの引数 i はデフォルトで-1であるため、デフォルトでは最後の項目が削除されて返されます。

3. s に x が見つからない場合、remove()は ValueError を発生させます。

4. reverse()メソッドは、大きなシーケンスを逆にするときにスペースを節約するために、所定の位置にあるシーケンスを変更します。 副作用によって動作することをユーザーに思い出させるために、逆の順序は返されません。

5. clear()とcopy()は、スライス操作をサポートしない可変コンテナー（ dict や set など）のインターフェースとの一貫性を保つために含まれています。 copy()は collections.abc.MutableSequence ABCの一部ではありませんが、ほとんどの具体的な可変シーケンスクラスが提供します。

   バージョン3.3の新機能： clear()およびcopy()メソッド。

6. 値 n は整数、または __ index __（）を実装するオブジェクトです。 n のゼロ値と負の値は、シーケンスをクリアします。 シーケンス内のアイテムはコピーされません。 共通シーケンス操作のs * nで説明されているように、これらは複数回参照されます。

リスト

リストは可変シーケンスであり、通常、同種のアイテムのコレクションを格納するために使用されます（正確な類似度はアプリケーションによって異なります）。

class list([iterable])

リストはいくつかの方法で作成できます。

• 空のリストを示すために角括弧のペアを使用する：[]

• 角かっこを使用して、項目をコンマで区切ります：[a]、[a, b, c]

• リスト内包表記の使用：[x for x in iterable]

• 型コンストラクターの使用：list()またはlist(iterable)

コンストラクターは、アイテムが iterable のアイテムと同じで同じ順序のリストを作成します。 iterable は、シーケンス、反復をサポートするコンテナー、またはイテレーターオブジェクトのいずれかです。 iterable がすでにリストになっている場合は、iterable[:]と同様に、コピーが作成されて返されます。 たとえば、list('abc')は['a', 'b', 'c']を返し、list( (1, 2, 3) )は[1, 2, 3]を返します。 引数が指定されていない場合、コンストラクターは新しい空のリスト[]を作成します。

sorted（）組み込みを含む、他の多くの操作もリストを生成します。

リストは、 common および mutable シーケンス操作のすべてを実装します。 リストには、次の追加の方法もあります。

sort(*, key=None, reverse=False)

このメソッドは、アイテム間の<比較のみを使用して、リストを所定の場所に並べ替えます。 例外は抑制されません。比較操作が失敗すると、並べ替え操作全体が失敗します（リストは部分的に変更された状態のままになる可能性があります）。

sort（）は、キーワードでのみ渡すことができる2つの引数を受け入れます（キーワードのみの引数）：

key は、各リスト要素から比較キーを抽出するために使用される1つの引数の関数を指定します（たとえば、key=str.lower）。 リスト内の各項目に対応するキーが1回計算され、ソートプロセス全体で使用されます。 Noneのデフォルト値は、個別のキー値を計算せずにリストアイテムが直接ソートされることを意味します。

functools.cmp_to_key（）ユーティリティを使用して、2.xスタイルの cmp 関数を key 関数に変換できます。

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

このメソッドは、大きなシーケンスをソートするときにスペースを節約するために、所定の位置にシーケンスを変更します。 副作用によって動作することをユーザーに通知するために、ソートされたシーケンスは返されません（ sorted（）を使用して、新しいソート済みリストインスタンスを明示的に要求します）。

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

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

タプル

タプルは不変のシーケンスであり、通常、異種データのコレクションを格納するために使用されます（ enumerate（）組み込みによって生成された2タプルなど）。 タプルは、同種のデータの不変のシーケンスが必要な場合にも使用されます（ set または dict インスタンスでのストレージの許可など）。

class tuple([iterable])

タプルは、いくつかの方法で構築できます。

• 空のタプルを示すために括弧のペアを使用する：()

• シングルトンタプルの末尾のコンマの使用：a,または(a,)

• アイテムをコンマで区切る：a, b, cまたは(a, b, c)

• tuple（）組み込みの使用：tuple()またはtuple(iterable)

コンストラクターは、アイテムが iterable のアイテムと同じで同じ順序のタプルを作成します。 iterable は、シーケンス、反復をサポートするコンテナー、またはイテレーターオブジェクトのいずれかです。 iterable がすでにタプルである場合、変更されずに返されます。 たとえば、tuple('abc')は('a', 'b', 'c')を返し、tuple( [1, 2, 3] )は(1, 2, 3)を返します。 引数が指定されていない場合、コンストラクターは新しい空のタプル()を作成します。

タプルを作成するのは実際にはカンマであり、括弧ではないことに注意してください。 空のタプルの場合、または構文のあいまいさを回避するために必要な場合を除いて、括弧はオプションです。 たとえば、f(a, b, c)は3つの引数を持つ関数呼び出しですが、f((a, b, c))は唯一の引数として3タプルを持つ関数呼び出しです。

タプルは、すべての common シーケンス操作を実装します。

名前によるアクセスがインデックスによるアクセスよりも明確である異種データのコレクションの場合、 collections.namedtuple（）が単純なタプルオブジェクトよりも適切な選択である可能性があります。

範囲

range タイプは、不変の数値シーケンスを表し、 for ループで特定の回数ループするために一般的に使用されます。

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

範囲コンストラクターの引数は整数である必要があります（組み込みの int または__index__特殊メソッドを実装するオブジェクト）。 step 引数を省略すると、デフォルトで1になります。 start 引数を省略すると、デフォルトで0になります。 step がゼロの場合、 ValueError が発生します。

正のステップの場合、範囲rの内容は、式r[i] = start + step*iによって決定されます。ここで、i >= 0およびr[i] < stopです。

負のステップの場合でも、範囲の内容は式r[i] = start + step*iによって決定されますが、制約はi >= 0およびr[i] > stopです。

r[0]が値の制約を満たさない場合、範囲オブジェクトは空になります。 範囲は負のインデックスをサポートしますが、これらは正のインデックスによって決定されるシーケンスの最後からのインデックスとして解釈されます。

sys.maxsize より大きい絶対値を含む範囲は許可されますが、一部の機能（ len（）など）では OverflowError が発生する場合があります。

範囲の例：

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

範囲は、連結と繰り返しを除くすべての common シーケンス操作を実装します（範囲オブジェクトは厳密なパターンに従うシーケンスのみを表すことができ、繰り返しと連結は通常そのパターンに違反するため）。

start

start パラメーターの値（または、パラメーターが指定されていない場合は0）

stop

stop パラメーターの値

step

step パラメーターの値（または、パラメーターが指定されていない場合は1）

通常のリストまたはタプルに対する範囲タイプの利点は、範囲オブジェクトが常に同じ（少量）量を取ることです。表現する範囲のサイズに関係なく、メモリの量（start、stop、stepの値のみを格納し、必要に応じて個々の項目とサブ範囲を計算するため）。

範囲オブジェクトは collections.abc.Sequence ABCを実装し、包含テスト、要素インデックスルックアップ、スライス、負のインデックスのサポートなどの機能を提供します（シーケンスタイプ—リスト、タプル、範囲[X222X ]）：：

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

==および!=を使用して範囲オブジェクトが等しいかどうかをテストすると、それらがシーケンスとして比較されます。 つまり、2つの範囲オブジェクトが同じ値のシーケンスを表す場合、それらは等しいと見なされます。 （等しいと比較する2つの範囲オブジェクトは、 start 、 stop および step 属性が異なる場合があることに注意してください（例：range(0) == range(2, 1, 3)または [ X158X]。）

バージョン3.2で変更：シーケンスABCを実装します。 スライスと負のインデックスをサポートします。 int オブジェクトのメンバーシップを、すべてのアイテムを反復処理するのではなく、一定時間でテストします。

バージョン3.3で変更：「==」と「！=」を定義して、（オブジェクトIDに基づいて比較するのではなく）定義した値のシーケンスに基づいて範囲オブジェクトを比較します。

バージョン3.3の新機能： start 、 stop 、および step 属性。

も参照してください

• linspaceレシピは、浮動小数点アプリケーションに適した範囲の遅延バージョンを実装する方法を示しています。

テキストシーケンスタイプ— str

Pythonのテキストデータは、 str オブジェクトまたは strings で処理されます。 文字列は、Unicodeコードポイントの不変のシーケンスです。 文字列リテラルはさまざまな方法で記述されます。

• 一重引用符：'allows embedded "double" quotes'
• 二重引用符："allows embedded 'single' quotes"。
• トリプルクォート：Three single quotes、"""Three double quotes"""

三重引用符で囲まれた文字列は複数行にまたがることがあります。関連するすべての空白は文字列リテラルに含まれます。

単一の式の一部であり、間に空白しかない文字列リテラルは、暗黙的に単一の文字列リテラルに変換されます。 つまり、("spam " "eggs") == "spam eggs"です。

サポートされているエスケープシーケンスや、ほとんどのエスケープシーケンス処理を無効にするr（「raw」）プレフィックスなど、さまざまな形式の文字列リテラルの詳細については、文字列およびバイトリテラルを参照してください。

文字列は、 str コンストラクターを使用して他のオブジェクトから作成することもできます。

個別の「文字」タイプがないため、文字列にインデックスを付けると、長さ1の文字列が生成されます。 つまり、空でない文字列 s の場合、s[0] == s[0:1]です。

変更可能な文字列型もありませんが、 str.join（）または io.StringIO を使用して、複数のフラグメントから文字列を効率的に構築できます。

バージョン3.3で変更： Python 2シリーズとの下位互換性のために、uプレフィックスが文字列リテラルで再び許可されます。 文字列リテラルの意味には影響せず、rプレフィックスと組み合わせることはできません。

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

文字列バージョンのオブジェクトを返します。 object が指定されていない場合、空の文字列を返します。 それ以外の場合、str()の動作は、次のように、エンコーディングまたはエラーのどちらが指定されているかによって異なります。

encoding も errors も指定されていない場合、str(object)は object .__ str __（）を返します。これは、「非公式」または適切に印刷可能な文字列表現です。 オブジェクトの。 文字列オブジェクトの場合、これは文字列自体です。 object に __ str __（）メソッドがない場合、 str（）はフォールバックして repr（object）を返します。

エンコーディングまたはエラーの少なくとも1つが指定されている場合、オブジェクトはバイトのようなオブジェクトである必要があります（例： bytes または bytearray ）。 この場合、 object が bytes （または bytearray ）オブジェクトである場合、str(bytes, encoding, errors)は bytes.decode（エンコーディング、エラー）。 それ以外の場合は、 bytes.decode（）を呼び出す前に、バッファオブジェクトの基礎となるbytesオブジェクトが取得されます。 バッファオブジェクトの詳細については、バイナリシーケンスタイプ—バイト、バイトアレイ、メモリビューおよびバッファプロトコルを参照してください。

encoding または errors 引数なしで bytes オブジェクトを str（）に渡すと、非公式の文字列表現を返す最初のケースに該当します（ Pythonの -b コマンドラインオプションも参照してください。 例えば：

>>> str(b'Zoot!')
"b'Zoot!'"

strクラスとそのメソッドの詳細については、以下のテキストシーケンスタイプ— str および文字列メソッドセクションを参照してください。 フォーマットされた文字列を出力するには、フォーマットされた文字列リテラルおよびフォーマット文字列構文のセクションを参照してください。 また、テキスト処理サービスのセクションを参照してください。

文字列メソッド

文字列は、すべての common シーケンス操作と、以下で説明する追加のメソッドを実装します。

文字列は2つのスタイルの文字列フォーマットもサポートします。1つは高度な柔軟性とカスタマイズを提供します（ str.format（）、フォーマット文字列構文およびカスタム文字列フォーマットを参照） ]）およびC printfスタイルのフォーマットに基づくもので、より狭い範囲のタイプを処理し、正しく使用するのは少し難しいですが、処理できる場合は多くの場合高速です（ printf-style String Formatting ）。

標準ライブラリのテキスト処理サービスセクションには、さまざまなテキスト関連ユーティリティを提供する他の多くのモジュールが含まれています（ re モジュールでの正規表現のサポートを含む）。

str.capitalize()

最初の文字を大文字にし、残りを小文字にした文字列のコピーを返します。

バージョン3.8で変更：最初の文字が大文字ではなくタイトルケースに入れられるようになりました。 これは、有向グラフのような文字では、完全な文字ではなく、最初の文字のみが大文字になることを意味します。

str.casefold()

文字列の大文字と小文字を区別したコピーを返します。 大文字と小文字を区別しない文字列は、大文字と小文字を区別しないマッチングに使用できます。

大文字小文字の区別は小文字に似ていますが、文字列内のすべての大文字小文字の区別を削除することを目的としているため、より積極的です。 たとえば、ドイツ語の小文字'ß'は、"ss"と同等です。 すでに小文字であるため、 lower（）は'ß'に対して何もしません。 casefold（）はそれを"ss"に変換します。

ケースフォールディングアルゴリズムは、Unicode標準のセクション3.13で説明されています。

バージョン3.3の新機能。

str.center(width[, fillchar])

長さ幅の文字列の中央に戻ります。 パディングは、指定された fillchar （デフォルトはASCIIスペース）を使用して行われます。 width がlen(s)以下の場合、元の文字列が返されます。

str.count(sub[, start[, end]])

[ start 、 end ]の範囲内の部分文字列 sub の重複しない出現回数を返します。 オプションの引数 start および end は、スライス表記のように解釈されます。

str.encode(encoding='utf-8', errors='strict')

文字列のエンコードされたバージョンをbytesオブジェクトとして返します。 デフォルトのエンコーディングは'utf-8'です。 エラーは、別のエラー処理スキームを設定するために指定される場合があります。 エラーのデフォルトは'strict'です。これは、エンコードエラーによって UnicodeError が発生することを意味します。 その他の可能な値は、'ignore'、'replace'、'xmlcharrefreplace'、'backslashreplace'、および codecs.register_error（）を介して登録されたその他の名前です。を参照してください。セクションエラーハンドラー。 可能なエンコーディングのリストについては、セクション標準エンコーディングを参照してください。

デフォルトでは、 errors 引数は最高のパフォーマンスが得られるかどうかはチェックされませんが、最初のエンコードエラーでのみ使用されます。 Python開発モードを有効にするか、デバッグビルドを使用してエラーを確認してください。

バージョン3.1で変更：キーワード引数のサポートが追加されました。

バージョン3.9で変更： エラーは、開発モードとデバッグモードでチェックされるようになりました。

str.endswith(suffix[, start[, end]])

文字列が指定されたサフィックスで終わる場合は、Trueを返します。それ以外の場合は、Falseを返します。 サフィックスは、検索するサフィックスのタプルにすることもできます。 オプションの start を使用して、その位置からテストを開始します。 オプションの end を使用して、その位置での比較を停止します。

str.expandtabs(tabsize=8)

現在の列と指定されたタブサイズに応じて、すべてのタブ文字が1つ以上のスペースに置き換えられた文字列のコピーを返します。 タブ位置は tabsize 文字ごとに発生します（デフォルトは8で、列0、8、16などにタブ位置があります）。 文字列を展開するには、現在の列をゼロに設定し、文字列を1文字ずつ調べます。 文字がタブ（\t）の場合、現在の列が次のタブ位置と等しくなるまで、1つ以上のスペース文字が結果に挿入されます。 （タブ文字自体はコピーされません。）文字が改行（\n）または戻り文字（\r）の場合、コピーされ、現在の列はゼロにリセットされます。 他の文字は変更されずにコピーされ、印刷時の文字の表現方法に関係なく、現在の列が1つインクリメントされます。

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'

str.find(sub[, start[, end]])

スライスs[start:end]内でサブ文字列 sub が見つかった文字列の最小のインデックスを返します。 オプションの引数 start および end は、スライス表記のように解釈されます。 sub が見つからない場合は、-1を返します。

ノート

find（）メソッドは、 sub の位置を知る必要がある場合にのみ使用してください。 sub が部分文字列であるかどうかを確認するには、 in 演算子を使用します。

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)

文字列フォーマット操作を実行します。 このメソッドが呼び出される文字列には、中括弧{}で区切られたリテラルテキストまたは置換フィールドを含めることができます。 各置換フィールドには、位置引数の数値インデックスまたはキーワード引数の名前のいずれかが含まれます。 各置換フィールドが対応する引数の文字列値で置き換えられた文字列のコピーを返します。

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

フォーマット文字列で指定できるさまざまなフォーマットオプションの説明については、フォーマット文字列構文を参照してください。

ノート

数値（ int 、 float 、 complex 、 decimal.Decimal およびサブクラス）をnタイプでフォーマットする場合（例：'{:n}'.format(1234)）、関数は一時的にLC_CTYPEロケールをLC_NUMERICロケールに設定して、decimal_pointおよびthousands_sepフィールドをデコードします。 X275X] が非ASCIIまたは1バイトより長く、LC_NUMERICロケールがLC_CTYPEロケールと異なる場合。 この一時的な変更は他のスレッドに影響します。

バージョン3.7で変更： nタイプで数値をフォーマットすると、関数は一時的にLC_CTYPEロケールをLC_NUMERICロケールに設定する場合があります。

str.format_map(mapping)

str.format(**mapping)と同様ですが、mappingが直接使用され、 dict にコピーされない点が異なります。 これは、たとえばmappingがdictサブクラスである場合に役立ちます。

>>> class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

バージョン3.2の新機能。

str.index(sub[, start[, end]])

find（）と同様ですが、部分文字列が見つからない場合は ValueError を発生させます。

str.isalnum()

文字列内のすべての文字が英数字であり、少なくとも1文字ある場合は、Trueを返します。それ以外の場合は、Falseを返します。 次のいずれかがTrueを返す場合、文字cは英数字です：c.isalpha()、c.isdecimal()、c.isdigit()、または [X121X ]。

str.isalpha()

文字列内のすべての文字がアルファベットで、少なくとも1文字ある場合は、Trueを返し、それ以外の場合はFalseを返します。 アルファベット文字は、Unicode文字データベースで「文字」として定義されている文字です。つまり、一般的なカテゴリプロパティが「Lm」、「Lt」、「Lu」、「Ll」、または「Lo」のいずれかである文字です。 これは、Unicode標準で定義されている「アルファベット」プロパティとは異なることに注意してください。

str.isascii()

文字列が空の場合、または文字列内のすべての文字がASCIIの場合は、Trueを返し、それ以外の場合はFalseを返します。 ASCII文字には、U + 0000-U + 007Fの範囲のコードポイントがあります。

バージョン3.7の新機能。

str.isdecimal()

文字列内のすべての文字が10進文字であり、少なくとも1文字ある場合は、Trueを返します。それ以外の場合は、Falseを返します。 10進文字は、基数10の数値を形成するために使用できる文字です。 U + 0660、アラビア語-INDIC DIGITZERO。 正式には、10進文字はUnicode一般カテゴリ「Nd」の文字です。

str.isdigit()

文字列内のすべての文字が数字であり、少なくとも1文字ある場合は、Trueを返します。それ以外の場合は、Falseを返します。 数字には、10進文字と、互換性の上付き数字などの特別な処理が必要な数字が含まれます。 これは、カローシュティー文字のように、基数10の数値を形成するために使用できない数字を対象としています。 正式には、数字は、プロパティ値Numeric_Type = DigitまたはNumeric_Type = Decimalを持つ文字です。

str.isidentifier()

文字列が言語定義のセクション識別子とキーワードに従って有効な識別子である場合は、Trueを返します。

keyword.iskeyword（）を呼び出して、文字列sが def や class などの予約済み識別子であるかどうかをテストします。

例：

>>> from keyword import iskeyword

>>> 'hello'.isidentifier(), iskeyword('hello')
True, False
>>> 'def'.isidentifier(), iskeyword('def')
True, True

str.islower()

文字列内の大文字と小文字がすべて 4 で、大文字と小文字が少なくとも1つある場合は、Trueを返し、それ以外の場合はFalseを返します。

str.isnumeric()

文字列内のすべての文字が数字であり、少なくとも1文字ある場合は、Trueを返します。それ以外の場合は、Falseを返します。 数字には、数字、およびUnicode数値プロパティを持つすべての文字が含まれます。 U + 2155、VULGAR FRACTION1 / 5。 正式には、数字はプロパティ値Numeric_Type = Digit、Numeric_Type = DecimalまたはNumeric_Type = Numericを持つ文字です。

str.isprintable()

文字列内のすべての文字が印刷可能であるか、文字列が空の場合はTrueを返し、それ以外の場合はFalseを返します。 印刷不可能な文字とは、Unicode文字データベースで「その他」または「区切り文字」として定義されている文字です。ただし、印刷可能と見なされるASCIIスペース（0x20）は除きます。 （このコンテキストでの印刷可能な文字は、 repr（）が文字列で呼び出されたときにエスケープしてはならない文字であることに注意してください。 sys.stdout または sys.stderr に書き込まれた文字列の処理には関係ありません。）

str.isspace()

文字列に空白文字のみがあり、少なくとも1文字ある場合は、Trueを返します。それ以外の場合は、Falseを返します。

Unicode文字データベース（ unicodedata を参照）で、その一般カテゴリがZs（「区切り文字、スペース」）であるか、双方向クラスである場合、文字は空白です。 WS、B、またはSのいずれかです。

str.istitle()

文字列が大文字の文字列であり、少なくとも1つの文字がある場合は、Trueを返します。たとえば、大文字は大文字以外の文字のみに続き、小文字は大文字のみの文字のみを続けることができます。 それ以外の場合はFalseを返します。

str.isupper()

文字列内の大文字と小文字がすべて 4 で、大文字と小文字が少なくとも1つある場合は、Trueを返し、それ以外の場合はFalseを返します。

>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
False

str.join(iterable)

iterable の文字列を連結した文字列を返します。 bytes オブジェクトを含め、 iterable に文字列以外の値がある場合、 TypeError が発生します。 要素間の区切り文字は、このメソッドを提供する文字列です。

str.ljust(width[, fillchar])

長さ幅の文字列で左寄せされた文字列を返します。 パディングは、指定された fillchar （デフォルトはASCIIスペース）を使用して行われます。 width がlen(s)以下の場合、元の文字列が返されます。

str.lower()

大文字と小文字がすべて 4 が小文字に変換された文字列のコピーを返します。

使用される小文字のアルゴリズムは、Unicode標準のセクション3.13で説明されています。

str.lstrip([chars])

先頭の文字が削除された文字列のコピーを返します。 chars 引数は、削除する文字のセットを指定する文字列です。 省略またはNoneの場合、 chars 引数はデフォルトで空白を削除します。 chars 引数はプレフィックスではありません。 むしろ、その値のすべての組み合わせが削除されます。

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

すべての文字セットではなく単一のプレフィックス文字列を削除するメソッドについては、 str.removeprefix（）を参照してください。 例えば：

>>> 'Arthur: three!'.lstrip('Arthur: ')
'ee!'
>>> 'Arthur: three!'.removeprefix('Arthur: ')
'three!'

static str.maketrans(x[, y[, z]])

この静的メソッドは、 str.translate（）に使用できる変換テーブルを返します。

引数が1つしかない場合は、Unicode序数（整数）または文字（長さ1の文字列）をUnicode序数、文字列（任意の長さ）またはNoneにマッピングする辞書である必要があります。 その後、文字キーは序数に変換されます。

2つの引数がある場合、それらは同じ長さの文字列である必要があり、結果の辞書では、xの各文字がyの同じ位置の文字にマップされます。 3番目の引数がある場合、それは文字列である必要があり、その文字は結果でNoneにマップされます。

str.partition(sep)

sep の最初の出現時に文字列を分割し、セパレーターの前の部分、セパレーター自体、およびセパレーターの後の部分を含む3タプルを返します。 セパレータが見つからない場合は、文字列自体を含む3タプルを返し、その後に2つの空の文字列が続きます。

str.removeprefix(prefix, /)

文字列が prefix 文字列で始まる場合は、string[len(prefix):]を返します。 それ以外の場合は、元の文字列のコピーを返します。

>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

バージョン3.9の新機能。

str.removesuffix(suffix, /)

文字列がサフィックス文字列で終わり、そのサフィックスが空でない場合は、string[:-len(suffix)]を返します。 それ以外の場合は、元の文字列のコピーを返します。

>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'

バージョン3.9の新機能。

str.replace(old, new[, count])

すべての部分文字列 old が new に置き換えられた文字列のコピーを返します。 オプションの引数 count を指定すると、最初の count オカレンスのみが置き換えられます。

str.rfind(sub[, start[, end]])

sub がs[start:end]内に含まれるように、サブ文字列 sub が見つかった文字列の最高のインデックスを返します。 オプションの引数 start および end は、スライス表記のように解釈されます。 失敗した場合は-1を返します。

str.rindex(sub[, start[, end]])

rfind（）と同様ですが、サブストリング sub が見つからない場合に ValueError を発生させます。

str.rjust(width[, fillchar])

長さ幅の文字列で右寄せされた文字列を返します。 パディングは、指定された fillchar （デフォルトはASCIIスペース）を使用して行われます。 width がlen(s)以下の場合、元の文字列が返されます。

str.rpartition(sep)

sep の最後のオカレンスで文字列を分割し、セパレーターの前の部分、セパレーター自体、およびセパレーターの後の部分を含む3タプルを返します。 セパレータが見つからない場合は、2つの空の文字列を含む3タプルを返し、その後に文字列自体を返します。

str.rsplit(sep=None, maxsplit=- 1)

sep を区切り文字列として使用して、文字列内の単語のリストを返します。 maxsplit が指定されている場合、最大で maxsplit 分割が実行され、右端分割が実行されます。 sep が指定されていないかNoneの場合、空白文字列は区切り文字になります。 右から分割することを除いて、 rsplit（）は split（）のように動作します。これについては以下で詳しく説明します。

str.rstrip([chars])

末尾の文字が削除された文字列のコピーを返します。 chars 引数は、削除する文字のセットを指定する文字列です。 省略またはNoneの場合、 chars 引数はデフォルトで空白を削除します。 chars 引数はサフィックスではありません。 むしろ、その値のすべての組み合わせが削除されます。

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

すべての文字セットではなく単一のサフィックス文字列を削除するメソッドについては、 str.removesuffix（）を参照してください。 例えば：

>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'

str.split(sep=None, maxsplit=- 1)

sep を区切り文字列として使用して、文字列内の単語のリストを返します。 maxsplit が指定されている場合、最大で maxsplit の分割が実行されます（したがって、リストには最大でmaxsplit+1要素が含まれます）。 maxsplit が指定されていないか-1の場合、分割数に制限はありません（可能なすべての分割が行われます）。

sep が指定されている場合、連続する区切り文字はグループ化されず、空の文字列を区切ると見なされます（たとえば、'1,,2'.split(',')は['1', , '2']を返します）。 sep 引数は、複数の文字で構成されている場合があります（たとえば、'1<>2<>3'.split('<>')は['1', '2', '3']を返します）。 空の文字列を指定された区切り文字で分割すると、[]が返されます。

例えば：

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']

sep が指定されていないか、Noneの場合、異なる分割アルゴリズムが適用されます。連続する空白の実行は単一の区切り文字と見なされ、結果には先頭に空の文字列が含まれません。文字列に先頭または末尾の空白がある場合は終了します。 したがって、空の文字列または空白だけで構成される文字列をNone区切り文字で分割すると、[]が返されます。

例えば：

>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']

str.splitlines([keepends])

文字列内の行のリストを返し、行の境界で区切ります。 keepends が指定され、trueでない限り、改行は結果のリストに含まれません。

このメソッドは、次の行境界で分割されます。 特に、境界はユニバーサルニューラインのスーパーセットです。

表現	説明
\n	改行
\r	キャリッジリターン
\r\n	キャリッジリターン+ラインフィード
\vまたは\x0b	ライン集計
\fまたは\x0c	フォームフィード
\x1c	ファイル区切り文字
\x1d	グループ区切り文字
\x1e	レコード区切り文字
\x85	次の行（C1制御コード）
\u2028	ラインセパレーター
\u2029	段落区切り文字

バージョン3.2で変更： \vおよび\fが行境界のリストに追加されました。

例えば：

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

区切り文字列 sep が指定された場合の split（）とは異なり、このメソッドは空の文字列に対して空のリストを返し、終端の改行によって余分な行が生成されることはありません。

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

比較のために、split('\n')は次のようになります。

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

str.startswith(prefix[, start[, end]])

文字列がプレフィックスで始まる場合はTrueを返し、そうでない場合はFalseを返します。 prefix は、検索するプレフィックスのタプルにすることもできます。 オプションの start を使用して、その位置から始まる文字列をテストします。 オプションの end を使用して、その位置で文字列の比較を停止します。

str.strip([chars])

先頭と末尾の文字が削除された文字列のコピーを返します。 chars 引数は、削除する文字のセットを指定する文字列です。 省略またはNoneの場合、 chars 引数はデフォルトで空白を削除します。 chars 引数は接頭辞または接尾辞ではありません。 むしろ、その値のすべての組み合わせが削除されます。

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

最も外側の先頭と末尾の chars 引数値が文字列から削除されます。 chars の文字セットに含まれていない文字列文字に到達するまで、文字は先頭から削除されます。 同様のアクションがトレーリングエンドで発生します。 例えば：

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'

str.swapcase()

大文字を小文字に、またはその逆に変換した文字列のコピーを返します。 s.swapcase().swapcase() == sが必ずしも正しいとは限らないことに注意してください。

str.title()

単語が大文字で始まり、残りの文字が小文字である文字列の大文字のバージョンを返します。

例えば：

>>> 'Hello world'.title()
'Hello World'

アルゴリズムは、連続する文字のグループとして単語の単純な言語に依存しない定義を使用します。 この定義は多くの文脈で機能しますが、縮約と所有格のアポストロフィが単語の境界を形成することを意味します。これは望ましい結果ではない可能性があります。

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

アポストロフィの回避策は、正規表現を使用して作成できます。

>>> import re
>>> def titlecase(s):
...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0).capitalize(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

str.translate(table)

指定された変換テーブルを介して各文字がマップされている文字列のコピーを返します。 テーブルは、__getitem__()、通常はマッピングまたはシーケンスを介してインデックスを実装するオブジェクトである必要があります。 Unicode序数（整数）でインデックスを付けると、テーブルオブジェクトは次のいずれかを実行できます。Unicode序数または文字列を返し、文字を1つ以上の他の文字にマップします。 Noneを返し、戻り文字列から文字を削除します。 または、 LookupError 例外を発生させて、文字をそれ自体にマップします。

str.maketrans（）を使用して、さまざまな形式の文字間マッピングから変換マップを作成できます。

カスタム文字マッピングへのより柔軟なアプローチについては、コーデックモジュールも参照してください。

str.upper()

大文字と小文字がすべて 4 に変換された文字列のコピーを返します。 sに大文字と小文字が区別されない文字が含まれている場合、または結果の文字のUnicodeカテゴリが「Lu」（文字、大文字）ではなく、例えば 「lt」（レター、タイトルケース）。

使用される大文字のアルゴリズムは、Unicode標準のセクション3.13で説明されています。

str.zfill(width)

ASCII '0'桁で埋められたままの文字列のコピーを返し、長さ幅の文字列を作成します。 先頭の記号プレフィックス（'+' / '-'）は、記号文字の前ではなくの後にパディングを挿入することによって処理されます。 width がlen(s)以下の場合、元の文字列が返されます。

例えば：

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

printfスタイルの文字列フォーマット

ノート

ここで説明するフォーマット操作は、多くの一般的なエラー（タプルと辞書を正しく表示できないなど）につながるさまざまな癖を示します。 新しい形式の文字列リテラル、 str.format（）インターフェイス、またはテンプレート文字列を使用すると、これらのエラーを回避できる場合があります。 これらの選択肢はそれぞれ、単純さ、柔軟性、および/または拡張性という独自のトレードオフと利点を提供します。

文字列オブジェクトには、%演算子（モジュロ）という1つの固有の組み込み演算があります。 これは、文字列 formating または interpolation 演算子とも呼ばれます。 format % values（ format は文字列）を指定すると、 format の%変換仕様は、値[の0個以上の要素に置き換えられます。 X161X]。 効果は、C言語でsprintf()を使用する場合と同様です。

format が単一の引数を必要とする場合、 values は単一の非タプルオブジェクトである可能性があります。 5 それ以外の場合、 values は、フォーマット文字列で指定された正確な数のアイテムを持つタプル、または単一のマッピングオブジェクト（辞書など）である必要があります。

変換指定子には2つ以上の文字が含まれ、次のコンポーネントがあります。これらはこの順序で発生する必要があります。

1. 指定子の開始を示す'%'文字。
2. 括弧で囲まれた文字シーケンス（(somename)など）で構成されるマッピングキー（オプション）。
3. 一部の変換タイプの結果に影響を与える変換フラグ（オプション）。
4. 最小フィールド幅（オプション）。 '*'（アスタリスク）として指定されている場合、実際の幅は values のタプルの次の要素から読み取られ、変換するオブジェクトは最小フィールド幅とオプションの精度の後になります。
5. 精度（オプション）。'.'（ドット）の後に精度が続きます。 '*'（アスタリスク）として指定されている場合、実際の精度は values のタプルの次の要素から読み取られ、変換する値は精度の後になります。
6. 長さ修飾子（オプション）。
7. 変換タイプ。

右の引数が辞書（または他のマッピングタイプ）の場合、文字列 must の形式には、'%'文字の直後に挿入される辞書に括弧で囲まれたマッピングキーが含まれている必要があります。 マッピングキーは、マッピングからフォーマットする値を選択します。 例えば：

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

この場合、*指定子をフォーマットで使用することはできません（順次パラメーターリストが必要なため）。

変換フラグの文字は次のとおりです。

国旗	意味
'#'	値の変換では、「代替形式」（以下で定義）が使用されます。
'0'	変換は、数値に対してゼロが埋め込まれます。
'-'	変換された値は調整されたままになります（両方が指定されている場合、'0'変換をオーバーライドします）。
' '	（スペース）符号付き変換によって生成される正の数（または空の文字列）の前に空白を残す必要があります。
'+'	符号文字（'+'または'-'）が変換の前に配置されます（「スペース」フラグをオーバーライドします）。

長さ修飾子（h、l、またはL）が存在する場合がありますが、Pythonには必要ないため、無視されます。 %ldは%dと同じです。

変換タイプは次のとおりです。

会話	意味	ノート
'd'	符号付き整数10進数。
'i'	符号付き整数10進数。
'o'	符号付き8進値。	(1)
'u'	廃止されたタイプ– 'd'と同じです。	(6)
'x'	符号付き16進数（小文字）。	(2)
'X'	符号付き16進数（大文字）。	(2)
'e'	浮動小数点指数形式（小文字）。	(3)
'E'	浮動小数点指数形式（大文字）。	(3)
'f'	浮動小数点10進形式。	(3)
'F'	浮動小数点10進形式。	(3)
'g'	浮動小数点形式。 指数が-4未満または精度以上の場合は小文字の指数形式を使用し、それ以外の場合は10進形式を使用します。	(4)
'G'	浮動小数点形式。 指数が-4未満または精度以上の場合は大文字の指数形式を使用し、それ以外の場合は10進形式を使用します。	(4)
'c'	単一文字（整数または単一文字ストリングを受け入れます）。
'r'	文字列（ repr（）を使用してPythonオブジェクトを変換します）。	(5)
's'	文字列（ str（）を使用してPythonオブジェクトを変換します）。	(5)
'a'	文字列（ ascii（）を使用してPythonオブジェクトを変換します）。	(5)
'%'	引数は変換されず、結果は'%'文字になります。

ノート：

1. 別の形式では、先頭の8進数指定子（'0o'）が最初の桁の前に挿入されます。

2. 別の形式では、先頭の'0x'または'0X'（'x'または'X'形式のどちらが使用されたかによって異なります）が最初の桁の前に挿入されます。

3. 別の形式では、数字が続かない場合でも、結果には常に小数点が含まれます。

   精度は小数点以下の桁数を決定し、デフォルトは6です。

4. 別の形式では、結果に常に小数点が含まれ、後続のゼロはそうでない場合のように削除されません。

   精度は、小数点の前後の有効桁数を決定し、デフォルトは6です。

5. 精度がNの場合、出力はN文字に切り捨てられます。

6. PEP 237 を参照してください。

Python文字列には明示的な長さがあるため、%s変換では、'\0'が文字列の終わりであるとは想定されていません。

バージョン3.1で変更：絶対値が1e50を超える数値の %f変換は、%g変換に置き換えられなくなりました。

バイナリシーケンスタイプ— bytes 、 bytearray 、 memoryview

バイナリデータを操作するためのコア組み込み型は、 bytes および bytearray です。 これらは、バッファプロトコルを使用してコピーを作成せずに他のバイナリオブジェクトのメモリにアクセスする memoryview によってサポートされています。

array モジュールは、32ビット整数やIEEE754倍精度浮動小数点値などの基本的なデータ型の効率的なストレージをサポートします。

バイトオブジェクト

バイトオブジェクトは、単一バイトの不変のシーケンスです。 多くの主要なバイナリプロトコルはASCIIテキストエンコーディングに基づいているため、bytesオブジェクトは、ASCII互換データを処理する場合にのみ有効であり、他のさまざまな方法で文字列オブジェクトと密接に関連するいくつかのメソッドを提供します。

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

まず、バイトリテラルの構文は、bプレフィックスが追加されていることを除いて、文字列リテラルの構文とほぼ同じです。

• 一重引用符：b'still allows embedded "double" quotes'

• 二重引用符：b"still allows embedded 'single' quotes"。

• トリプルクォート：b3 single quotes、b"""3 double quotes"""

バイトリテラルではASCII文字のみが許可されます（宣言されたソースコードエンコーディングに関係なく）。 127を超えるバイナリ値は、適切なエスケープシーケンスを使用してバイトリテラルに入力する必要があります。

文字列リテラルと同様に、バイトリテラルもrプレフィックスを使用して、エスケープシーケンスの処理を無効にすることができます。 サポートされているエスケープシーケンスを含む、さまざまな形式のバイトリテラルの詳細については、文字列およびバイトリテラルを参照してください。

バイトリテラルと表現はASCIIテキストに基づいていますが、バイトオブジェクトは実際には不変の整数シーケンスのように動作し、シーケンス内の各値は0 <= x < 256のように制限されます（この制限に違反しようとすると ValueError がトリガーされます]）。 これは、多くのバイナリ形式にASCIIベースの要素が含まれており、一部のテキスト指向のアルゴリズムで便利に操作できることを強調するために意図的に行われますが、これは通常、任意のバイナリデータには当てはまりません（テキスト処理アルゴリズムをそうでないバイナリデータ形式に盲目的に適用する） ASCII互換は通常、データの破損につながります）。

リテラル形式に加えて、bytesオブジェクトは他の多くの方法で作成できます。

• 指定された長さのゼロで埋められたバイトオブジェクト：bytes(10)

• 整数の反復可能から：bytes(range(20))

• バッファプロトコルを介した既存のバイナリデータのコピー：bytes(obj)

bytes 組み込みも参照してください。

2桁の16進数は1バイトに正確に対応するため、16進数はバイナリデータを記述するために一般的に使用される形式です。 したがって、bytesタイプには、その形式でデータを読み取るための追加のクラスメソッドがあります。

classmethod fromhex(string)

この bytes クラスメソッドはbytesオブジェクトを返し、指定された文字列オブジェクトをデコードします。 文字列には、バイトごとに2桁の16進数が含まれている必要があり、ASCII空白は無視されます。

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

バージョン3.7で変更： bytes.fromhex（）は、スペースだけでなく、文字列内のすべてのASCII空白をスキップするようになりました。

バイトオブジェクトを16進表現に変換するための逆変換関数が存在します。

hex([sep[, bytes_per_sep]])

インスタンスのバイトごとに2桁の16進数を含む文字列オブジェクトを返します。

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

16進文字列を読みやすくしたい場合は、出力に含める単一文字の区切り文字 sep パラメーターを指定できます。 デフォルトでは、各バイト間。 2番目のオプションの bytes_per_sep パラメーターは、間隔を制御します。 正の値は右からセパレーターの位置を計算し、負の値は左からセパレーターの位置を計算します。

>>> value = b'\xf0\xf1\xf2'
>>> value.hex('-')
'f0-f1-f2'
>>> value.hex('_', 2)
'f0_f1f2'
>>> b'UUDDLRLRAB'.hex(' ', -4)
'55554444 4c524c52 4142'

バージョン3.5の新機能。

バージョン3.8で変更： bytes.hex（）は、オプションの sep および bytes_per_sep パラメーターをサポートして、16進出力のバイト間にセパレーターを挿入するようになりました。 。

バイトオブジェクトは整数のシーケンス（タプルに似ています）であるため、バイトオブジェクト b の場合、b[0]は整数になり、b[0:1]はのバイトオブジェクトになります。長さ1。 （これは、インデックス作成とスライスの両方で長さ1の文字列が生成されるテキスト文字列とは対照的です）

バイトオブジェクトの表現は、リテラル形式（b'...'）を使用します。これは、たとえば、 bytes([46, 46, 46])。 list(b)を使用すると、いつでもバイトオブジェクトを整数のリストに変換できます。

ノート

Python 2.xユーザーの場合：Python 2.xシリーズでは、8ビット文字列（2.xが組み込みのバイナリデータ型に最も近いもの）とUnicode文字列の間のさまざまな暗黙的な変換が許可されていました。 これは、Pythonが元々8ビットテキストのみをサポートし、Unicodeテキストが後で追加されたという事実を説明するための下位互換性の回避策でした。 Python 3.xでは、これらの暗黙的な変換はなくなりました。8ビットのバイナリデータとUnicodeテキストの間の変換は明示的である必要があり、バイトオブジェクトと文字列オブジェクトは常に等しくありません。

Bytearrayオブジェクト

bytearray オブジェクトは、 bytes オブジェクトに対応する変更可能なオブジェクトです。

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

bytearrayオブジェクト専用のリテラル構文はありません。代わりに、コンストラクターを呼び出すことによって常に作成されます。

• 空のインスタンスの作成：bytearray()

• 指定された長さのゼロで埋められたインスタンスを作成します：bytearray(10)

• 整数の反復可能から：bytearray(range(20))

• バッファプロトコルを介した既存のバイナリデータのコピー：bytearray(b'Hi!')

バイト配列オブジェクトは可変であるため、バイトおよびバイト配列操作で説明されている一般的なバイトおよびバイト配列操作に加えて、可変シーケンス操作をサポートします。

bytearray 組み込みも参照してください。

2桁の16進数は1バイトに正確に対応するため、16進数はバイナリデータを記述するために一般的に使用される形式です。 したがって、bytearrayタイプには、その形式でデータを読み取るための追加のクラスメソッドがあります。

classmethod fromhex(string)

この bytearray クラスのメソッドは、bytearrayオブジェクトを返し、指定された文字列オブジェクトをデコードします。 文字列には、バイトごとに2桁の16進数が含まれている必要があり、ASCII空白は無視されます。

>>> bytearray.fromhex('2Ef0 F1f2  ')
bytearray(b'.\xf0\xf1\xf2')

バージョン3.7で変更： bytearray.fromhex（）は、スペースだけでなく、文字列内のすべてのASCII空白をスキップするようになりました。

bytearrayオブジェクトを16進表現に変換するための逆変換関数が存在します。

hex([sep[, bytes_per_sep]])

インスタンスのバイトごとに2桁の16進数を含む文字列オブジェクトを返します。

>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'

バージョン3.5の新機能。

バージョン3.8で変更： bytes.hex（）と同様に、 bytearray.hex（）はオプションの sep およびをサポートするようになりましたbytes_per_sep パラメーターを使用して、16進出力のバイト間にセパレーターを挿入します。

bytearrayオブジェクトは（リストに似た）整数のシーケンスであるため、bytearrayオブジェクト b の場合、b[0]は整数になり、b[0:1]はのbytearrayオブジェクトになります。長さ1。 （これは、インデックス作成とスライスの両方で長さ1の文字列が生成されるテキスト文字列とは対照的です）

bytearrayオブジェクトの表現は、バイトリテラル形式（bytearray(b'...')）を使用します。これは、たとえば、 bytearray([46, 46, 46])。 list(b)を使用すると、bytearrayオブジェクトをいつでも整数のリストに変換できます。

バイトおよびBytearray操作

byteオブジェクトとbytearrayオブジェクトはどちらも、 common シーケンス操作をサポートしています。 これらは、同じタイプのオペランドだけでなく、バイトのようなオブジェクトとも相互運用します。 この柔軟性により、エラーを発生させることなく、操作に自由に混在させることができます。 ただし、結果の戻りタイプは、オペランドの順序によって異なる場合があります。

ノート

文字列のメソッドが引数としてバイトを受け入れないのと同様に、bytesおよびbytearrayオブジェクトのメソッドは引数として文字列を受け入れません。 たとえば、次のように書く必要があります。

a = "abc"
b = a.replace("a", "f")

と：

a = b"abc"
b = a.replace(b"a", b"f")

一部のバイトおよびバイト配列操作は、ASCII互換のバイナリ形式の使用を想定しているため、任意のバイナリデータを操作する場合は避ける必要があります。 これらの制限については、以下で説明します。

ノート

これらのASCIIベースの操作を使用して、ASCIIベースの形式で保存されていないバイナリデータを操作すると、データが破損する可能性があります。

バイトおよびbytearrayオブジェクトに対する次のメソッドは、任意のバイナリデータで使用できます。

bytes.count(sub[, start[, end]])
bytearray.count(sub[, start[, end]])

[ start 、 end ]の範囲内のサブシーケンス sub の重複しないオカレンスの数を返します。 オプションの引数 start および end は、スライス表記のように解釈されます。

検索するサブシーケンスは、バイトのようなオブジェクトまたは0〜255の範囲の整数です。

バージョン3.3で変更：サブシーケンスとして0〜255の範囲の整数も受け入れます。

bytes.removeprefix(prefix, /)
bytearray.removeprefix(prefix, /)

バイナリデータがプレフィックス文字列で始まる場合は、bytes[len(prefix):]を返します。 それ以外の場合は、元のバイナリデータのコピーを返します。

>>> b'TestHook'.removeprefix(b'Test')
b'Hook'
>>> b'BaseTestCase'.removeprefix(b'Test')
b'BaseTestCase'

プレフィックスは、バイトのようなオブジェクトであればどれでもかまいません。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

バージョン3.9の新機能。

bytes.removesuffix(suffix, /)
bytearray.removesuffix(suffix, /)

バイナリデータがサフィックス文字列で終わり、そのサフィックスが空でない場合は、bytes[:-len(suffix)]を返します。 それ以外の場合は、元のバイナリデータのコピーを返します。

>>> b'MiscTests'.removesuffix(b'Tests')
b'Misc'
>>> b'TmpDirMixin'.removesuffix(b'Tests')
b'TmpDirMixin'

サフィックスは、バイトのようなオブジェクトであればどれでもかまいません。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

バージョン3.9の新機能。

bytes.decode(encoding='utf-8', errors='strict')
bytearray.decode(encoding='utf-8', errors='strict')

指定されたバイトからデコードされた文字列を返します。 デフォルトのエンコーディングは'utf-8'です。 エラーは、別のエラー処理スキームを設定するために指定される場合があります。 エラーのデフォルトは'strict'です。これは、エンコードエラーによって UnicodeError が発生することを意味します。 その他の可能な値は、'ignore'、'replace'、および codecs.register_error（）を介して登録されたその他の名前です。セクションエラーハンドラーを参照してください。 可能なエンコーディングのリストについては、セクション標準エンコーディングを参照してください。

デフォルトでは、 errors 引数は、最高のパフォーマンスが得られるかどうかはチェックされませんが、最初のデコードエラーでのみ使用されます。 Python開発モードを有効にするか、デバッグビルドを使用してエラーを確認してください。

ノート

encoding 引数を str に渡すと、一時的なバイトやバイト配列オブジェクトを作成しなくても、バイトのようなオブジェクトを直接デコードできます。

バージョン3.1で変更：キーワード引数のサポートが追加されました。

バージョン3.9で変更： エラーは、開発モードとデバッグモードでチェックされるようになりました。

bytes.endswith(suffix[, start[, end]])
bytearray.endswith(suffix[, start[, end]])

バイナリデータが指定されたサフィックスで終わる場合はTrueを返し、それ以外の場合はFalseを返します。 サフィックスは、検索するサフィックスのタプルにすることもできます。 オプションの start を使用して、その位置からテストを開始します。 オプションの end を使用して、その位置での比較を停止します。

検索するサフィックスは、バイトのようなオブジェクトであればどれでもかまいません。

bytes.find(sub[, start[, end]])
bytearray.find(sub[, start[, end]])

sub がスライスs[start:end]に含まれるように、サブシーケンス sub が見つかったデータの最小インデックスを返します。 オプションの引数 start および end は、スライス表記のように解釈されます。 sub が見つからない場合は、-1を返します。

検索するサブシーケンスは、バイトのようなオブジェクトまたは0〜255の範囲の整数です。

ノート

find（）メソッドは、 sub の位置を知る必要がある場合にのみ使用してください。 sub が部分文字列であるかどうかを確認するには、 in 演算子を使用します。

>>> b'Py' in b'Python'
True

バージョン3.3で変更：サブシーケンスとして0〜255の範囲の整数も受け入れます。

bytes.index(sub[, start[, end]])
bytearray.index(sub[, start[, end]])

find（）と同様ですが、サブシーケンスが見つからない場合は ValueError を発生させます。

検索するサブシーケンスは、バイトのようなオブジェクトまたは0〜255の範囲の整数です。

バージョン3.3で変更：サブシーケンスとして0〜255の範囲の整数も受け入れます。

bytes.join(iterable)

bytearray.join(iterable)

iterable のバイナリデータシーケンスを連結したbytesまたはbytearrayオブジェクトを返します。 TypeError は、 str オブジェクトを含め、バイトのようなオブジェクトではない値が iterable にある場合に発生します。 要素間の区切り文字は、このメソッドを提供するバイトまたはバイト配列オブジェクトの内容です。

static bytes.maketrans(from, to)
static bytearray.maketrans(from, to)

この静的メソッドは、 bytes.translate（）で使用可能な変換テーブルを返します。このテーブルは、 from の各文字をからの同じ位置の文字にマップします。 from および to は、両方ともバイトのようなオブジェクトであり、同じ長さである必要があります。

バージョン3.1の新機能。

bytes.partition(sep)
bytearray.partition(sep)

sep の最初の出現時にシーケンスを分割し、セパレーターの前の部分、セパレーター自体またはそのバイト配列コピー、およびセパレーターの後の部分を含む3タプルを返します。 セパレータが見つからない場合は、元のシーケンスのコピーを含む3タプルを返し、その後に2つの空のバイトまたはbytearrayオブジェクトが続きます。

検索する区切り文字は、バイトのようなオブジェクトです。

bytes.replace(old, new[, count])
bytearray.replace(old, new[, count])

サブシーケンス old のすべてのオカレンスが new に置き換えられたシーケンスのコピーを返します。 オプションの引数 count を指定すると、最初の count オカレンスのみが置き換えられます。

検索するサブシーケンスとその置換は、バイトのようなオブジェクトであればどれでもかまいません。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.rfind(sub[, start[, end]])
bytearray.rfind(sub[, start[, end]])

sub がs[start:end]内に含まれるように、サブシーケンス sub が見つかったシーケンスの最高のインデックスを返します。 オプションの引数 start および end は、スライス表記のように解釈されます。 失敗した場合は-1を返します。

検索するサブシーケンスは、バイトのようなオブジェクトまたは0〜255の範囲の整数です。

バージョン3.3で変更：サブシーケンスとして0〜255の範囲の整数も受け入れます。

bytes.rindex(sub[, start[, end]])
bytearray.rindex(sub[, start[, end]])

rfind（）と同様ですが、サブシーケンス sub が見つからない場合に ValueError を発生させます。

検索するサブシーケンスは、バイトのようなオブジェクトまたは0〜255の範囲の整数です。

バージョン3.3で変更：サブシーケンスとして0〜255の範囲の整数も受け入れます。

bytes.rpartition(sep)
bytearray.rpartition(sep)

sep の最後のオカレンスでシーケンスを分割し、セパレーターの前の部分、セパレーター自体またはそのバイト配列コピー、およびセパレーターの後の部分を含む3タプルを返します。 セパレータが見つからない場合は、2つの空のバイトまたはbytearrayオブジェクトを含む3タプルを返し、その後に元のシーケンスのコピーを返します。

検索する区切り文字は、バイトのようなオブジェクトです。

bytes.startswith(prefix[, start[, end]])
bytearray.startswith(prefix[, start[, end]])

バイナリデータが指定されたプレフィックスで始まる場合はTrueを返し、そうでない場合はFalseを返します。 prefix は、検索するプレフィックスのタプルにすることもできます。 オプションの start を使用して、その位置からテストを開始します。 オプションの end を使用して、その位置での比較を停止します。

検索するプレフィックスは、バイトのようなオブジェクトであればどれでもかまいません。

bytes.translate(table, /, delete=b)
bytearray.translate(table, /, delete=b)

オプションの引数 delete で発生するすべてのバイトが削除され、残りのバイトが指定された変換テーブルを介してマップされているバイトまたはbytearrayオブジェクトのコピーを返します。これは、長さ256のバイトオブジェクトである必要があります。

bytes.maketrans（）メソッドを使用して、変換テーブルを作成できます。

文字のみを削除する翻訳の場合は、 table 引数をNoneに設定します。

>>> b'read this short text'.translate(None, b'aeiou')
b'rd ths shrt txt'

バージョン3.6で変更： delete がキーワード引数としてサポートされるようになりました。

バイトおよびbytearrayオブジェクトに対する次のメソッドは、ASCII互換のバイナリ形式の使用を想定したデフォルトの動作をしますが、適切な引数を渡すことにより、任意のバイナリデータで引き続き使用できます。 このセクションのすべてのbytearrayメソッドは、ではなく動作し、代わりに新しいオブジェクトを生成することに注意してください。

bytes.center(width[, fillbyte])
bytearray.center(width[, fillbyte])

長さ幅のシーケンスの中央にあるオブジェクトのコピーを返します。 パディングは、指定された fillbyte （デフォルトはASCIIスペース）を使用して行われます。 bytes オブジェクトの場合、 width がlen(s)以下の場合、元のシーケンスが返されます。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.ljust(width[, fillbyte])
bytearray.ljust(width[, fillbyte])

長さ幅のシーケンスで左寄せされたオブジェクトのコピーを返します。 パディングは、指定された fillbyte （デフォルトはASCIIスペース）を使用して行われます。 bytes オブジェクトの場合、 width がlen(s)以下の場合、元のシーケンスが返されます。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.lstrip([chars])
bytearray.lstrip([chars])

指定された先行バイトが削除されたシーケンスのコピーを返します。 chars 引数は、削除するバイト値のセットを指定するバイナリシーケンスです。名前は、このメソッドが通常ASCII文字で使用されるという事実を示しています。 省略またはNoneの場合、 chars 引数はデフォルトでASCII空白を削除します。 chars 引数はプレフィックスではありません。 むしろ、その値のすべての組み合わせが削除されます。

>>> b'   spacious   '.lstrip()
b'spacious   '
>>> b'www.example.com'.lstrip(b'cmowz.')
b'example.com'

削除するバイト値のバイナリシーケンスは、バイトのようなオブジェクトであればどれでもかまいません。 すべての文字セットではなく単一のプレフィックス文字列を削除するメソッドについては、 removeprefix（）を参照してください。 例えば：

>>> b'Arthur: three!'.lstrip(b'Arthur: ')
b'ee!'
>>> b'Arthur: three!'.removeprefix(b'Arthur: ')
b'three!'

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.rjust(width[, fillbyte])
bytearray.rjust(width[, fillbyte])

長さ幅のシーケンスで右寄せされたオブジェクトのコピーを返します。 パディングは、指定された fillbyte （デフォルトはASCIIスペース）を使用して行われます。 bytes オブジェクトの場合、 width がlen(s)以下の場合、元のシーケンスが返されます。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.rsplit(sep=None, maxsplit=- 1)

bytearray.rsplit(sep=None, maxsplit=- 1)

sep を区切り文字列として使用して、バイナリシーケンスを同じタイプのサブシーケンスに分割します。 maxsplit が指定されている場合、最大で maxsplit 分割が実行され、右端分割が実行されます。 sep が指定されていないかNoneの場合、ASCII空白のみで構成されるサブシーケンスは区切り文字になります。 右から分割することを除いて、 rsplit（）は split（）のように動作します。これについては以下で詳しく説明します。

bytes.rstrip([chars])
bytearray.rstrip([chars])

指定された末尾のバイトが削除されたシーケンスのコピーを返します。 chars 引数は、削除するバイト値のセットを指定するバイナリシーケンスです。名前は、このメソッドが通常ASCII文字で使用されるという事実を示しています。 省略またはNoneの場合、 chars 引数はデフォルトでASCII空白を削除します。 chars 引数はサフィックスではありません。 むしろ、その値のすべての組み合わせが削除されます。

>>> b'   spacious   '.rstrip()
b'   spacious'
>>> b'mississippi'.rstrip(b'ipz')
b'mississ'

削除するバイト値のバイナリシーケンスは、バイトのようなオブジェクトであればどれでもかまいません。 文字セットのすべてではなく単一のサフィックス文字列を削除するメソッドについては、 removesuffix（）を参照してください。 例えば：

>>> b'Monty Python'.rstrip(b' Python')
b'M'
>>> b'Monty Python'.removesuffix(b' Python')
b'Monty'

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.split(sep=None, maxsplit=- 1)
bytearray.split(sep=None, maxsplit=- 1)

sep を区切り文字列として使用して、バイナリシーケンスを同じタイプのサブシーケンスに分割します。 maxsplit が指定され、負でない場合、最大で maxsplit 分割が実行されます（したがって、リストには最大でmaxsplit+1要素が含まれます）。 maxsplit が指定されていないか、-1の場合、分割数に制限はありません（可能なすべての分割が行われます）。

sep が指定されている場合、連続する区切り文字はグループ化されず、空のサブシーケンスを区切ると見なされます（たとえば、b'1,,2'.split(b',')は[b'1', b, b'2']を返します）。 sep 引数は、マルチバイトシーケンスで構成されている場合があります（たとえば、b'1<>2<>3'.split(b'<>')は[b'1', b'2', b'3']を返します）。 空のシーケンスを指定された区切り文字で分割すると、分割されるオブジェクトのタイプに応じて、[b]または[bytearray(b)]が返されます。 sep 引数は、バイトのようなオブジェクトであればどれでもかまいません。

例えば：

>>> b'1,2,3'.split(b',')
[b'1', b'2', b'3']
>>> b'1,2,3'.split(b',', maxsplit=1)
[b'1', b'2,3']
>>> b'1,2,,3,'.split(b',')
[b'1', b'2', b'', b'3', b'']

sep が指定されていないか、Noneの場合、異なる分割アルゴリズムが適用されます。連続するASCII空白の実行は単一の区切り文字と見なされ、結果には最初に空の文字列が含まれません。または、シーケンスに先頭または末尾の空白がある場合は終了します。 したがって、空のシーケンスまたは指定された区切り文字なしでASCII空白のみで構成されるシーケンスを分割すると、[]が返されます。

例えば：

>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b'   1   2   3   '.split()
[b'1', b'2', b'3']

bytes.strip([chars])
bytearray.strip([chars])

指定された先頭バイトと末尾バイトが削除されたシーケンスのコピーを返します。 chars 引数は、削除するバイト値のセットを指定するバイナリシーケンスです。名前は、このメソッドが通常ASCII文字で使用されるという事実を示しています。 省略またはNoneの場合、 chars 引数はデフォルトでASCII空白を削除します。 chars 引数は接頭辞または接尾辞ではありません。 むしろ、その値のすべての組み合わせが削除されます。

>>> b'   spacious   '.strip()
b'spacious'
>>> b'www.example.com'.strip(b'cmowz.')
b'example'

削除するバイト値のバイナリシーケンスは、バイトのようなオブジェクトであればどれでもかまいません。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

バイトおよびバイト配列オブジェクトに対する以下のメソッドは、ASCII互換のバイナリ形式の使用を前提としているため、任意のバイナリデータに適用しないでください。 このセクションのすべてのbytearrayメソッドは、ではなく動作し、代わりに新しいオブジェクトを生成することに注意してください。

bytes.capitalize()
bytearray.capitalize()

各バイトがASCII文字として解釈され、最初のバイトが大文字になり、残りが小文字になっているシーケンスのコピーを返します。 非ASCIIバイト値は変更されずに渡されます。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.expandtabs(tabsize=8)
bytearray.expandtabs(tabsize=8)

現在の列と指定されたタブサイズに応じて、すべてのASCIIタブ文字が1つ以上のASCIIスペースに置き換えられたシーケンスのコピーを返します。 タブ位置は tabsize バイトごとに発生します（デフォルトは8で、列0、8、16などにタブ位置があります）。 シーケンスを拡張するには、現在の列をゼロに設定し、シーケンスをバイトごとに調べます。 バイトがASCIIタブ文字（b'\t'）の場合、現在の列が次のタブ位置と等しくなるまで、1つ以上のスペース文字が結果に挿入されます。 （タブ文字自体はコピーされません。）現在のバイトがASCII改行（b'\n'）またはキャリッジリターン（b'\r'）の場合、それはコピーされ、現在の列はゼロにリセットされます。 他のバイト値は変更されずにコピーされ、印刷時のバイト値の表現方法に関係なく、現在の列が1つインクリメントされます。

>>> b'01\t012\t0123\t01234'.expandtabs()
b'01      012     0123    01234'
>>> b'01\t012\t0123\t01234'.expandtabs(4)
b'01  012 0123    01234'

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.isalnum()
bytearray.isalnum()

シーケンス内のすべてのバイトがASCIIアルファベット文字またはASCII10進数であり、シーケンスが空でない場合はTrueを返し、それ以外の場合はFalseを返します。 アルファベットのASCII文字は、シーケンスb'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'のバイト値です。 ASCII 10進数は、シーケンスb'0123456789'のバイト値です。

例えば：

>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False

bytes.isalpha()
bytearray.isalpha()

シーケンス内のすべてのバイトがアルファベットのASCII文字であり、シーケンスが空でない場合はTrueを返し、それ以外の場合はFalseを返します。 アルファベットのASCII文字は、シーケンスb'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'のバイト値です。

例えば：

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False

bytes.isascii()
bytearray.isascii()

シーケンスが空の場合、またはシーケンス内のすべてのバイトがASCIIの場合は、Trueを返し、それ以外の場合はFalseを返します。 ASCIIバイトは0-0x7Fの範囲です。

バージョン3.7の新機能。

bytes.isdigit()
bytearray.isdigit()

シーケンス内のすべてのバイトがASCII10進数で、シーケンスが空でない場合はTrueを返し、それ以外の場合はFalseを返します。 ASCII 10進数は、シーケンスb'0123456789'のバイト値です。

例えば：

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False

bytes.islower()
bytearray.islower()

シーケンスに小文字のASCII文字が少なくとも1つあり、大文字のASCII文字がない場合はTrueを返し、それ以外の場合はFalseを返します。

例えば：

>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False

小文字のASCII文字は、シーケンスb'abcdefghijklmnopqrstuvwxyz'のバイト値です。 大文字のASCII文字は、シーケンスb'ABCDEFGHIJKLMNOPQRSTUVWXYZ'のバイト値です。

bytes.isspace()

bytearray.isspace()

シーケンス内のすべてのバイトがASCII空白であり、シーケンスが空でない場合はTrueを返し、それ以外の場合はFalseを返します。 ASCII空白文字は、シーケンスb' \t\n\r\x0b\f'（スペース、タブ、改行、キャリッジリターン、垂直タブ、フォームフィード）のバイト値です。

bytes.istitle()
bytearray.istitle()

シーケンスがASCIIタイトルケースで、シーケンスが空でない場合はTrueを返し、それ以外の場合はFalseを返します。 「titlecase」の定義の詳細については、 bytes.title（）を参照してください。

例えば：

>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False

bytes.isupper()
bytearray.isupper()

シーケンスに大文字のアルファベットASCII文字が少なくとも1つあり、小文字のASCII文字がない場合はTrueを返し、それ以外の場合はFalseを返します。

例えば：

>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False

小文字のASCII文字は、シーケンスb'abcdefghijklmnopqrstuvwxyz'のバイト値です。 大文字のASCII文字は、シーケンスb'ABCDEFGHIJKLMNOPQRSTUVWXYZ'のバイト値です。

bytes.lower()
bytearray.lower()

すべての大文字のASCII文字が対応する小文字の対応する文字に変換されたシーケンスのコピーを返します。

例えば：

>>> b'Hello World'.lower()
b'hello world'

小文字のASCII文字は、シーケンスb'abcdefghijklmnopqrstuvwxyz'のバイト値です。 大文字のASCII文字は、シーケンスb'ABCDEFGHIJKLMNOPQRSTUVWXYZ'のバイト値です。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.splitlines(keepends=False)
bytearray.splitlines(keepends=False)

ASCII行境界で分割して、バイナリシーケンスの行のリストを返します。 この方法では、ユニバーサルニューラインアプローチを使用してラインを分割します。 keepends が指定され、trueでない限り、改行は結果のリストに含まれません。

例えば：

>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
[b'ab c', b'', b'de fg', b'kl']
>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

区切り文字列 sep が指定された場合の split（）とは異なり、このメソッドは空の文字列に対して空のリストを返し、終端の改行によって余分な行が生成されることはありません。

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])

bytes.swapcase()
bytearray.swapcase()

すべての小文字のASCII文字が対応する大文字に変換されたシーケンスのコピーを返します。その逆も同様です。

例えば：

>>> b'Hello World'.swapcase()
b'hELLO wORLD'

小文字のASCII文字は、シーケンスb'abcdefghijklmnopqrstuvwxyz'のバイト値です。 大文字のASCII文字は、シーケンスb'ABCDEFGHIJKLMNOPQRSTUVWXYZ'のバイト値です。

str.swapcase（）とは異なり、バイナリバージョンではbin.swapcase().swapcase() == binが常に当てはまります。 大文字と小文字の変換はASCIIで対称的ですが、任意のUnicodeコードポイントには一般的に当てはまりません。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.title()
bytearray.title()

単語が大文字のASCII文字で始まり、残りの文字が小文字である、タイトル付きバージョンのバイナリシーケンスを返します。 大文字と小文字を区別しないバイト値は変更されません。

例えば：

>>> b'Hello world'.title()
b'Hello World'

小文字のASCII文字は、シーケンスb'abcdefghijklmnopqrstuvwxyz'のバイト値です。 大文字のASCII文字は、シーケンスb'ABCDEFGHIJKLMNOPQRSTUVWXYZ'のバイト値です。 他のすべてのバイト値は大文字と小文字が区別されません。

アルゴリズムは、連続する文字のグループとして単語の単純な言語に依存しない定義を使用します。 この定義は多くの文脈で機能しますが、縮約と所有格のアポストロフィが単語の境界を形成することを意味します。これは望ましい結果ではない可能性があります。

>>> b"they're bill's friends from the UK".title()
b"They'Re Bill'S Friends From The Uk"

アポストロフィの回避策は、正規表現を使用して作成できます。

>>> import re
>>> def titlecase(s):
...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0:1].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase(b"they're bill's friends.")
b"They're Bill's Friends."

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.upper()
bytearray.upper()

すべての小文字のASCII文字を対応する大文字に変換したシーケンスのコピーを返します。

例えば：

>>> b'Hello World'.upper()
b'HELLO WORLD'

小文字のASCII文字は、シーケンスb'abcdefghijklmnopqrstuvwxyz'のバイト値です。 大文字のASCII文字は、シーケンスb'ABCDEFGHIJKLMNOPQRSTUVWXYZ'のバイト値です。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

bytes.zfill(width)
bytearray.zfill(width)

ASCII b'0'桁で埋められたままのシーケンスのコピーを返し、長さ幅のシーケンスを作成します。 先頭の記号プレフィックス（b'+' / b'-'）は、記号文字の前ではなくの後にパディングを挿入することによって処理されます。 bytes オブジェクトの場合、 width がlen(seq)以下の場合、元のシーケンスが返されます。

例えば：

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

printfスタイルのバイトフォーマット

ノート

ここで説明するフォーマット操作は、多くの一般的なエラー（タプルと辞書を正しく表示できないなど）につながるさまざまな癖を示します。 印刷される値がタプルまたはディクショナリである可能性がある場合は、タプルでラップします。

バイトオブジェクト（bytes / bytearray）には、%演算子（モジュロ）という1つの固有の組み込み演算があります。 これは、バイトフォーマットまたは補間演算子とも呼ばれます。 format % values（ format はバイトオブジェクト）を指定すると、 format の%変換仕様は、値の0個以上の要素に置き換えられます。 。 効果は、C言語でsprintf()を使用する場合と同様です。

format が単一の引数を必要とする場合、 values は単一の非タプルオブジェクトである可能性があります。 5 それ以外の場合、 values は、format bytesオブジェクトまたは単一のマッピングオブジェクト（辞書など）で指定された正確な数のアイテムを持つタプルである必要があります。

変換指定子には2つ以上の文字が含まれ、次のコンポーネントがあります。これらはこの順序で発生する必要があります。

1. 指定子の開始を示す'%'文字。
2. 括弧で囲まれた文字シーケンス（(somename)など）で構成されるマッピングキー（オプション）。
3. 一部の変換タイプの結果に影響を与える変換フラグ（オプション）。
4. 最小フィールド幅（オプション）。 '*'（アスタリスク）として指定されている場合、実際の幅は values のタプルの次の要素から読み取られ、変換するオブジェクトは最小フィールド幅とオプションの精度の後になります。
5. 精度（オプション）。'.'（ドット）の後に精度が続きます。 '*'（アスタリスク）として指定されている場合、実際の精度は values のタプルの次の要素から読み取られ、変換する値は精度の後になります。
6. 長さ修飾子（オプション）。
7. 変換タイプ。

右の引数が辞書（または他のマッピングタイプ）の場合、bytesオブジェクト must の形式には、'%'文字の直後に挿入される辞書に括弧で囲まれたマッピングキーが含まれている必要があります。 マッピングキーは、マッピングからフォーマットする値を選択します。 例えば：

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

この場合、*指定子をフォーマットで使用することはできません（順次パラメーターリストが必要なため）。

変換フラグの文字は次のとおりです。

国旗	意味
'#'	値の変換では、「代替形式」（以下で定義）が使用されます。
'0'	変換は、数値に対してゼロが埋め込まれます。
'-'	変換された値は調整されたままになります（両方が指定されている場合、'0'変換をオーバーライドします）。
' '	（スペース）符号付き変換によって生成される正の数（または空の文字列）の前に空白を残す必要があります。
'+'	符号文字（'+'または'-'）が変換の前に配置されます（「スペース」フラグをオーバーライドします）。

長さ修飾子（h、l、またはL）が存在する場合がありますが、Pythonには必要ないため、無視されます。 %ldは%dと同じです。

変換タイプは次のとおりです。

会話	意味	ノート
'd'	符号付き整数10進数。
'i'	符号付き整数10進数。
'o'	符号付き8進値。	(1)
'u'	廃止されたタイプ– 'd'と同じです。	(8)
'x'	符号付き16進数（小文字）。	(2)
'X'	符号付き16進数（大文字）。	(2)
'e'	浮動小数点指数形式（小文字）。	(3)
'E'	浮動小数点指数形式（大文字）。	(3)
'f'	浮動小数点10進形式。	(3)
'F'	浮動小数点10進形式。	(3)
'g'	浮動小数点形式。 指数が-4未満または精度以上の場合は小文字の指数形式を使用し、それ以外の場合は10進形式を使用します。	(4)
'G'	浮動小数点形式。 指数が-4未満または精度以上の場合は大文字の指数形式を使用し、それ以外の場合は10進形式を使用します。	(4)
'c'	シングルバイト（整数またはシングルバイトオブジェクトを受け入れます）。
'b'	バイト（バッファプロトコルに従う、または__bytes__()を持つオブジェクト）。	(5)
's'	's'は'b'のエイリアスであり、Python2 / 3コードベースにのみ使用する必要があります。	(6)
'a'	バイト（repr(obj).encode('ascii','backslashreplace)を使用してPythonオブジェクトを変換します）。	(5)
'r'	'r'は'a'のエイリアスであり、Python2 / 3コードベースにのみ使用する必要があります。	(7)
'%'	引数は変換されず、結果は'%'文字になります。

ノート：

1. 別の形式では、先頭の8進数指定子（'0o'）が最初の桁の前に挿入されます。

2. 別の形式では、先頭の'0x'または'0X'（'x'または'X'形式のどちらが使用されたかによって異なります）が最初の桁の前に挿入されます。

3. 別の形式では、数字が続かない場合でも、結果には常に小数点が含まれます。

   精度は小数点以下の桁数を決定し、デフォルトは6です。

4. 別の形式では、結果に常に小数点が含まれ、後続のゼロはそうでない場合のように削除されません。

   精度は、小数点の前後の有効桁数を決定し、デフォルトは6です。

5. 精度がNの場合、出力はN文字に切り捨てられます。

6. b'%s'は非推奨ですが、3.xシリーズでは削除されません。

7. b'%r'は非推奨ですが、3.xシリーズでは削除されません。

8. PEP 237 を参照してください。

ノート

このメソッドのbytearrayバージョンは、ではなく動作します。変更が加えられていない場合でも、常に新しいオブジェクトが生成されます。

も参照してください

PEP 461 -バイトとバイト配列に% f ormattingを追加

バージョン3.5の新機能。

メモリビュー

memoryview オブジェクトを使用すると、Pythonコードは、バッファプロトコルをサポートするオブジェクトの内部データにコピーせずにアクセスできます。

class memoryview(object)

オブジェクトを参照する memoryview を作成します。 object はバッファプロトコルをサポートする必要があります。 バッファプロトコルをサポートする組み込みオブジェクトには、 bytes および bytearray が含まれます。

memoryview には、 element の概念があります。これは、元のオブジェクトによって処理されるアトミックメモリユニットです。 bytes や bytearray などの多くの単純な型では、要素は1バイトですが、 array.array などの他の型ではより大きな要素が含まれる場合があります。

len(view)は、 tolist の長さと同じです。 view.ndim = 0の場合、長さは1です。 view.ndim = 1の場合、長さはビュー内の要素の数と同じです。 高次元の場合、長さはビューのネストされたリスト表現の長さと同じです。 itemsize 属性は、単一の要素のバイト数を示します。

memoryview は、データを公開するためのスライスとインデックス作成をサポートしています。 1次元のスライスは、サブビューになります。

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

format が struct モジュールのネイティブフォーマット指定子の1つである場合、整数または整数のタプルによるインデックス付けもサポートされ、単一の要素を返します。正しいタイプ。 1次元のメモリビューは、整数または1整数のタプルでインデックスを付けることができます。 多次元メモリビューは、正確に ndim 整数のタプルでインデックスを付けることができます。ここで、 ndim は次元の数です。 ゼロ次元のメモリビューは、空のタプルでインデックスを付けることができます。

非バイト形式の例を次に示します。

>>> import array
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = memoryview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]

基になるオブジェクトが書き込み可能である場合、memoryviewは1次元のスライス割り当てをサポートします。 サイズ変更は許可されていません：

>>> data = bytearray(b'abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = ord(b'z')
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = b'123'
>>> data
bytearray(b'z123fg')
>>> v[2:3] = b'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview assignment: lvalue and rvalue have different structures
>>> v[2:6] = b'spam'
>>> data
bytearray(b'z1spam')

フォーマットが「B」、「b」、または「c」のハッシュ可能な（読み取り専用）タイプの1次元メモリビューもハッシュ可能です。 ハッシュはhash(m) == hash(m.tobytes())として定義されています。

>>> v = memoryview(b'abcefg')
>>> hash(v) == hash(b'abcefg')
True
>>> hash(v[2:4]) == hash(b'ce')
True
>>> hash(v[::-2]) == hash(b'abcefg'[::-2])
True

バージョン3.3で変更： 1次元のメモリビューをスライスできるようになりました。 フォーマットが「B」、「b」、または「c」の1次元メモリビューがハッシュ可能になりました。

バージョン3.4で変更： memoryviewが collections.abc.Sequence に自動的に登録されるようになりました

バージョン3.5で変更： memoryviewsは整数のタプルでインデックス付けできるようになりました。

memoryview にはいくつかの方法があります。

__eq__(exporter)

形状が同等であり、オペランドのそれぞれのフォーマットコードが struct を使用して解釈される場合、対応するすべての値が等しい場合、memoryviewと PEP 3118 エクスポーターは等しくなります。構文。

tolist（）で現在サポートされている struct 形式の文字列のサブセットの場合、v.tolist() == w.tolist()の場合、vとwは等しくなります。

>>> import array
>>> a = array.array('I', [1, 2, 3, 4, 5])
>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> c = array.array('b', [5, 3, 1])
>>> x = memoryview(a)
>>> y = memoryview(b)
>>> x == a == y == b
True
>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
True
>>> z = y[::-2]
>>> z == c
True
>>> z.tolist() == c.tolist()
True

いずれかのフォーマット文字列が struct モジュールでサポートされていない場合、オブジェクトは常に等しくないと比較されます（フォーマット文字列とバッファの内容が同じであっても）。

>>> from ctypes import BigEndianStructure, c_long
>>> class BEPoint(BigEndianStructure):
...     _fields_ = [("x", c_long), ("y", c_long)]
...
>>> point = BEPoint(100, 200)
>>> a = memoryview(point)
>>> b = memoryview(point)
>>> a == point
False
>>> a == b
False

浮動小数点数と同様に、v is wはではなくはmemoryviewオブジェクトのv == wを意味しないことに注意してください。

バージョン3.3で変更：以前のバージョンでは、アイテムの形式と論理配列構造を無視してrawメモリを比較していました。

tobytes(order=None)

バッファ内のデータをバイト文字列として返します。 これは、memoryviewで bytes コンストラクターを呼び出すのと同じです。

>>> m = memoryview(b"abc")
>>> m.tobytes()
b'abc'
>>> bytes(m)
b'abc'

連続していない配列の場合、結果はすべての要素がバイトに変換されたフラット化されたリスト表現に等しくなります。 tobytes（）は、 struct モジュール構文にないものも含め、すべてのフォーマット文字列をサポートします。

バージョン3.8の新機能： order は{'C'、 'F'、 'A'}にすることができます。 order が 'C'または 'F'の場合、元の配列のデータはCまたはFortranの順序に変換されます。 連続したビューの場合、「A」は物理メモリの正確なコピーを返します。 特に、メモリ内のFortranの順序は保持されます。 連続していないビューの場合、データは最初にCに変換されます。 order = None は order = 'C' と同じです。

hex([sep[, bytes_per_sep]])

バッファ内のバイトごとに2桁の16進数を含む文字列オブジェクトを返します。

>>> m = memoryview(b"abc")
>>> m.hex()
'616263'

バージョン3.5の新機能。

バージョン3.8で変更： bytes.hex（）と同様に、 memoryview.hex（）はオプションの sep およびをサポートするようになりましたbytes_per_sep パラメーターを使用して、16進出力のバイト間にセパレーターを挿入します。

tolist()

バッファ内のデータを要素のリストとして返します。

>>> memoryview(b'abc').tolist()
[97, 98, 99]
>>> import array
>>> a = array.array('d', [1.1, 2.2, 3.3])
>>> m = memoryview(a)
>>> m.tolist()
[1.1, 2.2, 3.3]

バージョン3.3での変更： tolist（）は、 struct モジュール構文のすべての単一文字ネイティブ形式と多次元表現をサポートするようになりました。

toreadonly()

memoryviewオブジェクトの読み取り専用バージョンを返します。 元のmemoryviewオブジェクトは変更されていません。

>>> m = memoryview(bytearray(b'abc'))
>>> mm = m.toreadonly()
>>> mm.tolist()
[89, 98, 99]
>>> mm[0] = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot modify read-only memory
>>> m[0] = 43
>>> mm.tolist()
[43, 98, 99]

バージョン3.8の新機能。

release()

memoryviewオブジェクトによって公開されている基になるバッファを解放します。 多くのオブジェクトは、ビューが保持されているときに特別なアクションを実行します（たとえば、 bytearray は一時的にサイズ変更を禁止します）。 したがって、release（）を呼び出すと、これらの制限をできるだけ早く削除（およびぶら下がっているリソースを解放）するのに便利です。

このメソッドが呼び出された後、ビューでそれ以上の操作を行うと、 ValueError が発生します（複数回呼び出すことができる release（）自体を除く）。

>>> m = memoryview(b'abc')
>>> m.release()
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

withステートメントを使用して、コンテキスト管理プロトコルを同様の効果に使用できます。

>>> with memoryview(b'abc') as m:
...     m[0]
...
97
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

バージョン3.2の新機能。

cast(format[, shape])

メモリビューを新しい形式または形状にキャストします。 shape のデフォルトは[byte_length//new_itemsize]です。これは、結果ビューが1次元になることを意味します。 戻り値は新しいmemoryviewですが、バッファ自体はコピーされません。 サポートされているキャストは、1D-> C- contiguous およびC-contiguous-> 1Dです。

宛先フォーマットは、 struct 構文の単一要素のネイティブフォーマットに制限されています。 形式の1つは、バイト形式（ 'B'、 'b'、または 'c'）である必要があります。 結果のバイト長は、元の長さと同じである必要があります。

1D / longを1D / unsignedバイトにキャストします：

>>> import array
>>> a = array.array('l', [1,2,3])
>>> x = memoryview(a)
>>> x.format
'l'
>>> x.itemsize
8
>>> len(x)
3
>>> x.nbytes
24
>>> y = x.cast('B')
>>> y.format
'B'
>>> y.itemsize
1
>>> len(y)
24
>>> y.nbytes
24

1D /符号なしバイトを1D / charにキャストします。

>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview: invalid value for format "B"
>>> y = x.cast('c')
>>> y[0] = b'a'
>>> b
bytearray(b'ayz')

1D /バイトを3D / intsから1D /符号付き文字にキャストします。

>>> import struct
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = memoryview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'i'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbytes
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbytes
48

1D / unsignedlongを2D / unsigned longにキャストします：

>>> buf = struct.pack("L"*6, *list(range(6)))
>>> x = memoryview(buf)
>>> y = x.cast('L', shape=[2,3])
>>> len(y)
2
>>> y.nbytes
48
>>> y.tolist()
[[0, 1, 2], [3, 4, 5]]

バージョン3.3の新機能。

バージョン3.5で変更：バイトビューにキャストするときにソース形式が制限されなくなりました。

使用可能な読み取り専用属性もいくつかあります。

obj

memoryviewの基になるオブジェクト：

>>> b  = bytearray(b'xyz')
>>> m = memoryview(b)
>>> m.obj is b
True

バージョン3.3の新機能。

nbytes

nbytes == product(shape) * itemsize == len(m.tobytes())。 これは、配列が連続した表現で使用するバイト単位のスペースの量です。 len(m)と必ずしも同じではありません。

>>> import array
>>> a = array.array('i', [1,2,3,4,5])
>>> m = memoryview(a)
>>> len(m)
5
>>> m.nbytes
20
>>> y = m[::2]
>>> len(y)
3
>>> y.nbytes
12
>>> len(y.tobytes())
12

多次元配列：

>>> import struct
>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
>>> x = memoryview(buf)
>>> y = x.cast('d', shape=[3,4])
>>> y.tolist()
[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
>>> len(y)
3
>>> y.nbytes
96

バージョン3.3の新機能。

readonly

メモリが読み取り専用かどうかを示すブール値。

format

ビュー内の各要素の形式（ struct モジュールスタイル）を含む文字列。 メモリビューは、任意の形式の文字列を使用してエクスポーターから作成できますが、いくつかのメソッド（例： tolist（））は、ネイティブの単一要素形式に制限されています。

バージョン3.3で変更：形式'B'は、構造体モジュールの構文に従って処理されるようになりました。 これは、memoryview(b'abc')[0] == b'abc'[0] == 97を意味します。

itemsize

memoryviewの各要素のバイト単位のサイズ：

>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True

ndim

メモリが表す多次元配列の次元数を示す整数。

shape

ndim の長さの整数のタプルで、メモリの形状をN次元配列として提供します。

バージョン3.3で変更： ndim = 0の場合、Noneの代わりに空のタプル。

strides

ndim の長さの整数のタプルで、配列の各次元の各要素にアクセスするためのサイズをバイト単位で示します。

バージョン3.3で変更： ndim = 0の場合、Noneの代わりに空のタプル。

suboffsets

PILスタイルの配列に内部的に使用されます。 値は情報提供のみです。

c_contiguous

メモリがC- 連続であるかどうかを示すブール値。

バージョン3.3の新機能。

f_contiguous

メモリがFortran 連続であるかどうかを示すブール値。

バージョン3.3の新機能。

contiguous

メモリが連続であるかどうかを示すブール値。

バージョン3.3の新機能。

セットタイプ— セット、フローズンセット

set オブジェクトは、個別の hashable オブジェクトの順序付けられていないコレクションです。 一般的な用途には、メンバーシップテスト、シーケンスからの重複の削除、交差、和集合、差、対称差などの数学演算の計算が含まれます。 （他のコンテナーについては、組み込みの dict 、 list 、 tuple クラス、および collections モジュールを参照してください。）

他のコレクションと同様に、セットはx in set、len(set)、およびfor x in setをサポートします。 順序付けられていないコレクションであるため、セットは要素の位置や挿入の順序を記録しません。 したがって、セットは、インデックス付け、スライス、またはその他のシーケンスのような動作をサポートしていません。

現在、 set と frozenset の2つの組み込みセットタイプがあります。 set タイプは変更可能です— add()やremove()などの方法を使用して内容を変更できます。 変更可能であるため、ハッシュ値がなく、辞書キーまたは別のセットの要素として使用することはできません。 frozenset タイプは不変であり、 hashable —作成後にその内容を変更することはできません。 したがって、辞書キーとして、または別のセットの要素として使用できます。

空でないセット（フリーズセットではない）は、 set コンストラクターに加えて、中括弧内に要素のコンマ区切りリストを配置することで作成できます。例：{'jack', 'sjoerd'}。

両方のクラスのコンストラクターは同じように機能します。

class set([iterable])
class frozenset([iterable])

要素が iterable から取得された新しいセットまたはfrozensetオブジェクトを返します。 セットの要素はハッシュ可能である必要があります。 セットのセットを表すには、内部セットは frozenset オブジェクトである必要があります。 iterable が指定されていない場合、新しい空のセットが返されます。

セットは、いくつかの方法で作成できます。

• 中括弧内の要素のコンマ区切りリストを使用します：{'jack', 'sjoerd'}

• 集合の内包的包摂を使用する：{c for c in 'abracadabra' if c not in 'abc'}

• 型コンストラクターを使用します：set()、set('foobar')、set(['a', 'b', 'foo'])

set および frozenset のインスタンスは、次の操作を提供します。

len(s)

セット s の要素数を返します（ s のカーディナリティ）。

x in s

x の s のメンバーシップをテストします。

x not in s

s の非メンバーシップについて x をテストします。

isdisjoint(other)

セットに other と共通の要素がない場合は、Trueを返します。 セットは、それらの共通部分が空のセットである場合にのみ互いに素です。

issubset(other)
set <= other

セット内のすべての要素がその他にあるかどうかをテストします。

set < other

セットが other の適切なサブセット、つまりset <= other and set != otherであるかどうかをテストします。

issuperset(other)
set >= other

other のすべての要素がセットに含まれているかどうかをテストします。

set > other

セットが other の適切なスーパーセット、つまりset >= other and set != otherであるかどうかをテストします。

union(*others)
set | other | ...

セットおよび他のすべての要素を含む新しいセットを返します。

intersection(*others)
set & other & ...

セットと他のすべてに共通の要素を持つ新しいセットを返します。

difference(*others)
set - other - ...

セット内に他の要素にはない要素を含む新しいセットを返します。

symmetric_difference(other)
set ^ other

セットまたはその他のいずれか（両方ではない）の要素を含む新しいセットを返します。

copy()

セットの浅いコピーを返します。

union（）、さまざまな（）、差分（）、対称差（）、の非演算子バージョンに注意してください。 ] issubset（）、および issuperset（）メソッドは、引数として反復可能なものを受け入れます。 対照的に、それらの演算子ベースの対応物は、それらの引数がセットである必要があります。 これにより、set('abc') & 'cbs'のようなエラーが発生しやすい構造が排除され、より読みやすいset('abc').intersection('cbs')が優先されます。

set と frozenset はどちらも、セットの比較をサポートします。 2つのセットは、各セットのすべての要素が他の要素に含まれている場合にのみ等しくなります（それぞれが他のサブセットです）。 最初のセットが2番目のセットの適切なサブセットである場合（サブセットであるが等しくない場合）に限り、セットは別のセットよりも小さくなります。 最初のセットが2番目のセットの適切なスーパーセットである場合（スーパーセットですが、等しくない場合）に限り、セットは別のセットよりも大きくなります。

set のインスタンスは、メンバーに基づいて frozenset のインスタンスと比較されます。 たとえば、set('abc') == frozenset('abc')はTrueを返し、set('abc') in set([frozenset('abc')])も返します。

サブセットと等式の比較は、全順序関数に一般化されません。 たとえば、2つの空でない互いに素なセットは等しくなく、互いにサブセットではないため、次の all はFalseを返します：a<b、 [X159X ]、またはa>b。

セットは半順序（サブセット関係）のみを定義するため、 list.sort（）メソッドの出力はセットのリストに対して未定義です。

辞書キーなどのセット要素は、ハッシュ可能である必要があります。

set インスタンスと frozenset を混合する二項演算は、最初のオペランドのタイプを返します。 例：frozenset('ab') | set('bc')は frozenset のインスタンスを返します。

次の表に、フリーズセットの不変インスタンスに適用されないセットで使用可能な操作を示します。

update(*others)
set |= other | ...

セットを更新し、他のすべての要素を追加します。

intersection_update(*others)
set &= other & ...

セットを更新し、セット内で見つかった要素と他のすべての要素のみを保持します。

difference_update(*others)
set -= other | ...

セットを更新し、他の要素で見つかった要素を削除します。

symmetric_difference_update(other)
set ^= other

セットを更新し、どちらかのセットで見つかった要素のみを保持しますが、両方では見つかりません。

add(elem)

要素 elem をセットに追加します。

remove(elem)

セットから要素 elem を削除します。 elem がセットに含まれていない場合、 KeyError を発生させます。

discard(elem)

要素 elem が存在する場合は、セットから削除します。

pop()

セットから任意の要素を削除して返します。 セットが空の場合、 KeyError を発生させます。

clear()

セットからすべての要素を削除します。

update（）、 section_update（）、 Difference_update（）、および symmetric_difference_update（）メソッドの非オペレーターバージョンに注意してください。 iterableを引数として受け入れます。

__contains__()、 remove（）、および discard（）メソッドの elem 引数が設定されている場合があることに注意してください。 同等のフリーズセットの検索をサポートするために、 elem から一時的なセットが作成されます。

マッピングタイプ— dict

マッピングオブジェクトは、ハッシュ可能値を任意のオブジェクトにマップします。 マッピングは可変オブジェクトです。 現在、標準のマッピングタイプは辞書のみです。 （他のコンテナーについては、組み込みのリスト、セット、タプルクラス、およびコレクションモジュールを参照してください。）

辞書のキーはほぼ任意の値です。 ハッシュ可能ではない値、つまり、リスト、辞書、またはその他の可変タイプ（オブジェクトIDではなく値によって比較される）を含む値は、キーとして使用できません。 キーに使用される数値タイプは、数値比較の通常の規則に従います。2つの数値が等しい場合（1と1.0など）、同じ辞書エントリにインデックスを付けるために交換可能に使用できます。 （ただし、コンピューターは浮動小数点数を近似値として格納するため、通常、それらを辞書キーとして使用することは賢明ではないことに注意してください。）

辞書は、key: valueペアのコンマ区切りリストを中かっこで囲むことによって作成できます。たとえば、{'jack': 4098, 'sjoerd': 4127}または{4098: 'jack', 4127: 'sjoerd'}、または dict コンストラクターによって作成できます。 。

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

オプションの定位置引数と、場合によっては空のキーワード引数のセットから初期化された新しい辞書を返します。

辞書はいくつかの方法で作成できます。

• 中括弧内のkey: valueペアのコンマ区切りリストを使用します：{'jack': 4098, 'sjoerd': 4127}または{4098: 'jack', 4127: 'sjoerd'}

• dict内包表記を使用する：{}、{x: x ** 2 for x in range(10)}

• 型コンストラクターを使用します：dict()、dict([('foo', 100), ('bar', 200)])、dict(foo=100, bar=200)

位置引数が指定されていない場合、空の辞書が作成されます。 位置引数が指定され、それがマッピングオブジェクトである場合、ディクショナリはマッピングオブジェクトと同じキーと値のペアで作成されます。 それ以外の場合、定位置引数は iterable オブジェクトである必要があります。 iterableの各アイテムは、それ自体が正確に2つのオブジェクトを持つiterableである必要があります。 各アイテムの最初のオブジェクトが新しいディクショナリのキーになり、2番目のオブジェクトが対応する値になります。 キーが複数回出現する場合、そのキーの最後の値が新しいディクショナリの対応する値になります。

キーワード引数が指定されている場合、キーワード引数とその値は、位置引数から作成された辞書に追加されます。 追加されるキーがすでに存在する場合、keyword引数の値がpositional引数の値に置き換わります。

説明のために、次の例はすべて{"one": 1, "two": 2, "three": 3}に等しい辞書を返します。

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True

最初の例のようにキーワード引数を指定すると、有効なPython識別子であるキーに対してのみ機能します。 それ以外の場合は、任意の有効なキーを使用できます。

これらは、ディクショナリがサポートする操作です（したがって、カスタムマッピングタイプもサポートする必要があります）。

list(d)

辞書 d で使用されているすべてのキーのリストを返します。

len(d)

辞書 d のアイテム数を返します。

d[key]

キーキーで d のアイテムを返します。 key がマップにない場合、 KeyError を発生させます。

dictのサブクラスがメソッド__missing__()を定義し、 key が存在しない場合、d[key]操作は、キー key を引数としてそのメソッドを呼び出します。 次に、d[key]演算は、__missing__(key)呼び出しによって返されるまたは発生するものをすべて返すか発生します。 他の操作やメソッドは__missing__()を呼び出しません。 __missing__()が定義されていない場合、 KeyError が発生します。 __missing__()はメソッドである必要があります。 インスタンス変数にすることはできません。

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

上記の例は、 collections.Counter の実装の一部を示しています。 別の__missing__メソッドが collections.defaultdict によって使用されます。

d[key] = value

d[key]を値に設定します。

del d[key]

d からd[key]を削除します。 key がマップにない場合、 KeyError を発生させます。

key in d

d にキーキーがある場合はTrueを返し、そうでない場合はFalseを返します。

key not in d

not key in dと同等です。

iter(d)

辞書のキーに対してイテレータを返します。 これはiter(d.keys())のショートカットです。

clear()

辞書からすべてのアイテムを削除します。

copy()

辞書の浅いコピーを返します。

classmethod fromkeys(iterable[, value])

iterable のキーと、 value に設定された値を使用して新しい辞書を作成します。

fromkeys（）は、新しい辞書を返すクラスメソッドです。 value のデフォルトはNoneです。 すべての値は単一のインスタンスのみを参照するため、通常、 value が空のリストなどの可変オブジェクトであることは意味がありません。 個別の値を取得するには、代わりに dict comprehension を使用してください。

get(key[, default])

key が辞書にある場合は、 key の値を返します。それ以外の場合は、 default を返します。 default が指定されていない場合、デフォルトでNoneになるため、このメソッドで KeyError が発生することはありません。

items()

辞書のアイテムの新しいビューを返します（(key, value)ペア）。 ビューオブジェクトのドキュメントを参照してください。

keys()

辞書のキーの新しいビューを返します。 ビューオブジェクトのドキュメントを参照してください。

pop(key[, default])

key が辞書にある場合は、それを削除してその値を返します。それ以外の場合は、 default を返します。 default が指定されておらず、 key が辞書にない場合、 KeyError が発生します。

popitem()

辞書から(key, value)ペアを削除して返します。 ペアは LIFO の順序で返されます。

popitem（）は、集合アルゴリズムでよく使用されるように、辞書を破壊的に反復するのに役立ちます。 辞書が空の場合、 popitem（）を呼び出すと、 KeyError が発生します。

バージョン3.7で変更： LIFOの注文が保証されるようになりました。 以前のバージョンでは、 popitem（）は任意のキー/値ペアを返していました。

reversed(d)

辞書のキーに対して逆イテレータを返します。 これはreversed(d.keys())のショートカットです。

バージョン3.8の新機能。

setdefault(key[, default])

key が辞書にある場合は、その値を返します。 そうでない場合は、値が default の key を挿入し、 default を返します。 default のデフォルトはNoneです。

update([other])

other のキーと値のペアで辞書を更新し、既存のキーを上書きします。 Noneを返します。

update（）は、別の辞書オブジェクトまたはキーと値のペアのイテラブル（タプルまたは長さ2の他のイテラブルとして）のいずれかを受け入れます。 キーワード引数が指定されている場合、ディクショナリは次のキーと値のペアで更新されます：d.update(red=1, blue=2)。

values()

ディクショナリの値の新しいビューを返します。 ビューオブジェクトのドキュメントを参照してください。

1つのdict.values()ビューと別のビューの等価比較では、常にFalseが返されます。 これは、dict.values()をそれ自体と比較する場合にも当てはまります。

>>> d = {'a': 1}
>>> d.values() == d.values()
False

d | other

d と other のキーと値をマージして、新しい辞書を作成します。これらは両方とも辞書である必要があります。 d と other がキーを共有する場合、 other の値が優先されます。

バージョン3.9の新機能。

d |= other

辞書 d を、 other のキーと値で更新します。キーと値のペアの mapping または iterable のいずれかです。 d と other がキーを共有する場合、 other の値が優先されます。

バージョン3.9の新機能。

辞書は、（順序に関係なく）同じ(key, value)ペアを持っている場合にのみ、同等に比較されます。 順序比較（ ' ='、 '>'） TypeError 。

辞書は挿入順序を保持します。 キーの更新は順序に影響しないことに注意してください。 削除後に追加されたキーは最後に挿入されます。

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

バージョン3.7で変更：辞書の順序は挿入順序であることが保証されています。 この動作は、3.6からのCPythonの実装の詳細でした。

辞書と辞書ビューはリバーシブルです。

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(reversed(d))
['four', 'three', 'two', 'one']
>>> list(reversed(d.values()))
[4, 3, 2, 1]
>>> list(reversed(d.items()))
[('four', 4), ('three', 3), ('two', 2), ('one', 1)]

バージョン3.8で変更：辞書がリバーシブルになりました。

も参照してください

types.MappingProxyType を使用して、 dict の読み取り専用ビューを作成できます。

辞書ビューオブジェクト

dict.keys（）、 dict.values（）、および dict.items（）によって返されるオブジェクトは、ビューオブジェクトです。 これらは、ディクショナリのエントリに関する動的なビューを提供します。つまり、ディクショナリが変更されると、ビューはこれらの変更を反映します。

ディクショナリビューを繰り返してそれぞれのデータを生成し、メンバーシップテストをサポートできます。

len(dictview)

辞書のエントリ数を返します。

iter(dictview)

ディクショナリ内のキー、値、またはアイテム（(key, value)のタプルとして表される）に対するイテレータを返します。

キーと値は挿入順に繰り返されます。 これにより、 zip（）：pairs = zip(d.values(), d.keys())を使用して(value, key)ペアを作成できます。 同じリストを作成する別の方法はpairs = [(v, k) for (k, v) in d.items()]です。

ディクショナリのエントリを追加または削除しているときにビューを反復すると、 RuntimeError が発生したり、すべてのエントリの反復に失敗したりする場合があります。

バージョン3.7で変更：辞書の順序は挿入順序であることが保証されています。

x in dictview

x が基礎となる辞書のキー、値、または項目にある場合は、Trueを返します（後者の場合、 x は(key, value)タプルである必要があります）。

reversed(dictview)

ディクショナリのキー、値、またはアイテムに対して逆イテレータを返します。 ビューは挿入の逆の順序で繰り返されます。

バージョン3.8で変更：辞書ビューがリバーシブルになりました。

dictview.mapping

ビューが参照する元のディクショナリをラップする types.MappingProxyType を返します。

バージョン3.10の新機能。

キービューは、エントリが一意でハッシュ可能であるため、セットのようになっています。 すべての値がハッシュ可能であり、(key, value)ペアが一意でハッシュ可能である場合、アイテムビューもセットのようになります。 （エントリは一般に一意ではないため、値ビューはセットのようなものとして扱われません。）セットのようなビューの場合、抽象基本クラス collections.abc.Set に対して定義されたすべての操作を使用できます（たとえば、==、<、または^）。

辞書ビューの使用例：

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}

>>> # get back a read-only proxy for the original dictionary
>>> values.mapping
mappingproxy({'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500})
>>> values.mapping['spam']
500

コンテキストマネージャーの種類

Pythonの with ステートメントは、コンテキストマネージャーによって定義されたランタイムコンテキストの概念をサポートします。 これは、ユーザー定義クラスがステートメント本体が実行される前に入力され、ステートメントが終了したときに終了するランタイムコンテキストを定義できるようにするメソッドのペアを使用して実装されます。

contextmanager.__enter__()

ランタイムコンテキストを入力し、このオブジェクトまたはランタイムコンテキストに関連する別のオブジェクトを返します。 このメソッドによって返される値は、このコンテキストマネージャーを使用して、 with ステートメントのas句の識別子にバインドされます。

自分自身を返すコンテキストマネージャーの例は、ファイルオブジェクトです。 ファイルオブジェクトは__enter __（）から戻り、 open（）を with ステートメントのコンテキスト式として使用できるようにします。

関連オブジェクトを返すコンテキストマネージャーの例は、 decimal.localcontext（）によって返されるものです。 これらのマネージャーは、アクティブな10進コンテキストを元の10進コンテキストのコピーに設定してから、そのコピーを返します。 これにより、withステートメントの外部のコードに影響を与えることなく、 with ステートメントの本文の現在の10進コンテキストに変更を加えることができます。

contextmanager.__exit__(exc_type, exc_val, exc_tb)

ランタイムコンテキストを終了し、発生した例外を抑制する必要があるかどうかを示すブールフラグを返します。 with ステートメントの本体の実行中に例外が発生した場合、引数には例外のタイプ、値、およびトレースバック情報が含まれます。 それ以外の場合、3つの引数はすべてNoneです。

このメソッドから真の値を返すと、 with ステートメントは例外を抑制し、withステートメントの直後のステートメントで実行を続行します。 それ以外の場合、このメソッドの実行が終了した後も例外は伝播し続けます。 このメソッドの実行中に発生した例外は、withステートメントの本文で発生した例外を置き換えます。

渡された例外を明示的に再発生させることはできません。代わりに、このメソッドはfalse値を返し、メソッドが正常に完了し、発生した例外を抑制したくないことを示します。 これにより、コンテキスト管理コードは、 __ exit __（）メソッドが実際に失敗したかどうかを簡単に検出できます。

Pythonは、簡単なスレッド同期、ファイルやその他のオブジェクトの迅速なクローズ、アクティブな10進算術コンテキストのより簡単な操作をサポートするためにいくつかのコンテキストマネージャーを定義しています。 特定のタイプは、コンテキスト管理プロトコルの実装を超えて特別に扱われることはありません。 いくつかの例については、 contextlib モジュールを参照してください。

Pythonの generator と contextlib.contextmanager デコレータは、これらのプロトコルを実装するための便利な方法を提供します。 ジェネレーター関数が contextlib.contextmanager デコレーターでデコレートされている場合、ジェネレーター関数は、によって生成されるイテレーターではなく、必要な__enter__()および__exit__()メソッドを実装するコンテキストマネージャーを返します。装飾されていないジェネレーター関数。

Python / C APIのPythonオブジェクトの型構造には、これらのメソッドのいずれにも特定のスロットがないことに注意してください。 これらのメソッドを定義する拡張タイプは、通常のPythonアクセス可能なメソッドとして提供する必要があります。 ランタイムコンテキストを設定するオーバーヘッドと比較して、単一クラスのディクショナリルックアップのオーバーヘッドはごくわずかです。

型注釈タイプ— 汎用エイリアス、ユニオン

型アノテーションのコア組み込み型は、汎用エイリアスとユニオンです。

一般的なエイリアスタイプ

GenericAliasオブジェクトは、list[int]などのクラス（通常はコンテナー）に添え字を付けることによって作成されます。 これらは主に型注釈を対象としています。

通常、コンテナオブジェクトのサブスクリプションは、オブジェクトのメソッド__getitem__()を呼び出します。 ただし、一部のコンテナのクラスのサブスクリプションは、代わりにクラスのクラスメソッド__class_getitem__()を呼び出す場合があります。 クラスメソッド__class_getitem__()は、GenericAliasオブジェクトを返す必要があります。

ノート

クラスのメタクラスの__getitem__()が存在する場合、クラスで定義されている__class_getitem__()よりも優先されます（詳細については、 PEP 560 を参照してください）。詳細）。

GenericAliasオブジェクトは、ジェネリック型のプロキシとして機能し、パラメーター化されたジェネリックを実装します。これは、コンテナー要素の型を提供するジェネリックの特定のインスタンスです。

GenericAliasオブジェクトのユーザー公開型は、 types.GenericAlias からアクセスでき、 isinstance（）チェックに使用できます。 GenericAliasオブジェクトを直接作成するためにも使用できます。

T[X, Y, ...]

使用するTに応じて、タイプ X 、 Y などの要素を含むタイプTを表すGenericAliasを作成します。 たとえば、 float 要素を含む list を期待する関数は次のとおりです。

def average(values: list[float]) -> float:
    return sum(values) / len(values)

マッピングオブジェクトの別の例。 dict を使用します。これは、キータイプと値タイプを表す2つのタイプパラメーターを期待するジェネリック型です。 この例では、関数は、タイプ str のキーとタイプ int の値を持つdictを想定しています。

def send_post_request(url: str, body: dict[str, int]) -> None:
    ...

組み込み関数 isinstance（）および issubclass（）は、2番目の引数にGenericAliasタイプを受け入れません。

>>> isinstance([1, 2], list[str])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot be a parameterized generic

Pythonランタイムは、型注釈を強制しません。 これは、ジェネリック型とその型パラメーターにまで及びます。 GenericAliasからオブジェクトを作成する場合、コンテナ要素はそのタイプに対してチェックされません。 たとえば、次のコードは推奨されていませんが、エラーなしで実行されます。

>>> t = list[str]
>>> t([1, 2, 3])
[1, 2, 3]

さらに、パラメーター化されたジェネリックスは、オブジェクトの作成中にタイプパラメーターを消去します。

>>> t = list[str]
>>> type(t)
<class 'types.GenericAlias'>

>>> l = t()
>>> type(l)
<class 'list'>

ジェネリックで repr（）または str（）を呼び出すと、パラメーター化された型が表示されます。

>>> repr(list[int])
'list[int]'

>>> str(list[int])
'list[int]'

ジェネリックスの__getitem__()メソッドは、dict[str][str]のような間違いを許可しない例外を発生させます。

>>> dict[str][str]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: There are no type variables left in dict[str]

ただし、このような式は、型変数が使用されている場合に有効です。 インデックスには、GenericAliasオブジェクトの __ args __ の型変数アイテムと同じ数の要素が含まれている必要があります。

>>> from typing import TypeVar
>>> Y = TypeVar('Y')
>>> dict[str, Y][int]
dict[str, int]

標準のジェネリックコレクション

これらの標準ライブラリコレクションは、パラメータ化されたジェネリックをサポートしています。

• tuple
• list
• dict
• set
• frozenset
• type
• collections.deque
• collections.defaultdict
• collections.OrderedDict
• collections.Counter
• collections.ChainMap
• collections.abc.Awaitable
• collections.abc.Coroutine
• collections.abc.AsyncIterable
• collections.abc.AsyncIterator
• collections.abc.AsyncGenerator
• collections.abc.Iterable
• collections.abc.Iterator
• collections.abc.Generator
• collections.abc.Reversible
• collections.abc.Container
• collections.abc.Collection
• collections.abc.Callable
• collections.abc.Set
• collections.abc.MutableSet
• collections.abc.Mapping
• collections.abc.MutableMapping
• collections.abc.Sequence
• collections.abc.MutableSequence
• collections.abc.ByteString
• collections.abc.MappingView
• collections.abc.KeysView
• collections.abc.ItemsView
• collections.abc.ValuesView
• contextlib.AbstractContextManager
• contextlib.AbstractAsyncContextManager
• re.Pattern
• 再戦

ジェネリックエイリアスの特別な属性

すべてのパラメーター化されたジェネリックは、特別な読み取り専用属性を実装します。

genericalias.__origin__

この属性は、パラメーター化されていないジェネリッククラスを指します。

>>> list[int].__origin__
<class 'list'>

genericalias.__args__

この属性は、ジェネリックコンテナの元の__class_getitem__()に渡されるジェネリック型のタプル（おそらく長さ1）です。

>>> dict[str, list[int]].__args__
(<class 'str'>, list[int])

genericalias.__parameters__

この属性は、__args__にある一意の型変数の遅延計算されたタプル（おそらく空）です。

>>> from typing import TypeVar

>>> T = TypeVar('T')
>>> list[T].__parameters__
(~T,)

ノート

typing.ParamSpec パラメータを持つGenericAliasオブジェクトは、 typing.ParamSpec が主に静的型チェックを目的としているため、置換後に正しい__parameters__を持たない場合があります。

も参照してください

• PEP 585 –「標準コレクションの型ヒントジェネリック」
• __class_getitem__() –パラメーター化されたジェネリックを実装するために使用されます。
• Generics – タイピングモジュールのジェネリック。

バージョン3.9の新機能。

共用体タイプ

和集合オブジェクトは、複数の型オブジェクトに対する|（ビット単位または）演算の値を保持します。 これらの型は、主に型注釈を対象としています。 共用体型式を使用すると、 typing.Union と比較してよりクリーンな型ヒント構文が可能になります。

X | Y | ...

タイプ X 、 Y などを保持するユニオンオブジェクトを定義します。 X | YはXまたはYのいずれかを意味します。 typing.Union[X, Y]と同等です。 たとえば、次の関数は、タイプ int または float の引数を想定しています。

def square(number: int | float) -> int | float:
    return number ** 2

union_object == other

ユニオンオブジェクトは、他のユニオンオブジェクトとの同等性をテストできます。 詳細：

• 諸同盟連合は平坦化されます：

  (int | str) | float == int | str | float

• 冗長タイプが削除されました：

  int | str | int == int | str

• ユニオンを比較する場合、順序は無視されます。

  int | str == str | int

• typing.Union と互換性があります：

  int | str == typing.Union[int, str]

• オプション型は、Noneとの和集合として綴ることができます。

  str | None == typing.Optional[str]

isinstance(obj, union_object)

issubclass(obj, union_object)

isinstance（）および issubclass（）の呼び出しも、ユニオンオブジェクトでサポートされています。

>>> isinstance("", int | str)
True

ただし、パラメーター化されたジェネリックスを含むユニオンオブジェクトは使用できません。

>>> isinstance(1, int | list[int])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot contain a parameterized generic

共用体オブジェクトのユーザー公開型は、 types.UnionType からアクセスでき、 isinstance（）チェックに使用できます。 次のタイプからオブジェクトをインスタンス化することはできません。

>>> import types
>>> isinstance(int | str, types.UnionType)
True
>>> types.UnionType()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot create 'types.UnionType' instances

ノート

構文X | Yをサポートするために、型オブジェクトの__or__()メソッドが追加されました。 メタクラスが__or__()を実装している場合、Unionはそれをオーバーライドできます。

>>> class M(type):
...     def __or__(self, other):
...         return "Hello"
...
>>> class C(metaclass=M):
...     pass
...
>>> C | int
'Hello'
>>> int | C
int | __main__.C

も参照してください

PEP 604 – X | Y構文と共用体型を提案するPEP。

バージョン3.10の新機能。

その他の組み込み型

インタプリタは、他のいくつかの種類のオブジェクトをサポートします。 これらのほとんどは、1つまたは2つの操作のみをサポートします。

モジュール

モジュールに対する唯一の特別な操作は属性アクセスです：m.name、ここで m はモジュールであり、 name は m 'で定義された名前にアクセスします■シンボルテーブル。 モジュール属性を割り当てることができます。 （ import ステートメントは、厳密に言えば、モジュールオブジェクトに対する操作ではないことに注意してください。import fooは、 foo という名前のモジュールオブジェクトが存在する必要はなく、存在する必要があります。 foo という名前のモジュールの（外部）定義が必要です。）

すべてのモジュールの特別な属性は __ dict __ です。 これは、モジュールのシンボルテーブルを含む辞書です。 このディクショナリを変更すると、実際にはモジュールのシンボルテーブルが変更されますが、 __ dict __ 属性に直接割り当てることはできません（m.aを1ですが、m.__dict__ = {}）と書くことはできません。 __ dict __ を直接変更することはお勧めしません。

インタプリタに組み込まれているモジュールは、<module 'sys' (built-in)>のように記述されています。 ファイルからロードする場合は、<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>と表記します。

クラスとクラスインスタンス

これらについては、オブジェクト、値、およびタイプおよびクラス定義を参照してください。

関数

関数オブジェクトは、関数定義によって作成されます。 関数オブジェクトに対する唯一の操作は、それを呼び出すことです：func(argument-list)。

関数オブジェクトには、組み込み関数とユーザー定義関数の2種類があります。 どちらも（関数を呼び出すための）同じ操作をサポートしますが、実装が異なるため、オブジェクトタイプが異なります。

詳細については、関数定義を参照してください。

メソッド

メソッドは、属性表記を使用して呼び出される関数です。 組み込みメソッド（リストのappend()など）とクラスインスタンスメソッドの2つのフレーバーがあります。 組み込みメソッドは、それらをサポートするタイプで説明されています。

インスタンスを介してメソッド（クラス名前空間で定義された関数）にアクセスすると、特別なオブジェクト、バインドされたメソッド（インスタンスメソッドとも呼ばれます）オブジェクトを取得します。 呼び出されると、self引数が引数リストに追加されます。 バインドされたメソッドには、2つの特別な読み取り専用属性があります。m.__self__はメソッドが動作するオブジェクトであり、m.__func__はメソッドを実装する関数です。 m(arg-1, arg-2, ..., arg-n)を呼び出すことは、m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)を呼び出すことと完全に同等です。

関数オブジェクトと同様に、バインドされたメソッドオブジェクトは任意の属性の取得をサポートします。 ただし、メソッド属性は実際には基になる関数オブジェクト（meth.__func__）に格納されるため、バインドされたメソッドにメソッド属性を設定することは許可されていません。 メソッドに属性を設定しようとすると、 AttributeError が発生します。 メソッド属性を設定するには、基になる関数オブジェクトに明示的に設定する必要があります。

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

詳細については、標準タイプ階層を参照してください。

コードオブジェクト

コードオブジェクトは、関数本体などの「疑似コンパイルされた」実行可能Pythonコードを表すために実装によって使用されます。 グローバル実行環境への参照が含まれていないため、関数オブジェクトとは異なります。 コードオブジェクトは、組み込みの compile（）関数によって返され、__code__属性を介して関数オブジェクトから抽出できます。 コードモジュールも参照してください。

__code__にアクセスすると、監査イベント object.__getattr__が引数objおよび"__code__"で発生します。

コードオブジェクトは、（ソース文字列の代わりに） exec（）または eval（）組み込み関数に渡すことで実行または評価できます。

詳細については、標準タイプ階層を参照してください。

タイプオブジェクト

タイプオブジェクトは、さまざまなオブジェクトタイプを表します。 オブジェクトの型には、組み込み関数 type（）によってアクセスされます。 タイプに特別な操作はありません。 標準モジュール types は、すべての標準組み込み型の名前を定義します。

タイプは次のように記述されます：<class 'int'>。

ヌルオブジェクト

このオブジェクトは、値を明示的に返さない関数によって返されます。 特別な操作はサポートしていません。 None（組み込み名）という名前のnullオブジェクトが1つだけあります。 type(None)()は同じシングルトンを生成します。

Noneと表記されています。

楕円オブジェクト

このオブジェクトは通常、スライスによって使用されます（スライスを参照）。 特別な操作はサポートしていません。 Ellipsis （組み込み名）という名前の省略記号オブジェクトが1つだけあります。 type(Ellipsis)()は、 Ellipsis シングルトンを生成します。

Ellipsisまたは...と表記されます。

NotImplementedオブジェクト

このオブジェクトは、サポートされていない型を操作するように求められたときに、比較および二項演算から返されます。 詳細については、比較を参照してください。 NotImplementedオブジェクトは1つだけです。 type(NotImplemented)()はシングルトンインスタンスを生成します。

NotImplementedと表記されています。

ブール値

ブール値は、2つの定数オブジェクトFalseとTrueです。 これらは真理値を表すために使用されます（ただし、他の値も偽または真と見なすことができます）。 数値コンテキスト（たとえば、算術演算子の引数として使用される場合）では、それぞれ整数0および1のように動作します。 組み込み関数 bool（）は、値が真理値として解釈できる場合、任意の値をブール値に変換するために使用できます（上記のセクション真理値テストを参照）。

それぞれFalseおよびTrueと表記されます。

内部オブジェクト

この情報については、標準タイプ階層を参照してください。 スタックフレームオブジェクト、トレースバックオブジェクト、およびスライスオブジェクトについて説明します。

特別な属性

実装は、関連するいくつかのオブジェクトタイプにいくつかの特別な読み取り専用属性を追加します。 これらの一部は、 dir（）組み込み関数によって報告されません。

object.__dict__

オブジェクトの（書き込み可能な）属性を格納するために使用されるディクショナリまたはその他のマッピングオブジェクト。

instance.__class__

クラスインスタンスが属するクラス。

class.__bases__

クラスオブジェクトの基本クラスのタプル。

definition.__name__

クラス、関数、メソッド、記述子、またはジェネレーターインスタンスの名前。

definition.__qualname__

クラス、関数、メソッド、記述子、またはジェネレーターインスタンスの修飾名。

バージョン3.3の新機能。

class.__mro__

この属性は、メソッドの解決中に基本クラスを検索するときに考慮されるクラスのタプルです。

class.mro()

このメソッドをメタクラスでオーバーライドして、インスタンスのメソッド解決順序をカスタマイズできます。 クラスのインスタンス化時に呼び出され、その結果は __ mro __ に格納されます。

class.__subclasses__()

各クラスは、その直接のサブクラスへの弱参照のリストを保持します。 このメソッドは、まだ生きているすべての参照のリストを返します。 リストは定義順になっています。 例：

>>> int.__subclasses__()
[<class 'bool'>]

脚注

1

これらの特別なメソッドの詳細については、Pythonリファレンスマニュアル（基本的なカスタマイズ）を参照してください。

2

結果として、リスト[1, 2]は[1.0, 2.0]と等しいと見なされ、タプルについても同様です。

3

パーサーはオペランドのタイプを判別できないため、これらは持っている必要があります。

4（ 1 、 2 、 3 、 4 ）

大文字と小文字を区別する文字は、一般的なカテゴリプロパティが「Lu」（文字、大文字）、「Ll」（文字、小文字）、または「Lt」（文字、タイトルケース）のいずれかである文字です。

5（ 1 、 2 ）

したがって、タプルのみをフォーマットするには、フォーマットするタプルのみが要素であるシングルトンタプルを提供する必要があります。